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]))
