def visit_Compare(self, ast_compare: Compare):
operator_node = Operator()
left = self.visit(ast_compare.left)
right = self.visit(ast_compare.comparators[0])
op = self.transform_op(ast_compare.ops[0])
operator_node.left = left
operator_node.right = right
operator_node.op = op
return operator_node
def visit_BinaryOperation(self, java_op_node: BinaryOperation):
operator_node = Operator()
self.set_coordinate(operator_node, java_op_node)
operator_node.op = java_op_node.operator
operator_node.left = self.visit(java_op_node.operandl)
operator_node.right = self.visit(java_op_node.operandr)
operator_node.add_children(operator_node.left)
operator_node.add_children(operator_node.right)
return operator_node
def visit_Operator(self, node: Operator):
op = node.op
left = self.visit(node.left)
right = self.visit(node.right)
if type(left) == sympy.Symbol:
self.backward_table_manager.current_table.can_replace_varables.append(
left.name)
elif type(right) == sympy.Symbol:
self.backward_table_manager.current_table.can_replace_varables.append(
right.name)
node.time_complexity = node.left.time_complexity + node.right.time_complexity
if op == '+':
return operator.add(left, right)
elif op == '-':
return operator.sub(left, right)
elif op == '*':
return operator.mul(left, right)
elif op == '/':
return operator.truediv(left, right)
elif op == '**':
return left**right
elif op == '<<':
return left * 2**right
elif op == '>>':
return left / (2**right)
elif op == '//':
return left // right
elif op == '>>':
return left / (2**right)
elif op == '%':
return left % right
elif op == '>>':
return left / (2**right)
elif op == '|':
return left | right
elif op == '&':
return left & right
elif op == '>>':
return left / (2**right)
elif op == '@':
return left @ right
def visit_Operator(self, node: Operator):
op = node.op
left = self.visit(node.left)
right = self.visit(node.right)
node.time_complexity = node.left.time_complexity + node.right.time_complexity
if op == '+':
return operator.add(left, right)
elif op == '-':
return operator.sub(left, right)
elif op == '*':
return operator.mul(left, right)
elif op == '/':
return operator.truediv(left, right)
elif op == '<<':
return left * 2**right
elif op == '>>':
return left / (2**right)
def visit_BinaryOp(self, pyc_bin_op: BinaryOp):
operator_node = Operator()
self.set_coordinate(operator_node, pyc_bin_op.coord)
operator_node.op = pyc_bin_op.op
operator_node.left = self.visit(pyc_bin_op.left)
operator_node.right = self.visit(pyc_bin_op.right)
# need to do some trick at signed variable (-1, +1, -n, +n)
if hasattr(pyc_bin_op.right, 'value'):
if pyc_bin_op.left.coord == pyc_bin_op.right.coord:
if type(pyc_bin_op.left) == Constant and type(pyc_bin_op.right) == Constant:
zero = ConstantNode()
self.set_coordinate(zero, pyc_bin_op.coord)
zero.value = 0
operator_node.right = operator_node.left
operator_node.left = zero
operator_node.add_children(operator_node.left)
operator_node.add_children(operator_node.right)
return operator_node
def visit_EnhancedForControl(
self, java_enhanced_for_control: EnhancedForControl):
for_node = ForNode()
self.set_coordinate(for_node, java_enhanced_for_control)
#init
assign_node = AssignNode()
variable_node = self.visit(java_enhanced_for_control.var)[0].target
constant_node = ConstantNode()
assign_node.target = variable_node
assign_node.value = constant_node
for_node.init.append(assign_node)
#condiction
operator_node = Operator()
operator_node.op = '<'
operator_node.left = variable_node
operator_node.right = self.visit(java_enhanced_for_control.iterable)
operator_node.add_children(operator_node.left)
operator_node.add_children(operator_node.right)
for_node.term = operator_node
#update
update_operator_node = Operator()
update_const_node = ConstantNode()
update_const_node.value = 1
update_operator_node.right = update_const_node
update_operator_node.left = variable_node
update_operator_node.op = '+'
update_assign_node = AssignNode()
update_assign_node.target = variable_node
update_assign_node.value = update_operator_node
for_node.update.append(update_assign_node)
return for_node
def visit_BinOp(self, ast_bin_op: BinOp):
operator_node = Operator()
# coord = coordinate(ast_bin_op.col_offset, ast_bin_op.lineno)
# self.set_coordinate(operator_node, coord)
if type(ast_bin_op.op) == Add:
operator_node.op = '+'
elif type(ast_bin_op.op) == Sub:
operator_node.op = '-'
elif type(ast_bin_op.op) == Mult:
operator_node.op = '*'
elif type(ast_bin_op.op) == Div:
operator_node.op = '/'
elif type(ast_bin_op.op) == FloorDiv:
operator_node.op = '//'
elif type(ast_bin_op.op) == Mod:
operator_node.op = '%'
elif type(ast_bin_op.op) == Pow:
operator_node.op = '**'
elif type(ast_bin_op.op) == LShift:
operator_node.op = '<<'
elif type(ast_bin_op.op) == RShift:
operator_node.op = '>>'
elif type(ast_bin_op.op) == BitOr:
operator_node.op = '|'
elif type(ast_bin_op.op) == BitAnd:
operator_node.op = '&'
elif type(ast_bin_op.op) == MatMult:
operator_node.op = '@'
else:
raise Exception("does not support operator: ", ast_bin_op.op)
operator_node.left = self.visit(ast_bin_op.left)
operator_node.right = self.visit(ast_bin_op.right)
operator_node.add_children(operator_node.left)
operator_node.add_children(operator_node.right)
return operator_node
def visit_BoolOp(self, ast_bool_op: BoolOp):
if type(ast_bool_op.op) == And:
op = '&&'
elif type(ast_bool_op.op) == Or:
op = '||'
else:
raise Exception("does not support operator: ", ast_bool_op.op)
operator_node = Operator()
operator_node.op = op
for i, node in enumerate(ast_bool_op.values):
if i == (len(ast_bool_op.values) - 1) and i > 1:
right = self.visit(node)
deep_operator_node.right = right
elif i == 0:
left = self.visit(node)
operator_node.left = left
else: #right
left = self.visit(node)
deep_operator_node = Operator()
deep_operator_node.op = op
deep_operator_node.left = left
operator_node.right = deep_operator_node
operator_node.add_children(operator_node.left)
operator_node.add_children(operator_node.right)
return operator_node