import antlr3
from CalculatorLexer import CalculatorLexer
from CalculatorParser import CalculatorParser
while True:
expr = raw_input('>>> ')
if expr == '':
break
cStream = antlr3.StringStream(expr)
lexer = CalculatorLexer(cStream)
tStream = antlr3.CommonTokenStream(lexer)
parser = CalculatorParser(tStream)
result = parser.evaluate()
print result
def testTreeRewrite(self):
grammar = textwrap.dedent(r'''grammar T6;
options {
language=Python;
output=AST;
}
tokens {
BLOCK;
ASSIGN;
}
prog: stat+;
stat
: IF '(' e=expr ')' s=stat
-> ^(IF $e $s)
| RETURN expr ';'
-> ^(RETURN expr)
| '{' stat* '}'
-> ^(BLOCK stat*)
| ID '=' expr ';'
-> ^(ASSIGN ID expr)
;
expr
: ID
| INT
;
IF: 'if';
RETURN: 'return';
ID: 'a'..'z'+;
INT: '0'..'9'+;
WS: (' '|'\n')+ {$channel=HIDDEN;} ;
COMMENT: '/*' (options {greedy=false;} : .)* '*/' {$channel = HIDDEN;} ;
''')
treeGrammar = textwrap.dedent(r'''tree grammar T6Walker;
options {
language=Python;
tokenVocab=T6;
ASTLabelType=CommonTree;
output=template;
rewrite=true;
}
prog: stat+;
stat
: ^(IF expr stat)
| ^(RETURN return_expr)
| ^(BLOCK stat*)
| ^(ASSIGN ID expr)
;
return_expr
: expr
-> template(t={$text}) <<boom(<t>)>>
;
expr
: ID
| INT
;
''')
input = textwrap.dedent('''\
if ( foo ) {
b = /* bla */ 2;
return 1 /* foo */;
}
/* gnurz */
return 12;
''')
lexerCls, parserCls = self.compileInlineGrammar(grammar)
walkerCls = self.compileInlineGrammar(treeGrammar)
cStream = antlr3.StringStream(input)
lexer = lexerCls(cStream)
tStream = antlr3.TokenRewriteStream(lexer)
parser = parserCls(tStream)
tree = parser.prog().tree
nodes = antlr3.tree.CommonTreeNodeStream(tree)
nodes.setTokenStream(tStream)
walker = walkerCls(nodes)
walker.prog()
found = tStream.toString()
expected = textwrap.dedent('''\
if ( foo ) {
b = /* bla */ 2;
return boom(1) /* foo */;
}
/* gnurz */
return boom(12);
''')
self.failUnlessEqual(expected, found)
def testValid1(self):
cStream = antlr3.StringStream('foo')
lexer = self.getLexer(cStream)
tStream = antlr3.CommonTokenStream(lexer)
parser = self.getParser(tStream)
events = parser.r()
import sys import antlr3 from SimpleCLexer import SimpleCLexer from SimpleCParser import SimpleCParser cStream = antlr3.StringStream(open(sys.argv[1]).read()) lexer = SimpleCLexer(cStream) tStream = antlr3.CommonTokenStream(lexer) parser = SimpleCParser(tStream) parser.program()
def testRewrite(self):
grammar = textwrap.dedent(r'''grammar T5;
options {
language=Python;
output=template;
rewrite=true;
}
prog: stat+;
stat
: 'if' '(' expr ')' stat
| 'return' return_expr ';'
| '{' stat* '}'
| ID '=' expr ';'
;
return_expr
: expr
-> template(t={$text}) <<boom(<t>)>>
;
expr
: ID
| INT
;
ID: 'a'..'z'+;
INT: '0'..'9'+;
WS: (' '|'\n')+ {$channel=HIDDEN;} ;
COMMENT: '/*' (options {greedy=false;} : .)* '*/' {$channel = HIDDEN;} ;
''')
input = textwrap.dedent('''\
if ( foo ) {
b = /* bla */ 2;
return 1 /* foo */;
}
/* gnurz */
return 12;
''')
lexerCls, parserCls = self.compileInlineGrammar(grammar)
cStream = antlr3.StringStream(input)
lexer = lexerCls(cStream)
tStream = antlr3.TokenRewriteStream(lexer)
parser = parserCls(tStream)
result = parser.prog()
found = tStream.toString()
expected = textwrap.dedent('''\
if ( foo ) {
b = /* bla */ 2;
return boom(1) /* foo */;
}
/* gnurz */
return boom(12);
''')
self.failUnlessEqual(expected, found)
def testSize(self):
"""StringStream.size()"""
stream = antlr3.StringStream('foo')
self.assertEqual(stream.size(), 3)
def testValid1(self):
cStream = antlr3.StringStream('foobar')
lexer = self.getLexer(cStream)
tStream = antlr3.CommonTokenStream(lexer)
parser = self.getParser(tStream)
parser.prog()
import sys import antlr3 from CSVLexer import CSVLexer from CSVParser import CSVParser cStream = antlr3.StringStream(sys.stdin.read()) # create char stream lexer = CSVLexer(cStream) # lexer feeds off chars tStream = antlr3.CommonTokenStream(lexer) # buffer up tokens parser = CSVParser(tStream) # parser feeds off tokens parser.file() # begin parse w/rule file
def testIndex(self):
"""StringStream.index()"""
stream = antlr3.StringStream('foo')
self.assertEqual(stream.index(), 0)
def testIndex(self):
"""StringStream.index()"""
stream = antlr3.StringStream('foo')
self.failUnlessEqual(stream.index(), 0)
def testSize(self):
"""StringStream.size()"""
stream = antlr3.StringStream('foo')
self.failUnlessEqual(stream.size(), 3)
def _parseGuard(self, sm, guard_s, container):
from UMLStateMachine.Parsers.GuardLexer import GuardLexer
from UMLStateMachine.Parsers.GuardParser import GuardParser
sStream = antlr3.StringStream(guard_s)
lexer = GuardLexer(sStream)
tStream = antlr3.CommonTokenStream(lexer)
parser = GuardParser(tStream)
_guard = parser.guard()
def check(lst):
hasBool = False
hasInt = False
for var in lst:
if isinstance(var, BoolConst):
hasBool = True
elif isinstance(var, int):
hasInt = True
else:
v = sm.lookupVar(var)
if var != "self.c" and not v:
import_logger.error(
"Can't find var \"%s\" in state machine \"%s\"" %
(var, sm.name))
else:
if isinstance(v, BoolVar):
hasBool = True
else:
hasInt = True
if hasBool and hasInt:
return False, False
return True, hasBool
def analyze(guard):
result = True
for atom in guard.disjunctions:
if isinstance(atom, CompAtom):
r1 = check(atom.args[0].args)
r2 = check(atom.args[1].args)
if not r1[0] or not r2[0] or r1[1] != r2[1]:
result = False
elif isinstance(atom, OrAtom) or isinstance(atom, AndAtom):
result &= analyze(atom)
elif isinstance(atom, InAtom):
pass
elif isinstance(atom, Negation):
if isinstance(atom.arg, OrAtom):
result = analyze(atom.arg)
else:
r1 = check(atom.arg.args[0].args)
r2 = check(atom.arg.args[1].args)
if not r1[0] or not r2[0] or r1[1] != r2[1]:
result = False
else:
print atom, conj, guard_s
print atom.__class__
assert (0)
return result
if not analyze(_guard):
import_logger.error(
"Comparing vars of different types in guard atom \"%s\"" %
(str(_guard)))
return _guard
def _parseAction(self, sm, s):
from UMLStateMachine.Parsers.ActionLexer import ActionLexer
from UMLStateMachine.Parsers.ActionParser import ActionParser
sStream = antlr3.StringStream(s)
lexer = ActionLexer(sStream)
tStream = antlr3.CommonTokenStream(lexer)
parser = ActionParser(tStream)
statements = parser.action()
ret_statements = []
for statement in statements:
def analyze_expr(expr, type):
assert (type in (int, bool))
# TODO: put BoolConst class into a common file?
if isinstance(expr, ActionBoolConst):
return (type == bool)
if isinstance(expr, IntConst):
return (type == int)
if isinstance(expr, VarName):
var = sm.lookupVar(str(expr))
if var == None:
import_logger.error(
"Unknown variable \"%s\" in assignment %s" %
(expr, statement))
if type == int:
return isinstance(var, IntVar) or isinstance(
var, ClockVar)
else:
return isinstance(var, BoolVar)
if isinstance(expr, PlusOp):
if type == bool:
return False
else:
return all([analyze_expr(e[1], int) for e in expr.ops])
if isinstance(expr, MultOp):
if type == bool:
return False
else:
return all([analyze_expr(e, int) for e in expr.ops])
if isinstance(expr, CompOp):
if type == int:
return False
else:
return all([analyze_expr(e, int) for e in expr.ops])
if isinstance(expr, AndOp) or isinstance(expr, OrOp):
if type == int:
return False
else:
return all([analyze_expr(e, bool) for e in expr.ops])
if isinstance(expr, ConditionalOp):
return analyze_expr(expr.op1, bool) and analyze_expr(
expr.op2, type) and analyze_expr(expr.op3, type)
if isinstance(statement, SendSignalStatement):
self.send_signal_names.add(statement.signal_name)
elif isinstance(statement, AssignStatement):
var = sm.lookupVar(statement.var_name)
if var == None:
import_logger.error("Assignment to unknown variable: " +
str(statement))
return None
if isinstance(var, IntVar):
res = analyze_expr(statement.expr, int)
elif isinstance(var, BoolVar):
res = analyze_expr(statement.expr, bool)
elif isinstance(var, ClockVar):
res = analyze_expr(statement.expr, int)
else:
assert (0)
if not res:
import_logger.error("Wrong expr type in assignment: " +
str(statement))
continue
elif isinstance(statement, RandomAssignStatement):
var = sm.lookupVar(statement.var_name)
if var == None:
import_logger.error("Assignment to unknown variable: " +
str(statement))
return None
if isinstance(var, IntVar) or isinstance(var, BoolVar):
res = True
else:
import_logger.error(
"Trying to assign a random variable to a clock variable: "
+ str(statement))
continue
ret_statements.append(statement)
return ret_statements
def testb2(self):
cStream = antlr3.StringStream('foobar')
lexer = self.getLexer(cStream)
tStream = antlr3.CommonTokenStream(lexer)
parser = self.getParser(tStream)
parser.b(True)
