def main():
input = InputStream(sys.stdin.read())
lexer = ExprLexer(input)
tokens = CommonTokenStream(lexer)
parser = ExprParser(tokens)
tree = parser.expr() # 取得一颗以 expr 为根的 AST
print(tree.toStringTree(recog=parser))
def compile(self, srcfile, base_dir, output_dir):
#fp = codecs.open(sys.argv[1], 'r', 'utf-8')
fp = open(srcfile, 'r')
char_stream = antlr3.ANTLRInputStream(fp)
lexer = ExprLexer(char_stream)
tokens = antlr3.CommonTokenStream(lexer)
parser = ExprParser(tokens)
r = parser.prog()
# this is the root of the AST
root = r.tree
#print (root.toStringTree())
#print '-------'
nodes = antlr3.tree.CommonTreeNodeStream(root)
nodes.setTokenStream(tokens)
from Eval import Eval
eval = Eval(nodes)
#######################################
head, tail = os.path.split(srcfile)
if not os.path.exists(output_dir):
os.mkdir(output_dir)
if not os.path.exists(output_dir + '/__init__.py'):
fp = open(output_dir + '/__init__.py', 'w')
fp.close()
dstfile = os.path.normpath(output_dir + '/' + tail.split('.')[0] + '.py')
#print 'compile: %-30s=> %s' % (srcfile, dstfile)
cpy = CpyBuilder(dstfile, base_dir, output_dir)
eval.prog(cpy)
return dstfile
def evaluateDTS(varTs, line):
istream = InputStream(line)
lexer = ExprLexer(istream)
token_stream = CommonTokenStream(lexer)
parser = ExprParser(token_stream)
parser.varTs = varTs
parser.expression()
def main():
input = InputStream(sys.stdin.read())
lexer = ExprLexer(input)
tokens = CommonTokenStream(lexer)
parser = ExprParser(tokens)
tree = parser.expr() # 取得一颗以 expr 为根的 AST
visitor = EvalVisitor()
print(tree.accept(visitor))
def main():
input = InputStream(sys.stdin.read())
lexer = ExprLexer(input)
tokens = CommonTokenStream(lexer)
parser = ExprParser(tokens)
parser._errHandler = BailErrorStrategy() # 设置错误处理
tree = parser.expr() # 取得一棵以 expr 为根的 AST
print(tree.toStringTree(recog=parser))
def main():
input = InputStream(sys.stdin.read())
lexer = ExprLexer(input)
tokens = CommonTokenStream(lexer)
parser = ExprParser(tokens)
parser._errHandler = BailErrorStrategy() # 设置错误处理
tree = parser.expr() # 取得一棵以 expr 为根的 AST
visitor = EvalVisitor()
print(tree.accept(visitor))
def main(argv):
input_stream = FileStream(argv[1])
lexer = ExprLexer(input_stream)
stream = CommonTokenStream(lexer)
parser = ExprParser(stream)
parser.buildParseTrees = True
parser_tree = parser.prog()
expressoes = ConcreteExprListener()
ParseTreeWalker.DEFAULT.walk(expressoes, parser_tree)
for expressao in expressoes.values:
print('{} = {}'.format(expressao['expr'], expressao['value']))
def parse():
char_stream = antlr3.ANTLRInputStream(sys.stdin, encoding='utf-8')
lexer = ExprLexer(char_stream)
tokens = antlr3.CommonTokenStream(lexer)
parser = ExprParser(tokens)
r = parser.prog()
root = r.tree
nodes = antlr3.tree.CommonTreeNodeStream(root)
walker = Eval.Eval(nodes)
try:
walker.prog()
except ReturnValue, v:
if isinstance(v.getValue(), str) or isinstance(v.getValue(), unicode):
print v.getValue().encode('utf-8')
else:
print v.getValue()
def parse():
char_stream = antlr3.ANTLRInputStream(sys.stdin, encoding='utf-8')
lexer = ExprLexer(char_stream)
tokens = antlr3.CommonTokenStream(lexer)
parser = ExprParser(tokens)
r = parser.prog()
root = r.tree
nodes = antlr3.tree.CommonTreeNodeStream(root)
walker = Eval.Eval(nodes)
try:
walker.prog()
except ReturnValue, v:
if isinstance(v.getValue(), str) or isinstance(v.getValue(), unicode):
print v.getValue().encode('utf-8')
else:
print v.getValue()
def _compile(self, srcfile, base_dir, output_dir):
head, tail = os.path.split(srcfile)
dstfile = os.path.normpath(output_dir + "/" + tail.split(".")[0] + ".py")
if os.path.exists(dstfile):
src_mtime = os.path.getmtime(srcfile)
dst_mtime = os.path.getmtime(dstfile)
# print src_mtime, dst_mtime
if src_mtime < dst_mtime:
return dstfile
# print 'compile: %-30s=> %s' % (srcfile, dstfile)
# print 'compile: %-30s=> %s' % (srcfile[len(base_dir)+1:], dstfile[len(base_dir)+1:])
if not os.path.exists(output_dir):
os.makedirs(output_dir)
if not os.path.exists(output_dir + "/__init__.py"):
fp = open(output_dir + "/__init__.py", "w")
fp.close()
# fp = codecs.open(sys.argv[1], 'r', 'utf-8')
fp = open(srcfile, "r")
char_stream = antlr3.ANTLRInputStream(fp)
lexer = ExprLexer(char_stream)
tokens = antlr3.CommonTokenStream(lexer)
parser = ExprParser(tokens)
r = parser.prog()
# this is the root of the AST
root = r.tree
# print (root.toStringTree())
# print '-------'
nodes = antlr3.tree.CommonTreeNodeStream(root)
nodes.setTokenStream(tokens)
from Eval import Eval
eval = Eval(nodes)
#######################################
cpy = CpyBuilder(dstfile, base_dir, output_dir)
eval.prog(cpy)
return dstfile
import sys
from antlr4 import *
from ExprLexer import ExprLexer
from ExprParser import ExprParser
input_stream = InputStream(input('? ')) # solicitar una linea
# input_stream = StdinStream() # stdin
# input_stream = FileStream(sys.argv[1]) # archivo por parametro
# input_stream = FileStream(sys.argv[1], encoding='utf-8') # archivo con acentos
lexer = ExprLexer(input_stream)
token_stream = CommonTokenStream(lexer)
parser = ExprParser(token_stream)
tree = parser.root()
print(tree.toStringTree(recog=parser))
__author__ = 'jszheng'
import sys
from antlr4 import *
from antlr4.InputStream import InputStream
from ExprLexer import ExprLexer
from ExprParser import ExprParser
if __name__ == '__main__':
parser = ExprParser(None)
parser.buildParseTrees = False
parser.memory = {} # how to add this to generated constructor?
line = sys.stdin.readline()
lineno = 1
while line != '':
line = line.strip()
#print(lineno, line)
istream = InputStream(line + "\n")
lexer = ExprLexer(istream)
lexer.line = lineno
lexer.column = 0
token_stream = CommonTokenStream(lexer)
parser.setInputStream(token_stream)
parser.stat()
line = sys.stdin.readline()
lineno += 1
__author__ = 'jszheng'
import sys
from antlr4 import *
from antlr4.InputStream import InputStream
from ExprLexer import ExprLexer
from ExprParser import ExprParser
if __name__ == '__main__':
parser = ExprParser(None)
parser.buildParseTrees = False
line = sys.stdin.readline()
lineno = 1
while line != '':
line = line.strip()
#print(lineno, line)
istream = InputStream(line + "\n")
lexer = ExprLexer(istream)
lexer.line = lineno
lexer.column = 0
token_stream = CommonTokenStream(lexer)
parser.setInputStream(token_stream)
parser.stat()
line = sys.stdin.readline()
lineno += 1
def main(argv):
input = FileStream(argv[1])
lexer = ExprLexer(input)
stream = CommonTokenStream(lexer)
parser = ExprParser(stream)
tree = parser.prog()
result = (-1) * result
return result
file_name = 'test.expr'
input_stream = FileStream(file_name)
print('input_stream:')
print(input_stream)
print()
lexer = ExprLexer(input_stream)
token_stream = CommonTokenStream(lexer)
token_stream.fill()
print('tokens:')
for tk in token_stream.tokens:
print(tk)
print()
parser = ExprParser(token_stream)
tree = parser.prog()
print('tree:')
lisp_tree_str = tree.toStringTree(recog=parser)
print(beautify_lisp_string(lisp_tree_str))
print()
print('calc:')
calc = Calc()
result = calc.visit(tree)
print()
print('result:')
print(result)
def compileLine(visitor, line):
lexer = ExprLexer(InputStream(line))
token_stream = CommonTokenStream(lexer)
parser = ExprParser(token_stream)
tree = parser.root()
return visitor.visit(tree)
import sys import antlr3 import antlr3.tree from ExprLexer import ExprLexer from ExprParser import ExprParser from Eval import Eval char_stream = antlr3.ANTLRInputStream(sys.stdin) lexer = ExprLexer(char_stream) tokens = antlr3.CommonTokenStream(lexer) parser = ExprParser(tokens) r = parser.prog() # this is the root of the AST root = r.tree nodes = antlr3.tree.CommonTreeNodeStream(root) nodes.setTokenStream(tokens) eval = Eval(nodes) eval.prog()
__author__ = 'jszheng'
import sys
from antlr4 import *
from antlr4.InputStream import InputStream
from ExprLexer import ExprLexer
from ExprParser import ExprParser
if __name__ == '__main__':
if len(sys.argv) > 1:
input_stream = FileStream(sys.argv[1])
else:
input_stream = InputStream(sys.stdin.readline())
lexer = ExprLexer(input_stream)
token_stream = CommonTokenStream(lexer)
parser = ExprParser(token_stream)
tree = parser.prog()
lisp_tree_str = tree.toStringTree(recog=parser)
print(lisp_tree_str)
def visitMulDiv(self, ctx:ExprParser.MulDivContext):
left = self.visit(ctx.expr(0))
right = self.visit(ctx.expr(1))
if ctx.op.type == ExprParser.MUL:
return left * right
else:
return left / right
def visitAddSub(self, ctx:ExprParser.AddSubContext):
left = self.visit(ctx.expr(0))
right = self.visit(ctx.expr(1))
if ctx.op.type == ExprParser.ADD:
return left + right
else:
return left - right
def visitParens(self, ctx:ExprParser.ParensContext):
return self.visit(ctx.expr())
with open("t.expr") as f:
inp = InputStream(f.read())
lexer = ExprLexer(inp)
tokens = CommonTokenStream(lexer)
parser = ExprParser(tokens)
tree = parser.prog()
print(tree.toStringTree(recog=parser))
evalu = EvalVisitor()
evalu.visit(tree)
# vim:fileencoding=gbk import sys import antlr3 import antlr3.tree from ExprLexer import ExprLexer from ExprParser import ExprParser from TreeExpr import TreeExpr istream = antlr3.ANTLRInputStream(sys.stdin) lexer = ExprLexer(istream) parser = ExprParser(antlr3.CommonTokenStream(lexer)) nstream = antlr3.tree.CommonTreeNodeStream(parser.prog().getTree()) walker = TreeExpr(nstream) walker.prog()
