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))
