def visitWhileStat(self, ctx): if self._debug: print("while statement, condition is:") print(Trees.toStringTree(ctx.expr(), None, self._parser)) print("and block is:") print(Trees.toStringTree(ctx.stat_block(), None, self._parser)) raise NotImplementedError()
def visitCondBlock(self, ctx): if self._debug: print("condblockstatement, condition is:") print(Trees.toStringTree(ctx.expr(), None, self._parser)) print("and block is:") print(Trees.toStringTree(ctx.stat_block(), None, self._parser)) pass # TODO
def visitWhileStat(self, ctx): if self._debug: print("while statement, condition is:") print(Trees.toStringTree(ctx.expr(), None, self._parser)) print("and block is:") print(Trees.toStringTree(ctx.stat_block(), None, self._parser)) print("je suis là") pass # TODO
def visitCondBlock(self, ctx): if self._debug: print("condblockstatement, condition is:") print(Trees.toStringTree(ctx.expr(), None, self._parser)) print("and block is:") print(Trees.toStringTree(ctx.stat_block(), None, self._parser)) end_if = self.ctx_stack[-1] # get the label for the end! raise NotImplementedError()
def visitWhileStat(self, ctx): if self._debug: print("while statement, condition is:") print(Trees.toStringTree(ctx.expr(), None, self._parser)) print("and block is:") print(Trees.toStringTree(ctx.stat_block(), None, self._parser)) ltest1 = self._current_function.new_label("ltest1") lendwhile1 = self._current_function.new_label("lendwhile") self._current_function.addLabel(ltest1) tmp4=self.visit(ctx.expr()) self._current_function.addInstructionCondJUMP(lendwhile1,tmp4,Condition(MiniCParser.EQ),0) self.visit(ctx.stat_block()) self._current_function.addInstructionJUMP(ltest1) self._current_function.addLabel(lendwhile1)
def visitWhileStat(self, ctx): if self._debug: print("while statement, condition is:") print(Trees.toStringTree(ctx.expr(), None, self._parser)) print("and block is:") print(Trees.toStringTree(ctx.stat_block(), None, self._parser)) labelbegin, labelend = self._current_function.new_label_while() self._current_function.addLabel(labelbegin) reg = self.visit(ctx.expr()) self._current_function.addInstructionCondJUMP(labelend, reg, Condition("beq"), 0) self.visit(ctx.stat_block()) self._current_function.addInstructionJUMP(labelbegin) self._current_function.addLabel(labelend)
def visitCondBlock(self, ctx): if self._debug: print("condblockstatement, condition is:") print(Trees.toStringTree(ctx.expr(), None, self._parser)) print("and block is:") print(Trees.toStringTree(ctx.stat_block(), None, self._parser)) tmp4=self.visit(ctx.expr()) lendif1 = self._current_function.new_label("lendif") self._current_function.addInstructionCondJUMP(lendif1,tmp4,Condition(MiniCParser.EQ),0) self.visit(ctx.stat_block()) end_if=self.ctx_stack[-1] self._current_function.addInstructionJUMP(end_if) self._current_function.addLabel(lendif1) return tmp4
def visitCondBlock(self, ctx): if self._debug: print("condblockstatement, condition is:") print(Trees.toStringTree(ctx.expr(), None, self._parser)) print("and block is:") print(Trees.toStringTree(ctx.stat_block(), None, self._parser)) end_if = self.ctx_stack[-1] # get the label for the end! next_cond = self._current_function.new_label('end_cond') cond = self.visit(ctx.expr()) self._current_function.addInstructionCondJUMP(next_cond, cond, Condition("beq"), 0) self.visit(ctx.stat_block()) self._current_function.addInstructionJUMP(end_if) self._current_function.addLabel(next_cond)
def visitCondBlock(self, ctx): if self._debug: print("condblockstatement, condition is:") print(Trees.toStringTree(ctx.expr(), None, self._parser)) print("and block is:") print(Trees.toStringTree(ctx.stat_block(), None, self._parser)) end_if = self.ctx_stack[-1] next_cond = self._prog.new_label('end_cond') cond = self.visit(ctx.expr()) src_cond = self._prog.addInstructionCondJUMP(next_cond, cond, Condition('eq'), Immediate(0)) self.visit(ctx.stat_block()) i = self._prog.addInstructionJUMP(end_if) self._prog.addLabel(next_cond) return src_cond
def visitRelationalExpr(self, ctx): c = Condition(ctx.myop.type) if self._debug: print("relational expression:") print(Trees.toStringTree(ctx, None, self._parser)) print("Condition:", c) raise NotImplementedError()
def parse( text: str, start: str, strict=False, transform: Union[str, Callable] = None, error_listener: ErrorListener = None, ) -> ParseTree: lexer = LexerGo(antlr4.InputStream(text)) lexer.removeErrorListeners() lexer.addErrorListener(LexerErrorListener()) stream = CommonTokenStream(lexer) parser = ParserGo(stream) tree = parser.sourceFile() printer = ParserGoListener() walker = ParseTreeWalker() walker.walk(printer, tree) visitor = ParserGoVisitor() parser.buildParseTrees = True # default if strict: error_listener = StrictErrorListener() if error_listener is not None and error_listener is not True: parser.removeErrorListeners() if error_listener: parser.addErrorListener(error_listener) print(Trees.toStringTree(tree, None, parser)) return tree
def parse(argv): if len(sys.argv) > 1: input = FileStream(argv[1]) #read the first argument as a filestream lexer = DecafLexer(input) #call your lexer stream = CommonTokenStream(lexer) #stream.fill() #print(stream.tokens) #tokencitos = ([token.text for token in stream.tokens]) #print(tokencitos) parser = DecafParser(stream) tree = parser.program( ) #start from the parser rule, however should be changed to your entry rule for your specific grammar #pydot__tree_to_png(tree, "./tree.png") traverse(tree, parser.ruleNames) traverse_intermediate_code(tree, parser.ruleNames) f = open('treegen.txt', 'w') f.write((Trees.toStringTree(tree, None, parser))) f.close() #printer = DecafListener() printer = ImpListener() walker = ParseTreeWalker() walker.walk(printer, tree) #print(walker) else: print('Error : Expected a valid file')
def main(): ais = FileStream(sys.argv[1]) lexer = myGrammarLexer(ais) tokens = CommonTokenStream(lexer) parser = myGrammarParser(tokens) tree = parser.rules() print Trees.toStringTree(tree, None, parser) # generating dot file walker = ParseTreeWalker() collector = FunctionListener() walker.walk(collector, tree) print collector.graph.toDOT() # using graphviz subprocess.check_call(["dot", "-Tpng", "test.dot", "-o", "dt.png"])
def visitWhileStat(self, ctx): if self._debug: print("while statement, condition is:") print(Trees.toStringTree(ctx.expr(), None, self._parser)) print("and block is:") print(Trees.toStringTree(ctx.stat_block(), None, self._parser)) test = self._prog.new_label("test") end_while = self._prog.new_label("end_while") self._prog.addLabel(test) dr = self.visit(ctx.expr()) #If expr is false, jump to end self._prog.addInstructionCondJUMP(end_while, dr, Condition(MuParser.EQ), 0) #else execute code self.visit(ctx.stat_block()) self._prog.addInstructionJUMP(test) self._prog.addLabel(end_while)
def visitCondBlock(self, ctx): if self._debug: print("condblockstatement, condition is:") print(Trees.toStringTree(ctx.expr(), None, self._parser)) print("and block is:") print(Trees.toStringTree(ctx.stat_block(), None, self._parser)) end_if = self.ctx_stack[-1] # get the label for the end! end_cond = self._prog.new_label("end_cond") dr = self.visit(ctx.expr()) #If condition (in dr) is false jump to endif self._prog.addInstructionCondJUMP(end_cond, dr, Condition(MuParser.EQ), 0) #Else condition is true self.visit(ctx.stat_block()) self._prog.addInstructionJUMP(end_if) self._prog.addLabel(end_cond)
def visitRelationalExpr(self, ctx): if self._debug: print("relational expression:") print(Trees.toStringTree(ctx, None, self._parser)) tmpl = self.visit(ctx.expr(0)) tmpr = self.visit(ctx.expr(1)) c = Condition(ctx.myop.type) raise NotImplementedError()
def generate_tree(cls, code_line): tree, parser = get_grammar_tree(code_text=code_line) test_tree = Trees.getChildren(tree)[0] string_tree = Trees.toStringTree(test_tree, recog=parser) string_tree = string_tree.replace('( (', '[ (').replace(') )', ') ]') return Tree.fromstring(string_tree)
def aster(path): dir_path = os.path.dirname(os.path.abspath(path)) name = os.path.splitext(os.path.basename(path))[0] lexer = BasisLexer(FileStream(path)) stream = CommonTokenStream(lexer) parser = BasisParser(stream) ast = parser.program() with open(dir_path + "\\" + name + ".rkt", 'w') as f: f.write(Trees.toStringTree(ast, None, parser)) f.close()
def aster(path): dir_path = os.path.dirname(os.path.abspath(path)) name = os.path.splitext(os.path.basename(path))[0] lexer = WenyanLexer(FileStream(path, encoding='utf8')) stream = CommonTokenStream(lexer) parser = WenyanParser(stream) ast = parser.program() with open('ast/' + name + ".txt", 'w') as f: f.write(Trees.toStringTree(ast, None, parser)) f.close()
def main(): with open(args.file, "r") as file: lines = file.read() input_stream = InputStream(lines) # input_stream = FileStream(args.file) lexer = testLexer(input_stream) token_stream = CommonTokenStream(lexer) parser = testParser(token_stream) tree = parser.module() print(Trees.toStringTree(tree, None, parser))
def visitAssignStat(self, ctx): if self._debug: print("assign statement, rightexpression is:") print(Trees.toStringTree(ctx.expr(), None, self._parser)) reg4expr = self.visit(ctx.expr()) name = ctx.ID().getText() if name in self._memory: self._current_function.addInstructionMV(self._memory[name], reg4expr) else: raise Exception("Variable is not declared")
def main(argv): print "Parsing: " + argv[1] + "\n" input = FileStream(argv[1]) lexer = SQLiteLexer(input) stream = CommonTokenStream(lexer) parser = SQLiteParser(stream) tree = parser.parse() print(Trees.toStringTree(tree, None, parser))
def main(): with open(args.file, "r") as file: lines = file.read() input_stream = InputStream(lines) # input_stream = FileStream(args.file) lexer = new_milestoneLexer(input_stream) token_stream = CommonTokenStream(lexer) parser = new_milestoneParser(token_stream) tree = parser.module( ) #start from the parser rule, however should be changed to your entry rule for your specific grammar. print(Trees.toStringTree(tree, None, parser))
def main(): parser = argparse.ArgumentParser() parser.add_argument('input', help='input_file') parser.add_argument('-AST', '--ast_flag', action='store_true', default=False, help="ast_flag") parser.add_argument('-treegraph', '--tree_flag', action='store_true', default=False, help="tree_flag") args = parser.parse_args() if args.input is None: print("Instruction Error!") print("Usage : python MiniJava.py demo.java [-AST -treegraph]") input = FileStream(args.input) print("------------------------") print("Lexical and Syntax Check...") lexer = MiniJavaLexer(input) stream = CommonTokenStream(lexer) parser = MiniJavaParser(stream) #parser.removeErrorListeners() #parser.addErrorListener(MiniJavaErrorListener()) tree = parser.goal() print("Lexical and Syntax Check Done.") print("------------------------") print("Semantic Check...") visitor = MyVisitor() visitor.visit(tree) print("Semantic Check Done.") print("------------------------") if args.ast_flag: print("AST string:") print(Trees.toStringTree(tree, None, parser)) print("------------------------") if args.tree_flag: print("Generate Parse Tree...") DFS(tree, 0, "") dot.format = 'png' dot.render('tree.gv', view=True) print("Generate Parse Tree Finished.")
def main(argv): input = FileStream(argv[1]) lexer = MatexLexer(input) stream = CommonTokenStream(lexer) parser = MatexParser(stream) tree = parser.math() print(Trees.toStringTree(tree, None, parser)) ast = MatexAST() walker = ParseTreeWalker() walker.walk(ast, tree) print(str(ast))
def main(): with open(args.file, "r") as file: lines = file.read() input_stream = InputStream(lines) lexer = milestone_2Lexer(input_stream) token_stream = CommonTokenStream(lexer) parser = milestone_2Parser(token_stream) tree = parser.start() print(Trees.toStringTree(tree, None, parser)) token = lexer.nextToken() out = open("milestone_2_result.txt", "w+")
def main(): '''Main entry point for the dfs CLI.''' args = docopt(__doc__, version=__version__) dslfile = args["FILE"] input = FileStream(dslfile) lexer = FinalStatePatternLexer(input) stream = CommonTokenStream(lexer) parser = FinalStatePatternParser(stream) tree = parser.top_level() traverser = FSPOntologyListener() walker = ParseTreeWalker() walker.walk(traverser, tree) print(Trees.toStringTree(tree, None, parser))
def test_parse_array(self): input = InputStream("{1,2,3}") lexer = ArrayInitLexer(input=input) tokens = CommonTokenStream(lexer) parser = ArrayInitParser(tokens) tree = parser.init() tree_str = Trees.toStringTree(tree, None, parser).replace(" ", "") expected_tree = "(init {(value 1),(value 2),(value 3)})".replace( " ", "") self.assertEqual( tree_str, expected_tree, msg=f"Expected\n\t{expected_tree}\n, but found\n\t{tree_str}", )
def visitRelationalExpr(self, ctx): if self._debug: print("relational expression:") print(Trees.toStringTree(ctx, None, self._parser)) tmpl = self.visit(ctx.expr(0)) tmpr = self.visit(ctx.expr(1)) c = Condition(ctx.myop.type) dest = self._prog.new_tmp() end_relational = self._prog.new_label('end_relational') self._prog.addInstructionLETI(dest, 0) self._prog.addInstructionCondJUMP( end_relational, tmpl, c.negate(), tmpr) self._prog.addInstructionLETI(dest, 1) self._prog.addLabel(end_relational) return dest
def visitRelationalExpr(self, ctx): c = Condition(ctx.myop.type) tmp0=self.visit(ctx.expr(0)) tmp1=self.visit(ctx.expr(1)) tmp4=self._current_function.new_tmp() if self._debug: print("relational expression:") print(Trees.toStringTree(ctx, None, self._parser)) print("Condition:", c) endrl = self._current_function.new_label("endrl") self._current_function.addInstructionLI(tmp4,0) self._current_function.addInstructionCondJUMP(endrl,tmp0,c.negate(),tmp1) self._current_function.addInstructionLI(tmp4,1) self._current_function.addLabel(endrl) return tmp4
def parse(self, sql): in_stream = InputStream(sql) lexer = SparksqlLexer(in_stream) token_stream = CommonTokenStream(lexer) try: parser = SparksqlParser(token_stream) parser._listeners = [CustomErrorListener()] self.tree = parser.select_statement() self.tree_str = Trees.toStringTree(self.tree, None, parser) self.is_valid = True except Exception as ex: self.is_valid = False self.error = ex
def __parse_meta_data__(input_stream, silent=False, print_parse_tree=False): lexer = PWE_ASP_Meta_DataLexer(input_stream) # use this line to take input from the cmd line # lexer = PWE_ASP_Meta_DataLexer(StdinStream()) ct_stream = CommonTokenStream(lexer) parser = PWE_ASP_Meta_DataParser(ct_stream) tree = parser.aspFile() if print_parse_tree: print(Trees.toStringTree(tree, None, parser)) asp_meta_data_listener = AntlrPWEMetaDataListener() asp_meta_data_listener.silent = silent walker = ParseTreeWalker() walker.walk(asp_meta_data_listener, tree) return asp_meta_data_listener.meta_data
def parse(self, sql): in_stream = InputStream(sql) lexer = SparksqlLexer(in_stream) token_stream = CommonTokenStream(lexer) try: parser = SparksqlParser(token_stream) parser._listeners = [CustomErrorListener()] self.tree = parser.select_statement() self.tree_str = Trees.toStringTree(self.tree, None, parser) self.is_valid = True except Exception as ex: self.is_valid = False self.error = ex
def parse(formula: str): f = InputStream(formula) lexer = FODTLLexer(f) stream = CommonTokenStream(lexer) parser = FODTLParser(stream) parser.addParseListener(FodtlParser()) parser.buildParseTrees = True # TODO : important prediction mode optimization (we gain x5 speed up with SLL) # use SLL for the first pass, if an error detected we probably have to make a second pass # using LL mode (to check, see the doc) # parser._interp.predictionMode = PredictionMode.LL # ~2.5 parser._interp.predictionMode = PredictionMode.SLL # ~0.4 # parser._interp.predictionMode = PredictionMode.LL_EXACT_AMBIG_DETECTION # ~2.5 tr = parser.main() bt = Trees.toStringTree(tr, recog=parser) # print(bt) l = parser.getParseListeners().pop(0) return l.formula
def toStringTree(self, ruleNames=None, recog=None): return Trees.toStringTree(self, ruleNames=ruleNames, recog=recog)
def toStringTree(self, ruleNames: list = None, recog: Parser = None): return Trees.toStringTree(self, ruleNames=ruleNames, recog=recog)
def loop(self): while True: try: if self.readMore: sys.stdout.write("... ") sys.stdout.flush() self.single_input += sys.stdin.readline() else: sys.stdout.write(">>> ") sys.stdout.flush() self.single_input = sys.stdin.readline() input_stream = antlr4.InputStream(self.single_input) # Instantiate and run generated lexer self.lexer = CustomLexer(input_stream) self.tokens = antlr4.CommonTokenStream(self.lexer) # Setting up error handling stuff error_handler = CustomErrorStrategy() error_listener = CustomErrorListener() buffered_errors = BufferedErrorListener() error_listener.addDelegatee(buffered_errors) # Run parser and set error handler self.parser = TinyPyParser(self.tokens) self.parser._errHandler = error_handler # Remove default terminal error listener & and our own self.parser.removeErrorListeners() self.parser.addErrorListener(error_listener) # Parse input parse_tree = self.parser.single_input() # Determine what to do next if error_listener.eof_received: print() exit(0) elif error_listener.input_unfinished or self.lexer.opened > 0: # User has not finished his input yet, read the next line and repeat self.readMore = True continue elif error_listener.errors_encountered > 0: # Errors encountered, start over print(buffered_errors.buffer) self.readMore = False continue else: # Successfully parsed the input, next time start over self.readMore = False # Build a flattened syntax tree cst = CST.CstFiltered(tree=parse_tree) # Print some stuff... (if needed) if self.args.cst: print(cst) if self.args.parse_tree: parseTreeString = Trees.toStringTree(parse_tree, recog=self.parser) print(parseTreeString) # Evaluate it... visitor = CustomVisitor() ast = visitor.visitSingle_input(parse_tree) if ast == None: continue if self.args.parse_only: continue results = ast.eval() # # ast.eval() returns list of statements; loop through them and print # if results != None: for statement in results: if statement != None and not isinstance(statement, ControlFlowMark): sys.displayhook(statement) #if results != None: # sys.displayhook(results) except KeyboardInterrupt as e: print("") exit(0) except antlr4.RecognitionException as e: print("Caught" + str(e) ) except runtime.Errors.BaseRuntimeException as e: print(e.__class__.__name__ + ": " + str(e)) except SystemExit as e: sys.exit(e) except BaseException as e: print(e.__class__.__name__ + ": " + str(e))