def visit_If(self, node):
label_visitor = LabelVisitor()
label_visitor.visit(node.test)
test = self.append_node(
Node(label_visitor.result,
node,
line_number=node.lineno,
path=self.filenames[-1]))
self.add_if_label(test)
body_connect_stmts = self.stmt_star_handler(node.body)
test.connect(body_connect_stmts.first_statement)
if node.orelse:
orelse_last_nodes = self.handle_or_else(node.orelse, test)
body_connect_stmts.last_statements.extend(orelse_last_nodes)
else:
body_connect_stmts.last_statements.append(
test
) # if there is no orelse, test needs an edge to the next_node
last_statements = self.remove_breaks(
body_connect_stmts.last_statements)
return ControlFlowNode(
test,
last_statements,
break_statements=body_connect_stmts.break_statements)
def assign_tuple_target(self, node, right_hand_side_variables):
new_assignment_nodes = list()
for i, target in enumerate(node.targets[0].elts):
value = node.value.elts[i]
label = LabelVisitor()
label.visit(target)
if isinstance(value, ast.Call):
new_ast_node = ast.Assign(target, value)
new_ast_node.lineno = node.lineno
new_assignment_nodes.append(
self.assignment_call_node(label.result, new_ast_node))
else:
label.result += ' = '
label.visit(value)
new_assignment_nodes.append(
self.append_node(
AssignmentNode(label.result,
self.extract_left_hand_side(target),
ast.Assign(target, value),
right_hand_side_variables,
line_number=node.lineno,
path=self.filenames[-1])))
self.connect_nodes(new_assignment_nodes)
return ControlFlowNode(new_assignment_nodes[0],
[new_assignment_nodes[-1]],
[]) # return the last added node
def visit_Raise(self, node):
label = LabelVisitor()
label.visit(node)
return self.append_node(
RaiseNode(label.result,
line_number=node.lineno,
path=self.filenames[-1]))
def visit_NameConstant(self, node):
label_visitor = LabelVisitor()
label_visitor.visit(node)
return self.append_node(
Node(label_visitor.result,
node.__class__.__name__,
node,
line_number=node.lineno,
path=self.filenames[-1]))
def add_builtin(self, node):
label = LabelVisitor()
label.visit(node)
builtin_call = Node(label.result,
node,
line_number=node.lineno,
path=self.filenames[-1])
if not self.undecided:
self.nodes.append(builtin_call)
self.undecided = False
return builtin_call
def visit_With(self, node):
label_visitor = LabelVisitor()
label_visitor.visit(node.items[0])
with_node = self.append_node(
Node(label_visitor.result,
node,
line_number=node.lineno,
path=self.filenames[-1]))
connect_statements = self.stmt_star_handler(node.body)
with_node.connect(connect_statements.first_statement)
return ControlFlowNode(with_node, connect_statements.last_statements,
connect_statements.break_statements)
def visit_While(self, node):
label_visitor = LabelVisitor()
label_visitor.visit(node.test)
test = self.append_node(
Node(label_visitor.result,
node,
line_number=node.lineno,
path=self.filenames[-1]))
self.add_while_label(test)
return self.loop_node_skeleton(test, node)
def visit_Call(self, node):
vars = VarsVisitor()
vars.visit(node)
label = LabelVisitor()
label.visit(node)
n = Node(label.result, variables = vars.result)
CFG.append(n)
print_CFG(CFG)
return n
def visit_AugAssign(self, node):
label = LabelVisitor()
label.visit(node)
rhs_visitor = RHSVisitor()
rhs_visitor.visit(node.value)
return self.append_node(
AssignmentNode(label.result,
self.extract_left_hand_side(node.target),
node,
rhs_visitor.result,
line_number=node.lineno,
path=self.filenames[-1]))
def visit_Call(self, node):
vars = VarsVisitor()
vars.visit(node)
label = LabelVisitor()
label.visit(node)
n = Node(label.result, variables=vars.result)
CFG.append(n)
print_CFG(CFG)
return n
def visit_Compare(self, node):
vars = VarsVisitor()
for i in node.comparators:
vars.visit(i)
vars.visit(node.left)
label = LabelVisitor()
label.visit(node)
n = Node(label.result, variables = vars.result)
CFG.append(n)
print_CFG(CFG)
return n
def visit_Return(self, node):
label = LabelVisitor()
label.visit(node)
this_function_name = self.function_return_stack[-1]
rhs_visitor = RHSVisitor()
rhs_visitor.visit(node.value)
LHS = 'ret_' + this_function_name
return self.append_node(
ReturnNode(LHS + ' = ' + label.result,
LHS,
rhs_visitor.result,
node,
line_number=node.lineno,
path=self.filenames[-1]))
def visit_Compare(self, node):
vars = VarsVisitor()
for i in node.comparators:
vars.visit(i)
vars.visit(node.left)
label = LabelVisitor()
label.visit(node)
n = Node(label.result, variables=vars.result)
CFG.append(n)
print_CFG(CFG)
return n
def save_actual_parameters_in_temp(self, args, arguments, line_number):
"""Save the actual parameters of a function call."""
parameters = dict()
for i, parameter in enumerate(args):
temp_name = 'temp_' + str(self.function_index) + '_' + arguments[i]
label_visitor = LabelVisitor()
label_visitor.visit(parameter)
n = RestoreNode(temp_name + ' = ' + label_visitor.result,
temp_name, [label_visitor.result],
line_number=line_number,
path=self.filenames[-1])
self.nodes[-1].connect(n)
self.nodes.append(n)
parameters[label_visitor.result] = arguments[i]
return parameters
def visit_Assign(self, node):
rhs_visitor = RHSVisitor()
rhs_visitor.visit(node.value)
if isinstance(node.targets[0], ast.Tuple): # x,y = [1,2]
if isinstance(node.value, ast.Tuple):
return self.assign_tuple_target(node, rhs_visitor.result)
elif isinstance(node.value, ast.Call):
call = None
for element in node.targets[0].elts:
label = LabelVisitor()
label.visit(element)
call = self.assignment_call_node(label.result, node)
return call
elif len(node.targets) > 1: # x = y = 3
return self.assign_multi_target(node, rhs_visitor.result)
else:
if isinstance(node.value, ast.Call): # x = call()
label = LabelVisitor()
label.visit(node.targets[0])
return self.assignment_call_node(label.result, node)
else: # x = 4
label = LabelVisitor()
label.visit(node)
return self.append_node(
AssignmentNode(label.result,
self.extract_left_hand_side(
node.targets[0]),
node,
rhs_visitor.result,
line_number=node.lineno,
path=self.filenames[-1]))
def assign_multi_target(self, node, right_hand_side_variables):
new_assignment_nodes = list()
for target in node.targets:
label = LabelVisitor()
label.visit(target)
left_hand_side = label.result
label.result += ' = '
label.visit(node.value)
new_assignment_nodes.append(
self.append_node(
AssignmentNode(label.result,
left_hand_side,
ast.Assign(target, node.value),
right_hand_side_variables,
line_number=node.lineno,
path=self.filenames[-1])))
self.connect_nodes(new_assignment_nodes)
return ControlFlowNode(new_assignment_nodes[0],
[new_assignment_nodes[-1]],
[]) # return the last added node
def add_class(self, call_node, def_node):
label_visitor = LabelVisitor()
label_visitor.visit(call_node)
previous_node = self.nodes[-1]
entry_node = self.append_node(EntryExitNode("Entry " + def_node.name))
previous_node.connect(entry_node)
function_body_connect_statements = self.stmt_star_handler(
def_node.body)
entry_node.connect(function_body_connect_statements.first_statement)
exit_node = self.append_node(EntryExitNode("Exit " + def_node.name))
exit_node.connect_predecessors(
function_body_connect_statements.last_statements)
return Node(label_visitor.result,
call_node,
line_number=call_node.lineno,
path=self.filenames[-1])
def visit_For(self, node):
self.undecided = True # Used for handling functions in for loops
#issue23
iterator_label = LabelVisitor()
iterator = iterator_label.visit(node.iter)
self.undecided = False
target_label = LabelVisitor()
target = target_label.visit(node.target)
for_node = self.append_node(
Node("for " + target_label.result + " in " +
iterator_label.result + ':',
node,
line_number=node.lineno,
path=self.filenames[-1]))
if isinstance(node.iter, ast.Call) and get_call_names_as_string(
node.iter.func) in self.function_names:
last_node = self.visit(node.iter)
last_node.connect(for_node)
return self.loop_node_skeleton(for_node, node)
def perform_labeling_on_expression(self, expr):
obj = parse(expr)
label = LabelVisitor()
label.visit(obj)
return label
def visit_Assign(self, node):
rhs_visitor = RHSVisitor()
rhs_visitor.visit(node.value)
if isinstance(node.targets[0], ast.Tuple): # x,y = [1,2]
if isinstance(node.value, ast.Tuple):
for i, target in enumerate(node.targets[0].elts):
if isinstance(target, ast.Name) & (target.id
in traceParams):
value = node.value.elts[i]
label = LabelVisitor()
label.visit(target)
if isinstance(value, ast.Call):
Tracker.paramsStatements.append(label.result)
else:
label.result += ' = '
label.visit(value)
Tracker.paramsStatements.append(label.result)
elif isinstance(node.value, ast.Call):
call = None
# print(astor.to_source(node, indent_with=' ' * 4, add_line_information=False))
for element in node.targets[0].elts:
if isinstance(element, ast.Tuple):
for tup in element.elts:
# print(tup)
if tup.id in traceParams:
label = LabelVisitor()
label.visit(tup)
left_hand_label = label.result
# print(left_hand_label)
label = LabelVisitor()
label.visit(node.value)
Tracker.paramsStatements.append(
left_hand_label + '=' + label.result)
# if isinstance(element,ast.Name) & (element.id in traceParams):
# label = LabelVisitor()
# label.visit(element)
# left_hand_label = label.result
# label = LabelVisitor()
# label.visit(node.value)
# Tracker.paramsStatements.append(left_hand_label + '=' + label.result)
elif len(node.targets) > 1: # x = y = 3
for target in node.targets:
label = LabelVisitor()
label.visit(target)
if label.result in traceParams:
label.result += ' = '
label.visit(node.value)
Tracker.paramsStatements.append(label.result)
else:
label = LabelVisitor()
label.visit(node.targets[0])
left_hand_label = label.result
if left_hand_label in traceParams:
if isinstance(node.value, ast.Call): # x = call()
label = LabelVisitor()
label.visit(node.value)
Tracker.paramsStatements.append(left_hand_label + '=' +
label.result)
else: # x = 4
label = LabelVisitor()
label.visit(node)
Tracker.paramsStatements.append(label.result)
def visit_Assign(self, node):
rhs_visitor = RHSVisitor()
rhs_visitor.visit(node.value)
if isinstance(node.targets[0], ast.Tuple): # x,y = [1,2]
if isinstance(node.value, ast.Tuple):
for i, target in enumerate(node.targets[0].elts):
if isinstance(target, ast.Name) & (target.id
in traceParams):
value = node.value.elts[i]
label = LabelVisitor()
label.visit(target)
if isinstance(value, ast.Call):
Tracker.paramsStatements.append(label.result)
else:
label.result += ' = '
label.visit(value)
Tracker.paramsStatements.append(label.result)
elif isinstance(node.value, ast.Call):
call = None
for element in node.targets[0].elts:
if element.id in traceParams:
label = LabelVisitor()
label.visit(element)
left_hand_label = label.result
label = LabelVisitor()
label.visit(node.value)
Tracker.paramsStatements.append(left_hand_label + '=' +
label.result)
elif len(node.targets) > 1: # x = y = 3
for target in node.targets:
label = LabelVisitor()
label.visit(target)
if label.result in traceParams:
label.result += ' = '
label.visit(node.value)
Tracker.paramsStatements.append(label.result)
else:
label = LabelVisitor()
label.visit(node.targets[0])
left_hand_label = label.result
if left_hand_label in traceParams:
if isinstance(node.value, ast.Call): # x = call()
label = LabelVisitor()
label.visit(node.value)
Tracker.paramsStatements.append(left_hand_label + '=' +
label.result)
else: # x = 4
label = LabelVisitor()
label.visit(node)
Tracker.paramsStatements.append(label.result)
def perform_labeling_on_expression(self, expr):
obj = parse(expr)
label = LabelVisitor()
label.visit(obj)
return label