307 lines
9.8 KiB
Python
307 lines
9.8 KiB
Python
from cfg.CFG_Node import (
|
|
CFG_Node,
|
|
CFG_CALL,
|
|
CFG_RETURN,
|
|
CFG_DIAMOND,
|
|
CFG_START,
|
|
CFG_END,
|
|
)
|
|
|
|
import compiler
|
|
import syntax
|
|
|
|
# Global registry for function start/end nodes
|
|
FUNCTIONS = {}
|
|
|
|
# Global variable to track the current function being processed
|
|
CURRENT_FUNCTION = None
|
|
|
|
class CONST(compiler.CONST):
|
|
def cfa(self, pred, end = None):
|
|
node = CFG_Node(self)
|
|
pred.add_child(node)
|
|
|
|
# Attach the end node if it is provided
|
|
if end is not None:
|
|
node.add_child(end)
|
|
return node
|
|
|
|
class ID(compiler.ID):
|
|
def cfa(self, pred, end = None):
|
|
node = CFG_Node(self)
|
|
pred.add_child(node)
|
|
|
|
# Attach the end node if it is provided
|
|
if end is not None:
|
|
node.add_child(end)
|
|
return node
|
|
|
|
class AOP(compiler.AOP):
|
|
def cfa(self, pred, end = None):
|
|
# Create nodes for the used expressions and attach
|
|
left_node = self.arg1.cfa(pred)
|
|
right_node = self.arg2.cfa(left_node)
|
|
|
|
# Create the operator node and attach
|
|
op_node = CFG_Node(self)
|
|
op_node.label = f"{str(self.arg1)} {self.operator} {str(self.arg2)}"
|
|
right_node.add_child(op_node)
|
|
|
|
# Attach the end node if it is provided
|
|
if end is not None:
|
|
op_node.add_child(end)
|
|
return op_node
|
|
|
|
class COMP(compiler.COMP):
|
|
def cfa(self, pred, end = None):
|
|
# Create nodes for the used expressions and attach
|
|
left_node = self.arg1.cfa(pred)
|
|
right_node = self.arg2.cfa(left_node)
|
|
|
|
# Create the comparison node and attach
|
|
comp_node = CFG_Node(self)
|
|
comp_node.label = f"{str(self.arg1)} {self.operator} {str(self.arg2)}"
|
|
right_node.add_child(comp_node)
|
|
|
|
# Attach the end node if it is provided
|
|
if end is not None:
|
|
comp_node.add_child(end)
|
|
return comp_node
|
|
|
|
class EQOP(compiler.EQOP):
|
|
def cfa(self, pred, end = None):
|
|
# Create nodes for the used expressions and attach
|
|
left_node = self.arg1.cfa(pred)
|
|
right_node = self.arg2.cfa(left_node)
|
|
|
|
# Create the comparison node and attach
|
|
eqop_node = CFG_Node(self)
|
|
eqop_node.label = f"{str(self.arg1)} {self.operator} {str(self.arg2)}"
|
|
right_node.add_child(eqop_node)
|
|
|
|
# Attach the end node if it is provided
|
|
if end is not None:
|
|
eqop_node.add_child(end)
|
|
return eqop_node
|
|
|
|
class LOP(compiler.LOP):
|
|
def cfa(self, pred, end = None):
|
|
# Create nodes for each operand separately
|
|
left_node = self.arg1.cfa(pred)
|
|
right_node = self.arg2.cfa(left_node)
|
|
|
|
# Create the logical operation node with just the operator
|
|
lop_node = CFG_Node(self)
|
|
lop_node.label = f"{str(self.arg1)} {self.operator} {str(self.arg2)}"
|
|
right_node.add_child(lop_node)
|
|
|
|
# Attach the end node if it is provided
|
|
if end is not None:
|
|
lop_node.add_child(end)
|
|
return lop_node
|
|
|
|
class ASSIGN(compiler.ASSIGN):
|
|
def cfa(self, pred, end = None):
|
|
# Unwraps expressions needed for assignment
|
|
expr_node = self.expr.cfa(pred)
|
|
|
|
# Assignment node
|
|
assign_node = CFG_Node(self)
|
|
expr_node.add_child(assign_node)
|
|
|
|
# Attach the end node if it is provided
|
|
if end is not None:
|
|
assign_node.add_child(end)
|
|
return assign_node
|
|
|
|
class SEQ(compiler.SEQ):
|
|
def cfa(self, pred, end = None):
|
|
mid = self.exp1.cfa(pred)
|
|
if mid is None:
|
|
return None
|
|
return self.exp2.cfa(mid, end)
|
|
|
|
class IF(compiler.IF):
|
|
def cfa(self, pred, end = None):
|
|
# Unwraps expressions needed for the condition
|
|
cond_node = self.cond.cfa(pred, None)
|
|
|
|
# Attach junction node
|
|
diamond = CFG_DIAMOND(self.cond)
|
|
cond_node.add_child(diamond)
|
|
|
|
# Define start and end entry and unwraps expressions
|
|
then_entry = CFG_Node()
|
|
diamond.add_child(then_entry)
|
|
else_entry = CFG_Node()
|
|
diamond.add_child(else_entry)
|
|
|
|
# Attach the end node if it is provided
|
|
join = CFG_Node()
|
|
if end is not None:
|
|
join.add_child(end)
|
|
|
|
# Connect the extracted expressions with the join
|
|
then_end = self.exp1.cfa(then_entry, join)
|
|
else_end = self.exp2.cfa(else_entry, join)
|
|
return join
|
|
|
|
class WHILE(compiler.WHILE):
|
|
def cfa(self, pred, end = None):
|
|
if hasattr(self.cond, 'arg1') and hasattr(self.cond, 'arg2'):
|
|
# This is a comparison operation (e.g., a > b)
|
|
|
|
# Create the condition evaluation nodes
|
|
left_node = self.cond.arg1.cfa(pred)
|
|
right_node = self.cond.arg2.cfa(left_node)
|
|
|
|
# Create the comparison node and attach
|
|
comp_node = CFG_Node(self.cond)
|
|
comp_node.label = f"{str(self.cond.arg1)} {self.cond.operator} {str(self.cond.arg2)}"
|
|
right_node.add_child(comp_node)
|
|
else:
|
|
# This is a simple condition (e.g., constant true/false)
|
|
cond_node = self.cond.cfa(pred)
|
|
comp_node = cond_node
|
|
|
|
# Attach junction node
|
|
diamond = CFG_DIAMOND(self.cond)
|
|
comp_node.add_child(diamond)
|
|
|
|
# Unwrap the loop body
|
|
body_entry = CFG_Node()
|
|
diamond.add_child(body_entry)
|
|
|
|
# The body should connect back to the start of condition evaluation
|
|
body_end = self.body.cfa(body_entry)
|
|
if body_end is not None:
|
|
# Connect the body end back to the condition evaluation
|
|
if hasattr(self.cond, 'arg1') and hasattr(self.cond, 'arg2'):
|
|
body_end.add_child(left_node)
|
|
else:
|
|
body_end.add_child(pred)
|
|
|
|
# Attach joining node
|
|
after = CFG_Node()
|
|
diamond.add_child(after)
|
|
|
|
# Attach the end node if it is provided
|
|
if end is not None:
|
|
after.add_child(end)
|
|
return after
|
|
|
|
class CALL(compiler.CALL):
|
|
def cfa(self, pred, end = None):
|
|
# Create nodes for all argument values
|
|
current_arg_node = pred
|
|
for i, arg in enumerate(self.arg):
|
|
current_arg_node = arg.cfa(current_arg_node)
|
|
|
|
# Create and attach the call node
|
|
call_node = CFG_CALL(self)
|
|
call_node.label = f"CALL {self.f_name}"
|
|
current_arg_node.add_child(call_node)
|
|
|
|
# Create and attach the exit node
|
|
cont = CFG_Node()
|
|
if end is not None:
|
|
cont.add_child(end)
|
|
|
|
# Find the functions in the function list
|
|
if self.f_name not in FUNCTIONS:
|
|
raise RuntimeError(f"Call to undefined function '{self.f_name}'")
|
|
# Determine the start and exit node of the function
|
|
f_start, f_end = FUNCTIONS[self.f_name]
|
|
|
|
# Create return node from function
|
|
return_node = CFG_RETURN(self)
|
|
return_node.label = f"RET {self.f_name}"
|
|
f_end.add_child(return_node)
|
|
return_node.add_child(cont)
|
|
|
|
# Span the start and exit nodes to the method body
|
|
call_node.add_child(f_start)
|
|
call_node.add_child(return_node)
|
|
|
|
# Return value flow for recursive calls
|
|
if CURRENT_FUNCTION is not None and self.f_name == CURRENT_FUNCTION:
|
|
return_node.add_child(cont)
|
|
return cont
|
|
|
|
class DECL(compiler.DECL):
|
|
def cfa(self, pred, end):
|
|
# Check if a function is already registered
|
|
if self.f_name in FUNCTIONS:
|
|
f_start, f_end = FUNCTIONS[self.f_name]
|
|
else:
|
|
# Span the method body into a start and end node
|
|
f_start = CFG_START(self)
|
|
f_start.label = f"START {self.f_name}({', '.join(self.params)})"
|
|
f_end = CFG_END(self)
|
|
f_end.label = f"END {self.f_name}({', '.join(self.params)})"
|
|
FUNCTIONS[self.f_name] = (f_start, f_end)
|
|
|
|
# Set the current function context for recursion detection
|
|
global CURRENT_FUNCTION
|
|
previous_function = CURRENT_FUNCTION
|
|
CURRENT_FUNCTION = self.f_name
|
|
|
|
try:
|
|
# Unwrap the method body
|
|
body_end = self.body.cfa(f_start, f_end)
|
|
|
|
# Attach the end node if it is provided
|
|
if body_end is not None:
|
|
body_end.add_child(f_end)
|
|
finally:
|
|
# Restore the previous function context
|
|
CURRENT_FUNCTION = previous_function
|
|
|
|
return pred
|
|
|
|
class LET(compiler.LET):
|
|
def cfa(self, pred, end = None):
|
|
# First pass: Register all function declarations
|
|
decls = self.decl if isinstance(self.decl, list) else [self.decl]
|
|
for d in decls:
|
|
if isinstance(d, compiler.DECL):
|
|
# Register function without building CFG yet
|
|
f_start = CFG_START(d)
|
|
f_start.label = f"START {d.f_name}({', '.join(d.params)})"
|
|
f_end = CFG_END(d)
|
|
f_end.label = f"END {d.f_name}({', '.join(d.params)})"
|
|
FUNCTIONS[d.f_name] = (f_start, f_end)
|
|
|
|
# Create a global entry node for the function
|
|
global_entry = CFG_Node()
|
|
global_entry.label = "None"
|
|
pred.add_child(global_entry)
|
|
current = global_entry
|
|
|
|
# Generate function declarations
|
|
for d in decls:
|
|
current = d.cfa(current, None)
|
|
if current is None:
|
|
return None
|
|
|
|
# Unwrap the body
|
|
body_result = self.body.cfa(current, end)
|
|
|
|
# Create global exit node
|
|
global_exit = CFG_Node()
|
|
global_exit.label = "None"
|
|
if body_result is not None:
|
|
body_result.add_child(global_exit)
|
|
|
|
# Attach the end node if it is provided
|
|
if end is not None:
|
|
global_exit.add_child(end)
|
|
return global_exit
|
|
|
|
class RETURN(syntax.EXPRESSION):
|
|
def cfa(self, pred, end):
|
|
n = CFG_RETURN(self)
|
|
pred.add_child(n)
|
|
n.add_child(end)
|
|
return None
|