def cStatementToPyAst(funcEnv, c):
body = funcEnv.getBody()
if isinstance(c, (CVarDecl, CFunc)):
funcEnv.registerNewVar(c.name, c)
elif isinstance(c, CStatement):
a, t = astAndTypeForCStatement(funcEnv, c)
if isinstance(a, ast.expr):
a = ast.Expr(value=a)
body.append(a)
elif isinstance(c, CWhileStatement):
body.append(astForCWhile(funcEnv, c))
elif isinstance(c, CForStatement):
body.append(astForCFor(funcEnv, c))
elif isinstance(c, CDoStatement):
body.append(astForCDoWhile(funcEnv, c))
elif isinstance(c, CIfStatement):
body.append(astForCIf(funcEnv, c))
elif isinstance(c, CSwitchStatement):
body.append(astForCSwitch(funcEnv, c))
elif isinstance(c, CReturnStatement):
body.append(astForCReturn(funcEnv, c))
elif isinstance(c, CBreakStatement):
body.append(ast.Break())
elif isinstance(c, CContinueStatement):
body.append(ast.Continue())
elif isinstance(c, CCodeBlock):
funcEnv.pushScope(body)
cCodeToPyAstList(funcEnv, c.body)
funcEnv.popScope()
else:
assert False, "cannot handle " + str(c)
def raise_exception(self,
node,
exc=None,
msg='',
expr=None,
fname=None,
lineno=None,
func=None):
"add an exception"
if self.error is None:
self.error = []
if expr is None:
expr = self.expr
if fname is None:
fname = self.fname
if lineno is None:
lineno = self.lineno
if func is None:
func = self.func
if len(self.error) > 0 and not isinstance(node, ast.Module):
msg = '%s' % msg
err = LarchExceptionHolder(node,
exc=exc,
msg=msg,
expr=expr,
fname=fname,
lineno=lineno,
func=func,
symtable=self.symtable)
self._interrupt = ast.Break()
self.error.append(err)
self.symtable._sys.last_error = err
def mutate(cls, node):
"""
Mutate break and continue statements
1. break to continue
2. continue to break
"""
if node not in config.visited_nodes:
if node.__class__ is ast.Break:
config.mutated = True
original_node = deepcopy(node)
parent = config.parent_dict[node]
del config.parent_dict[node]
node = ast.Continue()
config.parent_dict[node] = parent
config.node_pairs[node] = original_node
config.current_mutated_node = node
elif node.__class__ is ast.Continue:
config.mutated = True
original_node = deepcopy(node)
parent = config.parent_dict[node]
del config.parent_dict[node]
node = ast.Break()
config.parent_dict[node] = parent
config.node_pairs[node] = original_node
config.current_mutated_node = node
return node
def astForCFor(funcEnv, stmnt):
assert isinstance(stmnt, CForStatement)
assert len(stmnt.args) == 3
assert isinstance(
stmnt.args[1], CStatement
) # second arg is the check; we must be able to evaluate that
# introduce dummy 'if' AST so that we have a scope for the for-loop (esp. the first statement)
ifAst = ast.If(body=[],
orelse=[],
test=ast.Name(id="True", ctx=ast.Load()))
funcEnv.pushScope(ifAst.body)
cStatementToPyAst(funcEnv, stmnt.args[0])
whileAst = ast.While(body=[],
orelse=[],
test=ast.Name(id="True", ctx=ast.Load()))
ifAst.body.append(whileAst)
ifTestAst = ast.If(body=[ast.Pass()], orelse=[ast.Break()])
ifTestAst.test = getAstNode_valueFromObj(
funcEnv.globalScope.stateStruct,
*astAndTypeForCStatement(funcEnv, stmnt.args[1]))
whileAst.body.append(ifTestAst)
funcEnv.pushScope(whileAst.body)
if stmnt.body is not None:
cCodeToPyAstList(funcEnv, stmnt.body)
cStatementToPyAst(funcEnv, stmnt.args[2])
funcEnv.popScope() # whileAst / main for-body
funcEnv.popScope() # ifAst
return ifAst
def controlnode_to_ast(node):
if node.code == "break:":
return [ast.Break()]
mod = ast.parse("%s\n pass" % node.code)
ctrl = mod.body[0]
ctrl.body = sum([node_to_ast(x) for x in node.children], [])
ctrl.orelse = sum([node_to_ast(x) for x in node.orelse], [])
return [ctrl]
def wrap_func_body(self, flat_body):
var_ast = ast.Assign()
var_ast.targets = [ast.Name(id=self.gotoVarName, ctx=ast.Store())]
var_ast.value = ast.Name(id="None", ctx=ast.Load())
main_loop_ast = ast.While(orelse=[])
main_loop_ast.test = ast.Name(id="True", ctx=ast.Load())
main_loop_ast.body = self.handle_body(flat_body)
main_loop_ast.body += [ast.Break()]
return [var_ast, main_loop_ast]
def to_node(self, stmt):
if isinstance(stmt, Statement):
return stmt.to_node()
if stmt == 'pass':
return ast.Pass()
if stmt == 'break':
return ast.Break()
if stmt == 'continue':
return ast.Continue()
def p_jump_statement_1(p):
'''
jump_statement : BREAK SEMI
'''
if DEBUG:
print("\njmp stmt: ", end="")
for i in range(len(p)):
print(i, " ", p[i], " ", end="")
p[0] = ast.Break()
def test_break(self):
assert self.run([
ast.Assign(
[ast_store('i')],
ast.Num(0),
),
ast.While(ast.Compare(ast_load('i'), [ast.Lt()], [ast.Num(10)]), [
ast.Break(),
], [])
], 'i', int) == 0
def stop_iteration(node):
cmp_break = ast.Compare(left=mk_name(self.flag_id),
ops=[ast.Eq()],
comparators=[mk_str(self.BREAK)])
cmp_return = ast.Compare(left=mk_name(self.flag_id),
ops=[ast.Eq()],
comparators=[mk_str(self.RETURN)])
test = ast.BoolOp(op=ast.Or(), values=[cmp_break, cmp_return])
break_stmt = ast.Break()
ifstmt = ast.If(test=test, body=[break_stmt], orelse=[])
node.body.append(ifstmt)
def visit_While(self, node):
if self.done:
return node
if self.count != self.selection:
self.count += 1
return node
self.done = True
return ast.While(test=node.test,
body=node.body + [node, ast.Break()],
orelse=[])
def raise_exception(self, node, exc=None, msg='', expr=None, lineno=None):
"add an exception"
if self.error is None:
self.error = []
if expr is None:
expr = self.expr
if len(self.error) > 0 and not isinstance(node, ast.Module):
msg = '%s' % msg
err = ExceptionHolder(node, exc=exc, msg=msg, expr=expr, lineno=lineno)
self._interrupt = ast.Break()
self.error.append(err)
raise RuntimeError
def raise_exception(self, node, msg='', expr=None):
"add an exception"
if self.error is None:
self.error = []
if expr is None:
expr = self.expr
if len(self.error) > 0 and not isinstance(node, ast.Module):
msg = '%s' % msg
etype, evalue, tback = sys.exc_info()
err = ExceptionHolder(node, msg=msg, expr=expr, py_exc=(etype, evalue))
self._interrupt = ast.Break()
self.error.append(err)
def mutate(cls, node):
if node not in config.visited_nodes:
if node.__class__ in [ast.For, ast.While]:
config.mutated = True
original_node = deepcopy(node)
parent = config.parent_dict[node]
del config.parent_dict[node]
node.body = [ast.Break()] + node.body
config.parent_dict[node] = parent
config.node_pairs[node] = original_node
config.current_mutated_node = node
return node
def astconv_dowhile_stmt(dowhile_stmt_astc, ctx, prefix_stmts):
[body_astc, exit_cond_astc] = dowhile_stmt_astc.get_children()
exit_check_prefix_stmts = []
exit_check_astpy = ast.If(test=ast.UnaryOp(op=ast.Not(),
operand=astconv_expr(
exit_cond_astc, ctx,
exit_check_prefix_stmts)),
body=[ast.Break()],
orelse=[])
return ast.While(test=ast.Name(id='True', ctx=ast.Load()),
body=to_stmt_list(body_astc, ctx) +
exit_check_prefix_stmts + [exit_check_astpy],
orelse=[])
def __init__(self, base_node):
BaseMutator.__init__(self, base_node)
self.original_node = base_node
# TODO - This doesn't work - AST node needs replaced
if base_node.__class__ is ast.Break:
self.mutations.append(
ast.Continue(lineno=base_node.lineno,
col_offset=base_node.col_offset))
# TODO - This doesn't work - AST node needs replaced
if base_node.__class__ is ast.Continue:
self.mutations.append(
ast.Break(lineno=base_node.lineno,
col_offset=base_node.col_offset))
def test_simple_statements(self):
# Simple statements can be put on a single line as long as the scope
# has not changed.
for body, expect in [
(ast.Expr(ast.Num(42)), '42'),
(ast.Import([ast.alias('a', None)]), 'import a'),
(ast.ImportFrom('b', [ast.alias('a', None)],
1), 'from .b import a'),
(ast.Break(), 'break'),
(ast.Continue(), 'continue'),
(ast.Pass(), 'pass'),
(ast.Assign([ast.Name('X', ast.Store())], ast.Num(42)), 'X=42'),
(ast.Delete([ast.Name('X', ast.Del())]), 'del X'),
(ast.Raise(None, None), 'raise'),
(ast.Return(None), 'return'),
(ast.AugAssign(ast.Name('X', ast.Store()), ast.Add(),
ast.Num(42)), 'X+=42'),
(ast.Assert(ast.Num(42), None), 'assert 42'),
(ast.Global(['x']), 'global x'),
(ast.Nonlocal(['x']), 'nonlocal x'),
]:
if_simple = ast.If(ast.Num(42), [body], None)
self.verify(if_simple, 'if 42:{}'.format(expect))
if_multiple_simples = ast.If(ast.Num(42),
[ast.Pass(), ast.Pass()], None)
self.verify(if_multiple_simples, 'if 42:pass;pass')
inner_if = ast.If(ast.Num(6), [ast.Pass()], None)
funky_if = ast.If(ast.Num(42), [
ast.Break(),
ast.Continue(), inner_if,
ast.Break(),
ast.Continue()
], None)
self.verify(funky_if,
'if 42:\n break;continue\n if 6:pass\n break;continue')
def statement_to_node(self, statement):
if type(statement) is PrintStatement:
node = self.print_to_node(statement)
elif type(statement) is AssignmentStatement:
node = self.assignment_to_node(statement)
elif type(statement) is IfStatement:
node = self.if_to_node(statement)
elif type(statement) is WhileStatement:
node = self.while_to_node(statement)
elif type(statement) is BreakStatement:
node = ast.Break()
elif type(statement) is ContinueStatement:
node = ast.Continue()
else:
raise
return node
def raise_exception(self, node, exc=None, msg='', expr=None, lineno=None):
"""Add an exception."""
if self.error is None:
self.error = []
if expr is None:
expr = self.expr
if len(self.error) > 0 and not isinstance(node, ast.Module):
msg = '%s' % msg
err = ExceptionHolder(node, exc=exc, msg=msg, expr=expr, lineno=lineno)
self._interrupt = ast.Break()
self.error.append(err)
if self.error_msg is None:
self.error_msg = "at expr='%s'" % (self.expr)
elif len(msg) > 0:
self.error_msg = msg
if exc is None:
try:
exc = self.error[0].exc
except:
exc = RuntimeError
raise exc(self.error_msg)
def _parse_jump_statement(self, env):
""" <jump_statement>
Parses the <jump_statement> language structure.
jump_statement -> 'continue' ';'
| 'break' ';'
| 'return' ';'
| 'return' logical_expression ';'
"""
if self._accept(lexer.Tag.CONTINUE):
return ast.Continue()
elif self._accept(lexer.Tag.BREAK):
return ast.Break()
elif self._accept(lexer.Tag.RETURN):
exp = None
if not self._check(';'):
exp = self._parse_logical_expression(env)
self._match(';')
return ast.Return(exp)
def raise_exception(self, node, exc=None, msg='', expr=None, lineno=None):
"""add an exception"""
if self.error is None:
self.error = []
if expr is None:
expr = self.expr
if self.error and not isinstance(node, ast.Module):
msg = '%s' % msg
err = ExceptionHolder(node, exc=exc, msg=msg, expr=expr, lineno=lineno)
self._interrupt = ast.Break()
self.error.append(err)
if self.error_msg is None:
self.error_msg = "%s in expr='%s'" % (msg, self.expr)
elif msg:
self.error_msg = "%s\n %s" % (self.error_msg, msg)
if exc is None:
# noinspection PyBroadException
try:
exc = self.error[0].exc
except:
exc = RuntimeError
raise exc(self.error_msg)
def visit_For(self, node):
iter_sym = Symbol()
return self.visit(ast.copy_location(ast.Expr(
value=LetBinding(
symbol=iter_sym,
inner=iter_sym,
bound_expr=ast.Call(
func=ast.Name(id="iter", ctx=ast.Load()),
args=[node.iter],
keywords=[]
),
ex_stmts=[
ast.While(
test=ast.Constant(value=True),
body=[ast.Try(
body=[ast.Assign(
targets=[node.target],
value=ast.Call(
func=ast.Name(id="next", ctx=ast.Load()),
args=[iter_sym],
keywords=[]
)
)],
handlers=[ast.ExceptHandler(
type=ast.Name(id="StopIteration", ctx=ast.Load()),
name=None,
body=[
ast.Break()
]
)],
orelse=[],
finalbody=[]
)] + node.body,
orelse=node.orelse
)
]
)
), node))
def astForCDoWhile(funcEnv, stmnt):
assert isinstance(stmnt, CDoStatement)
assert isinstance(stmnt.whilePart, CWhileStatement)
assert stmnt.whilePart.body is None
assert len(stmnt.args) == 0
assert len(stmnt.whilePart.args) == 1
assert isinstance(stmnt.whilePart.args[0], CStatement)
whileAst = ast.While(body=[],
orelse=[],
test=ast.Name(id="True", ctx=ast.Load()))
funcEnv.pushScope(whileAst.body)
if stmnt.body is not None:
cCodeToPyAstList(funcEnv, stmnt.body)
funcEnv.popScope()
ifAst = ast.If(body=[ast.Continue()], orelse=[ast.Break()])
ifAst.test = getAstNode_valueFromObj(
funcEnv.globalScope.stateStruct,
*astAndTypeForCStatement(funcEnv, stmnt.whilePart.args[0]))
whileAst.body.append(ifAst)
return whileAst
def visit_While(self, node):
if not coloring.is_green(node):
return node
# testVar = not bool(...test)
testVar = gensym.gensym("test")
testStatement = ast.Assign(
targets=[ast.Name(id=testVar, ctx=ast.Store())],
value=ast.UnaryOp(op=ast.Not(),
operand=ast.Call(func=ast.Name(id='bool',
ctx=ast.Load()),
args=[node.test],
keywords=[])))
ast.copy_location(testStatement, node)
# TODO testStatement needs to be colored appropriately
# based on whether test contains green calls
# "if <testVar>: break"
breakNode = ast.Break()
ast.copy_location(breakNode, node)
breakNode.color = True
loopIf = ast.If(test=ast.Name(id=testVar, ctx=ast.Load()),
body=[breakNode],
orelse=[])
ast.copy_location(loopIf, node)
loopIf.color = True
# build the new body
newbody = []
newbody.append(testStatement)
newbody.append(loopIf)
newbody.extend(node.body)
node.body = self._transform_sequence(newbody)
node.test = ast.copy_location(ast.NameConstant(value=True), node)
return node
def visit_For(self, node: For, *args, **kwargs) -> C.For:
target = self.visit(node.target, *args, **kwargs)
iter = self.visit(node.iter, *args, **kwargs)
body = self.visit(node.body, *args, **kwargs)
cond = self.visit(node.cond, *args, **kwargs)
orelse = self.visit(node.orelse, *args, **kwargs)
type_comment = self.visit(node.type_comment, *args, **kwargs)
if cond is not None:
check = C.If(
test=C.UnaryOp(op=C.Not(), operand=cond),
body=[C.Break()],
orelse=[],
)
body = [check] + body
return C.For(
target=target,
iter=iter,
body=body,
orelse=orelse,
type_comment=type_comment,
)
def statement(self, is_global=False):
if self.accept(';'):
self.advance()
return ast.EmptyStmt()
elif self.accept('return'):
return self.return_()
elif self.accept('break'):
self.advance()
brk = ast.Break()
self.expect(';')
return brk
elif self.accept('continue'):
self.advance()
cont = ast.Continue()
self.expect(';')
return cont
elif self.accept('{'):
return self.block()
elif self.accept('for'):
return self.for_()
elif self.accept('while'):
return self.while_()
elif self.accept('if'):
return self.if_()
elif self.is_declaration():
declr = self.declaration()
if (type(declr) == ast.Declaration and
type(declr.typ) == ast.Function and self.accept('{')):
return self.parse_function(declr)
else:
self.expect(';')
return declr
else:
expr = self.expression()
self.expect(';')
return expr
def visit_While(self, node):
breakout = ast.If(
test=node.test,
body=[ast.Expr(value=ast.Continue())],
orelse=[ast.Expr(value=ast.Break())]
)
body_block = [i for i in node.body]
body_block.append(breakout)
new_node = ast.For(
target=ast.Name("WhileLoop"),
iter=ast.Call(func=ast.Name(id="range"),
ctx=ast.Load(), args=[ast.Num(n=65534)]),
body=body_block
)
try:
self.indent -= 1
subp = self.sub_parser(new_node)
subp.indent -= 1
self.stack.append(subp.format())
finally:
self.indent += 1
def tct(infunc):
""" Transform a recursive call to an iteration... in some cases """
tree = ast.parse(inspect.getsource(infunc))
transformer = ReturnCallTransformer(infunc.func_name,
ast.Continue(),
tree.body[0].args)
trans_tree = transformer.visit(tree)
trans_tree.body[0].body = [
ast.While(test=ast.Name(id='True', ctx=ast.Load()),
body=trans_tree.body[0].body + [ast.Break()],
orelse=[])
]
# remove TCT decorator, so that we only do TCT once
trans_tree.body[0].decorator_list = [decorator for decorator
in trans_tree.body[0].decorator_list if decorator.id != 'tct']
outfunc_code = compile(ast.fix_missing_locations(trans_tree),
inspect.getfile(infunc), 'exec')
eval_env = globals().copy()
eval(outfunc_code, eval_env)
return eval_env[infunc.func_name]
def as_ast(dct):
"""See https://docs.python.org/2/library/ast.html"""
if dct['ast_type'] == "Module":
return ast.Module(dct["body"])
elif dct['ast_type'] == "Interactive":
return ast.Interactive(dct["body"])
elif dct['ast_type'] == "Expression":
return ast.Expression(dct["body"])
elif dct['ast_type'] == "Suite":
return ast.Suite(dct["body"])
elif dct['ast_type'] == "FunctionDef":
return ast.FunctionDef(dct["name"], dct["args"], dct["body"],
dct["decorator_list"])
elif dct['ast_type'] == "ClassDef":
return ast.ClassDef(dct["name"], dct["bases"], dct["body"],
dct["decorator_list"])
elif dct['ast_type'] == "Return":
return ast.Return(dct["value"])
elif dct['ast_type'] == "Delete":
return ast.Delete(dct["targets"])
elif dct['ast_type'] == "Assign":
return ast.Assign(dct["targets"], dct["value"])
elif dct['ast_type'] == "AugAssign":
return ast.AugAssign(dct["target"], dct["op"], dct["value"])
elif dct['ast_type'] == "Print":
return ast.Print(dct["dest"], dct["values"], dct["nl"])
elif dct['ast_type'] == "For":
return ast.For(dct["target"], dct["iter"], dct["body"], dct["orelse"])
elif dct['ast_type'] == "While":
return ast.While(dct["test"], dct["body"], dct["orelse"])
elif dct['ast_type'] == "If":
return ast.If(dct["test"], dct["body"], dct["orelse"])
elif dct['ast_type'] == "With":
return ast.With(dct["context_expr"], dct["optional_vars"], dct["body"])
elif dct['ast_type'] == "Raise":
return ast.Raise(dct["type"], dct["inst"], dct["tback"])
elif dct['ast_type'] == "TryExcept":
return ast.TryExcept(dct["body"], dct["handlers"], dct["orelse"])
elif dct['ast_type'] == "TryFinally":
return ast.TryFinally(dct["body"], dct["finalbody"])
elif dct['ast_type'] == "Assert":
return ast.Assert(dct["test"], dct["msg"])
elif dct['ast_type'] == "Import":
return ast.Import(dct["names"])
elif dct['ast_type'] == "ImportFrom":
return ast.ImportFrom(dct["module"], dct["names"], dct["level"])
elif dct['ast_type'] == "Exec":
return ast.Exec(dct["body"], dct["globals"], dct["locals"])
elif dct['ast_type'] == "Global":
return ast.Global(dct["names"])
elif dct['ast_type'] == "Expr":
return ast.Expr(dct["value"])
elif dct['ast_type'] == "Pass":
return ast.Pass()
elif dct['ast_type'] == "Break":
return ast.Break()
elif dct['ast_type'] == "Continue":
return ast.Continue()
elif dct['ast_type'] == "BoolOp":
return ast.BoolOp(dct["op"], dct["values"])
elif dct['ast_type'] == "BinOp":
return ast.BinOp(dct["left"], dct["op"], dct["right"])
elif dct['ast_type'] == "UnaryOp":
return ast.UnaryOp(dct["op"], dct["operand"])
elif dct['ast_type'] == "Lambda":
return ast.Lambda(dct["args"], dct["body"])
elif dct['ast_type'] == "IfExp":
return ast.IfExp(dct["test"], dct["body"], dct["orelse"])
elif dct['ast_type'] == "Dict":
return ast.Dict(dct["keys"], dct["values"])
elif dct['ast_type'] == "Set":
return ast.Set(dct["elts"])
elif dct['ast_type'] == "ListComp":
return ast.ListComp(dct["elt"], dct["generators"])
elif dct['ast_type'] == "SetComp":
return ast.SetComp(dct["elt"], dct["generators"])
elif dct['ast_type'] == "DictComp":
return ast.DictComp(dct["key"], dct["value"], dct["generators"])
elif dct['ast_type'] == "GeneratorExp":
return ast.GeneratorExp(dct["elt"], dct["generators"])
elif dct['ast_type'] == "Yield":
return ast.Yield(dct["value"])
elif dct['ast_type'] == "Compare":
return ast.Compare(dct["left"], dct["ops"], dct["comparators"])
elif dct['ast_type'] == "Call":
return ast.Call(dct["func"], dct["args"], dct["keywords"],
dct["starargs"], dct["kwargs"])
elif dct['ast_type'] == "Repr":
return ast.Repr(dct["value"])
elif dct['ast_type'] == "Num":
return ast.Num(dct["n"])
elif dct['ast_type'] == "Str":
# Converting to ASCII
return ast.Str(dct["s"].encode('ascii', 'ignore'))
elif dct['ast_type'] == "Attribute":
return ast.Attribute(dct["value"], dct["attr"], dct["ctx"])
elif dct['ast_type'] == "Subscript":
return ast.Subscript(dct["value"], dct["slice"], dct["ctx"])
elif dct['ast_type'] == "Name":
return ast.Name(dct["id"], dct["ctx"])
elif dct['ast_type'] == "List":
return ast.List(dct["elts"], dct["ctx"])
elif dct['ast_type'] == "Tuple":
return ast.Tuple(dct["elts"], dct["ctx"])
elif dct['ast_type'] == "Load":
return ast.Load()
elif dct['ast_type'] == "Store":
return ast.Store()
elif dct['ast_type'] == "Del":
return ast.Del()
elif dct['ast_type'] == "AugLoad":
return ast.AugLoad()
elif dct['ast_type'] == "AugStore":
return ast.AugStore()
elif dct['ast_type'] == "Param":
return ast.Param()
elif dct['ast_type'] == "Ellipsis":
return ast.Ellipsis()
elif dct['ast_type'] == "Slice":
return ast.Slice(dct["lower"], dct["upper"], dct["step"])
elif dct['ast_type'] == "ExtSlice":
return ast.ExtSlice(dct["dims"])
elif dct['ast_type'] == "Index":
return ast.Index(dct["value"])
elif dct['ast_type'] == "And":
return ast.And()
elif dct['ast_type'] == "Or":
return ast.Or()
elif dct['ast_type'] == "Add":
return ast.Add()
elif dct['ast_type'] == "Sub":
return ast.Sub()
elif dct['ast_type'] == "Mult":
return ast.Mult()
elif dct['ast_type'] == "Div":
return ast.Div()
elif dct['ast_type'] == "Mod":
return ast.Mod()
elif dct['ast_type'] == "Pow":
return ast.Pow()
elif dct['ast_type'] == "LShift":
return ast.LShift()
elif dct['ast_type'] == "RShift":
return ast.RShift()
elif dct['ast_type'] == "BitOr":
return ast.BitOr()
elif dct['ast_type'] == "BitXor":
return ast.BitXor()
elif dct['ast_type'] == "BitAnd":
return ast.BitAnd()
elif dct['ast_type'] == "FloorDiv":
return ast.FloorDiv()
elif dct['ast_type'] == "Invert":
return ast.Invert()
elif dct['ast_type'] == "Not":
return ast.Not()
elif dct['ast_type'] == "UAdd":
return ast.UAdd()
elif dct['ast_type'] == "USub":
return ast.USub()
elif dct['ast_type'] == "Eq":
return ast.Eq()
elif dct['ast_type'] == "NotEq":
return ast.NotEq()
elif dct['ast_type'] == "Lt":
return ast.Lt()
elif dct['ast_type'] == "LtE":
return ast.LtE()
elif dct['ast_type'] == "Gt":
return ast.Gt()
elif dct['ast_type'] == "GtE":
return ast.GtE()
elif dct['ast_type'] == "Is":
return ast.Is()
elif dct['ast_type'] == "IsNot":
return ast.IsNot()
elif dct['ast_type'] == "In":
return ast.In()
elif dct['ast_type'] == "NotIn":
return ast.NotIn()
elif dct['ast_type'] == "comprehension":
return ast.comprehension(dct["target"], dct["iter"], dct["ifs"])
elif dct['ast_type'] == "ExceptHandler":
return ast.ExceptHandler(dct["type"], dct["name"], dct["body"])
elif dct['ast_type'] == "arguments":
return ast.arguments(dct["args"], dct["vararg"], dct["kwarg"],
dct["defaults"])
elif dct['ast_type'] == "keyword":
return ast.keyword(dct["arg"], dct["value"])
elif dct['ast_type'] == "alias":
return ast.alias(dct["name"], dct["asname"])
else:
return dct
def p_break_statement_2(self, p):
"""break_statement : BREAK identifier SEMI
| BREAK identifier auto_semi
"""
p[0] = ast.Break(p[2])
