def ConvertCompare(self, tree): """ Convert the Compare(expr left, cmpop* ops, expr* comparators) node. Each of the ops are \in Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn More than one comparison is possible. Like 3 < x < 4. If the lenght of ops is one, then we return a simple comparison node, else we return an and of comparison nodes.""" if len(tree.ops) is 1: return self.__ConvertBinaryOperation(position=self.gc.GC(tree), op=GetClassName(tree.ops[0]), left=tree.left, right=tree.comparators[0]) comparisons = [] comparators = [tree.left] + tree.comparators for (i, c) in enumerate(tree.ops): comparisons.append( self.__ConvertBinaryOperation(position=self.gc.GC( comparators[i]), op=GetClassName(c), left=comparators[i], right=comparators[i + 1])) return N.Expression(position=self.gc.GC(tree), operator='BOOLEAN_AND', children=comparisons)
def ConvertUnaryop(self, tree): """ Convert the UnaryOp(unaryop op, expr operand) node. op \in Invert | Not | UAdd | USub """ return N.Expression(position=self.gc.GC(tree), operator=UNARY_OPERATOR_CONVERSIONS[GetClassName( tree.op)], children=[self.ConvertTree(tree.operand)])
def ConvertArrayref(self, tree): return N.Expression(position=GetCoords(tree), operator='INDEX_INTO', children=[ self.ConvertTree(tree.name), self.ConvertTree(tree.subscript) ])
def ConvertCast(self, tree): return N.Expression(position=None, operator='TYPE_CAST', children=[ self.ConvertTree(tree.to_type).type, self.ConvertTree(tree.expr) ])
def ConvertStructref(self, tree): op = tree.type # a.b or a->b assert (op in BINARY_OPERATOR_CONVERSIONS) return N.Expression(position=GetCoords(tree), operator=BINARY_OPERATOR_CONVERSIONS[op], children=self.ConvertListOfStatements( [tree.name, tree.field]))
def ConvertSubscript(self, tree): """ Convert Subscript(expr value, slice slice, expr_context ctx) node.""" return N.Expression(position=self.gc.GC(tree), operator='INDEX_INTO', children=[ self.ConvertTree(tree.value), self.ConvertTree(tree.slice) ])
def ConvertAttribute(self, tree): """ Convert the Attribute(expr value, identifier attr, expr_context ctx) node.""" return N.Expression(position=self.gc.GC(tree), operator='ATTRIBUTE_INDEX', children=[ self.ConvertTree(tree.value), N.ReferVariable(self.gc.GC(tree), tree.attr) ])
def ConvertBinop(self, tree): """ Convert the BinOp(expr left, operator op, expr right) node. op\ in Add | Sub | Mult | Div | Mod | Pow | LShift | RShift | BitOr | BitXor | BitAnd | FloorDiv""" return N.Expression( position=self.gc.GC(tree), operator=BINARY_OPERATOR_CONVERSIONS[GetClassName(tree.op)], children=self.ConvertListOfStatements([tree.left, tree.right]))
def __ConvertBinaryOperation(self, op, position, left, right): """ We split the conversion into two cases - not in, is not (not operators), and the rest. In the not operators case, we use the NOT_BINARY_OPERATORS dictionary, and a BOOLEAN_NOT.""" expr = N.Expression(position=position, operator=None, children=self.ConvertListOfStatements( [left, right])) if op in NOT_BINARY_OPERATORS: expr.operator = NOT_BINARY_OPERATORS[op] expr = N.Expression(position=position, operator='BOOLEAN_NOT', children=[expr]) else: expr.operator = BINARY_OPERATOR_CONVERSIONS[op] return expr
def ConvertAugassign(self, tree): """ Convert the AugAssign(expr target, operator op, expr value) node.""" #TODO(spranesh): Not cheat? lvalue = self.ConvertTree(tree.target) rvalue = N.Expression( position=self.gc.GC(tree.value), operator=BINARY_OPERATOR_CONVERSIONS[GetClassName(tree.op)], children=[lvalue, self.ConvertTree(tree.value)]) return N.Assignment(position=self.gc.GC(tree), lvalue=lvalue, rvalue=rvalue)
def ConvertComprehension(self, tree): """ Convert the comprehension(expr target, expr iter, expr* ifs) node into a Generator. Note that the ifs must be combined into a single condition.""" condition = None if tree.ifs != []: condition = N.Expression(position=self.gc.GC(tree.ifs[0]), operator='BOOLEAN_AND', children=self.ConvertListOfStatements( tree.ifs)) return N.Generator(position=None, target=self.ConvertTree(tree.target), generator=self.ConvertTree(tree.iter), condition=condition)
def ConvertAssignment(self, tree): op = tree.op if len(op) is not 1: aux_op = op[:-1] #TODO(spranesh): Not make any transformations to the += like operators? assert (aux_op in BINARY_OPERATOR_CONVERSIONS) # Make sure that the same subtree is there in both the lvalue, # and the first child of the rvalue lvalue = self.ConvertTree(tree.lvalue) rvalue = N.Expression( position=GetCoords(tree.rvalue), operator=BINARY_OPERATOR_CONVERSIONS[aux_op], children=[lvalue, self.ConvertTree(tree.rvalue)]) else: lvalue = self.ConvertTree(tree.lvalue) rvalue = self.ConvertTree(tree.rvalue) return N.Assignment(position=GetCoords(tree), lvalue=lvalue, rvalue=rvalue)
def ConvertUnaryop(self, tree): assert (tree.op in UNARY_OPERATOR_CONVERSIONS) return N.Expression(position=GetCoords(tree), operator=UNARY_OPERATOR_CONVERSIONS[tree.op], children=[self.ConvertTree(tree.expr)])
(constant 1))))))))))) """ if_true = [ N.Return(position=None, return_expression=N.Constant(position=None, value='1')) ] fact_arguments = N.FunctionArguments(position=None, arguments=[ N.Expression( position=None, operator='MINUS', children=[ N.ReferVariable(position=None, name='n'), N.Constant(position=None, value='1') ]) ]) if_false = [ N.Return(position=None, return_expression=N.Expression( position=None, operator='MULTIPLY', children=[ N.ReferVariable(position=None, name='n'), N.CallFunction(position=None, function=N.ReferVariable(position=None,
def ConvertTernaryop(self, tree): return N.Expression(position=GetCoords(tree), operator='TERNARY_IF', children=self.ConvertListOfStatements( [tree.cond, tree.iftrue, tree.iffalse]))
def ConvertIfexp(self, tree): """ Convert the IfExp(expr test, expr body, expr orelse) node.""" return N.Expression(position=self.gc.GC(tree), operator='TERNARY_IF', children=self.ConvertListOfStatements( [tree.test, tree.body, tree.orelse]))
def ConvertBoolop(self, tree): """ Convert the BoolOp(boolop op, expr* values) node. (And | Or) """ return N.Expression(position=self.gc.GC(tree), operator=BINARY_OPERATOR_CONVERSIONS[GetClassName( tree.op)], children=self.ConvertListOfStatements(tree.values))
def ConvertBinaryop(self, tree): assert (tree.op in BINARY_OPERATOR_CONVERSIONS) return N.Expression(position=GetCoords(tree), operator=BINARY_OPERATOR_CONVERSIONS[tree.op], children=self.ConvertListOfStatements( [tree.left, tree.right]))