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 test_hdl_expression(): """Test expressions.""" expr_1 = "PARAM-2" expr_2 = "PARAM_X+1" expr_3 = "a and ~b" hdl_expr_1 = HDLExpression(ast.parse(expr_1, mode="eval")) hdl_expr_2 = HDLExpression(ast.parse(expr_2, mode="eval")) hdl_expr_3 = HDLExpression(expr_3) print(hdl_expr_3.dumps()) sum = hdl_expr_1 + hdl_expr_2 neg = ~sum bool_neg = sum.bool_neg() bool_and = hdl_expr_1.bool_and(hdl_expr_2) bool_or = hdl_expr_1.bool_or(hdl_expr_2) print(sum.dumps()) print(neg.dumps()) print(bool_neg.dumps()) print(bool_and.dumps()) print(bool_or.dumps()) _ = hdl_expr_1 & 0x1 _ = 0x1 | hdl_expr_1 _ = 0x1 & hdl_expr_1 _ = 0x1 ^ hdl_expr_1 _ = hdl_expr_1 ^ 0x1 my_signal = HDLSignal("reg", "signal_a", size=2) _ = HDLExpression(HDLIntegerConstant(1)) _ = HDLExpression(1) _ = HDLExpression(my_signal) _ = HDLExpression(HDLSignalSlice(my_signal, 1)) _ = HDLExpression(my_signal[1:0]) # test reduction expr_a = HDLExpression("value_a") expr_b = HDLExpression("value_b") full_expr = expr_a << 0 | expr_b << 16 | HDLExpression(0) case_1 = ast.BinOp(left=ast.Constant(value=0), op=ast.BitOr(), right=ast.Name(id="VAR")) case_2 = ast.BinOp(left=ast.Constant(value=1), op=ast.Mult(), right=ast.Name(id="VAR")) case_3 = ast.BinOp(left=ast.Constant(value=0), op=ast.Mult(), right=ast.Name(id="VAR")) hdl_expr = HDLExpression(ast.Expression(body=case_1)) hdl_expr_2 = HDLExpression(ast.Expression(body=case_2)) hdl_expr_3 = HDLExpression(ast.Expression(body=case_3)) print(hdl_expr.dumps()) print(hdl_expr_2.dumps()) reduced_1 = HDLExpression._reduce_binop(case_1) hdl_expr = HDLExpression(ast.Expression(body=reduced_1)) print(hdl_expr.dumps()) reduced_2 = HDLExpression._reduce_binop(case_2) hdl_expr_2 = HDLExpression(ast.Expression(body=reduced_2)) print(hdl_expr_2.dumps()) reduced_3 = HDLExpression._reduce_binop(case_3) hdl_expr_3 = HDLExpression(ast.Expression(body=reduced_3)) print(hdl_expr_3.dumps()) print(full_expr.dumps()) full_expr.reduce_expr() print(full_expr.dumps())
def expr_rewrite(head, tail): if tail: for op, each in tail: head = ast.BinOp(head, ast.BitOr(), each, **loc @ op) return head
def mk_bitor(a, b): return ast.BinOp(left=a, right=b, op=ast.BitOr())
class Char(object): def __init__(self, str, lineno=0): self.value = str self.lineno = lineno op_ast_map = { '+': ast.Add(), '-': ast.Sub(), '*': ast.Mult(), '/': ast.Div(), '%': ast.Mod(), '**': ast.Pow(), '<<': ast.LShift(), '>>': ast.RShift(), '|': ast.BitOr(), '^^': ast.BitXor(), '&&': ast.BitAnd(), '//': ast.FloorDiv(), '==': ast.Eq(), '!=': ast.NotEq(), '<': ast.Lt(), '<=': ast.LtE(), '>': ast.Gt(), '>=': ast.GtE(), 'is': ast.Is(), 'is_not': ast.IsNot(), 'in': ast.In(), 'not_in': ast.NotIn(), 'and': ast.And(), 'or': ast.Or()
"^^": ast.Pow(), "**": ast.Pow(), "pow": ast.Pow(), "power": ast.Pow(), "to the": ast.Pow(), "to the power": ast.Pow(), "to the power of": ast.Pow(), "%": ast.Mod(), "mod": ast.Mod(), "modulo": ast.Mod(), "!": ast.Not(), "not": ast.Not(), "&": ast.And(), # BitAnd ENGLISH: a & b ~== a and b "&&": ast.And(), "and": ast.And(), "|": ast.BitOr(), "||": ast.Or(), "or": ast.Or(), "does not equal": ast.NotEq(), "doesn't equal": ast.NotEq(), "not equal": ast.NotEq(), "is not": ast.NotEq(), "isn't": ast.NotEq(), "isnt": ast.NotEq(), "!=": ast.NotEq(), "≠": ast.NotEq(), "=": ast.Eq(), "==": ast.Eq(), "===": ast.Eq(), "~=": ast.Eq(), "is": ast.Eq(),
def mutate_BitAnd(self, node): return ast.BitOr()
def bitor(self, other: Union[T, Expr[T]]) -> BinOp[T]: return BinOp(self, ast.BitOr(), other)
class LtnsCompiler: def _temp_func_name(self): if not hasattr(self, '_temp'): self._temp = 0 self._temp += 1 return f'_temp_func_{self._temp}' def _temp_var_name(self): if not hasattr(self, '_temp'): self._temp = 0 self._temp += 1 return f'_temp_var_{self._temp}' def _compile_branch(self, branch): result = Result() for x in branch[:-1]: res = self.compile(x) result.stmts += res.stmts result.stmts += [res.expr_statement] res = self.compile(branch[-1]) result.stmts += res.stmts result.expr = res.expr return result def _compile_args(self, args, kwargs): for i, arg in enumerate(args): if arg == '&': vararg = ast.arg(str(args[i + 1], None), None) posarg = args[:i] else: vararg = None posarg = args return ast.arguments( args=[ast.arg(str(x), None) for x in posarg], vararg=vararg, kwonlyargs=[ast.arg(str(x), None) for x in kwargs], kwarg=None, defaults=[], kw_defaults=list(kwargs.values()), ) def compile(self, node): return _model_compiler[type(node)](self, node) @model(LtnsElement) def compile_element(self, element): if element.name in _special_form_compiler: return _special_form_compiler[element.name](self, *element.childs, **element.attributes) func = ast.parse(element.name, mode='eval').body # TODO: handle exception of parsing result = Result() args = [] keywords = [] for child in element.childs: res = self.compile(child) args.append(res.expr) result.stmts += res.stmts for key, value in element.attributes.items(): res = self.compile(value) keywords.append(ast.keyword(arg=str(key), value=res.expr)) result.stmts += res.stmts expr = ast.Call(func=func, args=args, keywords=keywords) result.expr = expr return result @model(LtnsSymbol) def compile_symbol(self, symbol): expr = ast.Name(id=str(symbol), ctx=ast.Load()) return Result(expr=expr) @model(LtnsString) def compile_string(self, string): return Result(expr=ast.Str(str(string))) @model(LtnsKeyword) def compile_keyword(self, keyword): return Result(expr=ast.Call( func=ast.Name(id='LtnsKeyword', ctx=ast.Load()), args=[ast.Str(str(keyword))], )) @model(LtnsInteger) def compile_integer(self, integer): return Result(expr=ast.Num(int(integer))) @model(LtnsFloat) def compile_float_number(self, float_number): return Result(expr=ast.Num(float(float_number))) @model(LtnsComplex) def compile_complex_number(self, complex_number): return Result(expr=ast.Num(complex(complex_number))) @model(LtnsList) def compile_list(self, ltns_list): result = Result() elts = [] for e in ltns_list: res = self.compile(e) elts.append(res.expr) result.stmts += res.stmts expr = ast.List(elts=elts, ctx=ast.Load()) result.expr = expr return result @special('do') def compile_do(self, *body): return self._compile_branch(body) name_op = { 'add*': ast.Add(), 'sub*': ast.Sub(), 'mul*': ast.Mult(), 'div*': ast.Div(), 'mod': ast.Mod(), 'pow': ast.Pow(), 'lshift': ast.LShift(), 'rshift': ast.RShift(), 'bitor': ast.BitOr(), 'bitxor': ast.BitXor(), 'bitand': ast.BitAnd(), } def compile_bin_op(self, a, b, name): result = Result() left = self.compile(a) result.stmts += left.stmts left = left.expr right = self.compile(b) result.stmts += right.stmts right = right.expr expr = ast.BinOp(op=self.name_op[name], left=left, right=right) result.expr = expr return result for name in name_op: _special_form_compiler[name] = partial(compile_bin_op, name=name) @special('if') def compile_if(self, test, then, orelse=None): result = Result() pred = self.compile(test) result.stmts += pred.stmts then_body = self.compile(then) else_body = None if orelse is not None: else_body = self.compile(orelse) if then_body.stmts or else_body.stmts: temp_func_name = self._temp_func_name() temp_var_name = self._temp_var_name() body = then_body.stmts body.append( ast.Assign( targets=[ast.Name(id=temp_var_name, ctx=ast.Store())], value=then_body.expr, )) orelse = else_body.stmts orelse.append( ast.Assign( targets=[ast.Name(id=temp_var_name, ctx=ast.Store())], value=else_body.expr, )) result.stmts.append( ast.FunctionDef( name=temp_func_name, args=ast.arguments( args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[], ), body=[ ast.If(test=pred.expr, body=body, orelse=orelse), ast.Return( value=ast.Name(id=temp_var_name, ctx=ast.Load())), ], decorator_list=[], returns=None, )) result.expr = ast.Call( func=ast.Name(id=temp_func_name, ctx=ast.Load()), args=[], keywords=[], ) return result else: result.expr = ast.IfExp( test=pred.expr, body=then_body.expr, orelse=else_body.expr, ) return result @special('fn*') def compile_fn(self, args, *body, **kwargs): result = Result() body = self._compile_branch(body) args = self._compile_args(args, kwargs) if body.stmts: fdef = ast.FunctionDef() fdef.name = self._temp_func_name() fdef.args = args fdef.body = body.stmts + [ast.Return(body.expr)] fdef.decorator_list = [] fdef.returns = None result.stmts += [fdef] result.expr = ast.Name(id=fdef.name, ctx=ast.Load()) else: result.expr = ast.Lambda(args=args, body=body.expr) return result @special('def') def compile_def(self, *name_value, **def_dict): if len(name_value) % 2 != 0: raise ValueError("length of argument list should be even") result = Result() for name, value in def_dict.items(): name = LtnsSymbol(name) name_value = name_value + (name, value) for i, name in enumerate(name_value[::2]): name = ast.Name(id=str(name), ctx=ast.Store()) value = self.compile(name_value[i * 2 + 1]) result.stmts += [ast.Assign( targets=[name], value=value.expr, )] result.expr = ast.Name(id='None', ctx=ast.Load()) return result
def visit_Or(self, node): self.generic_visit(node) return ast.BitOr()
def test_empty_init(self): # Jython 2.5.0 did not allow empty constructors for many ast node types # but CPython ast nodes do allow this. For the moment, I don't see a # reason to allow construction of the super types (like ast.AST and # ast.stmt) as well as the op types that are implemented as enums in # Jython (like boolop), but I've left them in but commented out for # now. We may need them in the future since CPython allows this, but # it may fall under implementation detail. #ast.AST() ast.Add() ast.And() ast.Assert() ast.Assign() ast.Attribute() ast.AugAssign() ast.AugLoad() ast.AugStore() ast.BinOp() ast.BitAnd() ast.BitOr() ast.BitXor() ast.BoolOp() ast.Break() ast.Call() ast.ClassDef() ast.Compare() ast.Continue() ast.Del() ast.Delete() ast.Dict() ast.Div() ast.Ellipsis() ast.Eq() ast.Exec() ast.Expr() ast.Expression() ast.ExtSlice() ast.FloorDiv() ast.For() ast.FunctionDef() ast.GeneratorExp() ast.Global() ast.Gt() ast.GtE() ast.If() ast.IfExp() ast.Import() ast.ImportFrom() ast.In() ast.Index() ast.Interactive() ast.Invert() ast.Is() ast.IsNot() ast.LShift() ast.Lambda() ast.List() ast.ListComp() ast.Load() ast.Lt() ast.LtE() ast.Mod() ast.Module() ast.Mult() ast.Name() ast.Not() ast.NotEq() ast.NotIn() ast.Num() ast.Or() ast.Param() ast.Pass() ast.Pow() ast.Print() ast.RShift() ast.Raise() ast.Repr() ast.Return() ast.Slice() ast.Store() ast.Str() ast.Sub() ast.Subscript() ast.Suite() ast.TryExcept() ast.TryFinally() ast.Tuple() ast.UAdd() ast.USub() ast.UnaryOp() ast.While() ast.With() ast.Yield() ast.alias() ast.arguments() #ast.boolop() #ast.cmpop() ast.comprehension() #ast.excepthandler() #ast.expr() #ast.expr_context() ast.keyword()
def translateExpr(n): if isinstance(n, Token): if n.type.name == 'INTEGER': if n.arg > 2**63: return ast.NameConstant('__BIGINT__') return ast.Num(n.arg) if n.type.name == 'FLOAT': return ast.Num(n.arg) if n.type.name == 'IDENT': return ast.NameConstant(mungeName(n.arg)) if n.type.name == 'FALSE': return ast.NameConstant('False') if n.type.name == 'TRUE': return ast.NameConstant('True') if n.type.name == 'BITSTRING': if n.arg.find('x') >= 0: return ast.Call(ast.NameConstant('__BITSTRING_MATCH__'), [ast.Str(n.arg)], []) return ast.NameConstant('0b' + n.arg) raise Exception('q %s' % n) if isinstance(n, Type): return ast.Num(800) if n.type == 'e-land': return ast.BoolOp( ast.And(), [translateExpr(n.children[0]), translateExpr(n.children[1])]) elif n.type == 'e-lor': return ast.BoolOp( ast.Or(), [translateExpr(n.children[0]), translateExpr(n.children[1])]) elif n.type == 'e-eq': return ast.Compare(translateExpr(n.children[0]), [ast.Eq()], [translateExpr(n.children[1])]) elif n.type == 'e-ne': return ast.Compare(translateExpr(n.children[0]), [ast.NotEq()], [translateExpr(n.children[1])]) elif n.type == 'e-call': return ast.Call(translateExpr(n.children[0]), [translateExpr(x) for x in n.children[1]], []) elif n.type == 'e-range': return ast.Subscript(translateExpr(n.children[0]), translateRange(n.children[1]), None) elif n.type == 'e-not': return ast.UnaryOp(ast.Not(), translateExpr(n.children[0])) elif n.type == 'e-negate': return ast.UnaryOp(ast.USub(), translateExpr(n.children[0])) elif n.type == 'e-add': return ast.BinOp(translateExpr(n.children[0]), ast.Add(), translateExpr(n.children[1])) elif n.type == 'e-sub': return ast.BinOp(translateExpr(n.children[0]), ast.Sub(), translateExpr(n.children[1])) elif n.type == 'e-mul': return ast.BinOp(translateExpr(n.children[0]), ast.Mult(), translateExpr(n.children[1])) elif n.type == 'e-div': return ast.BinOp(translateExpr(n.children[0]), ast.FloorDiv(), translateExpr(n.children[1])) elif n.type == 'e-fdiv': return ast.BinOp(translateExpr(n.children[0]), ast.Div(), translateExpr(n.children[1])) elif n.type == 'e-rem': return ast.BinOp(translateExpr(n.children[0]), ast.Mod(), translateExpr(n.children[1])) elif n.type == 'e-lt': return ast.Compare(translateExpr(n.children[0]), [ast.Lt()], [translateExpr(n.children[1])]) elif n.type == 'e-le': return ast.Compare(translateExpr(n.children[0]), [ast.LtE()], [translateExpr(n.children[1])]) elif n.type == 'e-gt': return ast.Compare(translateExpr(n.children[0]), [ast.Gt()], [translateExpr(n.children[1])]) elif n.type == 'e-ge': return ast.Compare(translateExpr(n.children[0]), [ast.GtE()], [translateExpr(n.children[1])]) elif n.type == 'e-lsh': return ast.BinOp(translateExpr(n.children[0]), ast.LShift(), translateExpr(n.children[1])) elif n.type == 'e-rsh': return ast.BinOp(translateExpr(n.children[0]), ast.RShift(), translateExpr(n.children[1])) elif n.type == 'e-eor': return ast.BinOp(translateExpr(n.children[0]), ast.BitXor(), translateExpr(n.children[1])) elif n.type == 'e-or': return ast.BinOp(translateExpr(n.children[0]), ast.BitOr(), translateExpr(n.children[1])) elif n.type == 'e-and': return ast.BinOp(translateExpr(n.children[0]), ast.BitAnd(), translateExpr(n.children[1])) elif n.type == 'e-ternary': return ast.IfExp(translateExpr(n.children[0]), translateExpr(n.children[1]), translateExpr(n.children[2])) elif n.type == 'e-subrange': return ast.Num(113) elif n.type == 'e-lnegate': return ast.UnaryOp(ast.Invert(), translateExpr(n.children[0])) elif n.type == 'e-subscript': return ast.Attribute(translateExpr(n.children[0]), n.children[1].arg, None) elif n.type == 'e-indexempty': return ast.Subscript(translateExpr(n.children[0]), ast.Slice(None, None, None), None) elif n.type == 'e-implementation-defined': return ast.Call(ast.NameConstant('IMPLEMENTATION_DEFINED'), [], []) elif n.type == 'e-exp': return ast.BinOp(translateExpr(n.children[0]), ast.Pow(), translateExpr(n.children[1])) elif n.type == 'e-mod': return ast.BinOp(translateExpr(n.children[0]), ast.Mod(), translateExpr(n.children[1])) elif n.type == 'e-unknown': return ast.Call(ast.NameConstant('UNKNOWN'), [], []) elif n.type == 'e-index': return ast.Subscript(translateExpr(n.children[0]), ast.Slice(None, None, None), None) elif n.type == 'e-tuple': return ast.Tuple([translateExpr(x) for x in n.children[0]], None) elif n.type == 'e-set-in': return ast.Num(114) elif n.type == 'e-concat': return ast.Call( ast.NameConstant('_CONCAT_'), [translateExpr(n.children[0]), translateExpr(n.children[1])], []) elif n.type == 'tuple-nomatch': return ast.NameConstant('_') elif n.type == 'range': return ast.Num(122) #return translateRange(n) else: raise Exception('unknown node type: %s' % (n, )) return ast.Num(42)
def expr(self, p): return ast.BinOp(left=p.xor_expr0, op=ast.BitOr(), right=p.xor_expr1)
def or_test(self, p): return ast.BinOp(left=p.and_test0, op=ast.BitOr(), right=p.and_test1)
'RSHIFT_ASN', 'POW_ASN', 'FDIV_ASN', 'NAME', 'NUMBER', ) Add = ast.Add() Sub = ast.Sub() Mult = ast.Mult() Div = ast.Div() Mod = ast.Mod() Pow = ast.Pow() LShift = ast.LShift() RShift = ast.RShift() BitOr = ast.BitOr() BitAnd = ast.BitAnd() BitXor = ast.BitXor() FloorDiv = ast.FloorDiv() op_dict = { "+": Add, "-": Sub, "*": Mult, "/": Div, "//": FloorDiv, "%": Mod, "**": Pow, "<<": LShift, ">>": RShift, "|": BitOr,
class helper(object): def __init__(self, node): self.node = node def __ast__(self): return self.node @property def body(self): return E(self.node.body) @body.setter def body(self, e): self.node.body = e def call(self, args=None): self.node = ast.Call(func=self.node, args=args if args else [], keywords=[], starargs=None, kwargs=None) return self def args(self, args): self.node.args = args return self def subscript(self, index=None): self.node = ast.Subscript(value=self.node, slice=ast.Index(index)) return self def attr(self, attribute): assert (isinstance(attribute, str)) self.node = ast.Attribute(value=self.node, attr=attribute) return self def assign(self, value): self.node = ast.Assign(targets=[self.node], value=E(value)) return self def init(self, value): self.node.init = value return self sub_assign = _aug_assign(ast.Sub()) add_assign = _aug_assign(ast.Add()) xor_assign = _aug_assign(ast.BitXor()) or_assign = _aug_assign(ast.BitOr()) mult = _bin_op(ast.Mult()) add = _bin_op(ast.Add()) bit_and = _bin_op(ast.BitAnd()) bit_or = _bin_op(ast.BitOr()) bit_xor = _bin_op(ast.BitXor()) xor = bit_xor NotEq = _compare2(ast.NotEq()) Eq = _compare2(ast.Eq()) Gt = _compare2(ast.Gt()) Lt = _compare2(ast.Lt()) def ast(self): return self.node