def fix_forward(lineno, value):
# Move the SP to accomodate local variables
local_variable_length = ice9_st_proc.st_proc[self.value].local_variable_line + \
+ ice9_st_proc.st_proc[self.value].parameter_count + 2
ice9_parser_global.emit_code('LDA', 4, local_variable_length, 4, 'Move SP to accomodate local variables')
# Set the new FP
offset = (-1 * ice9_st_proc.st_proc[self.value].local_variable_line)
ice9_parser_global.emit_code('LDA', 6, offset, 4, 'Set the FP to the current top of stack')
def generate_address(self):
# Load last value as it is
register = expr_node.generate_code(self.expr_list[-1])
# Get new register to calculate product
for x in range(len(self.expr_list) - 2, -1, -1):
product_reg = expr_node.generate_code(self.expr_list[x])
constant_reg = ice9_parser_global.get_next_register()
ice9_parser_global.emit_code('LDC', constant_reg, get_follow_product(self.value, x + 1), 0, \
'Array index : Load constant')
ice9_parser_global.emit_code('MUL', product_reg, product_reg, constant_reg, \
'Array index : Multiply')
ice9_parser_global.emit_code('ADD', register, register, product_reg, 'Array index : Add')
ice9_parser_global.reclaim_register()
# Check array bounds for -ve index
ice9_parser_global.emit_code('JGE', register, 1, 7, 'If non-negative array index, skip halt')
ice9_parser_global.emit_code('LDC', 7, 5, 0, 'Array index out of bounds, write error and halt')
# Check array bounds for index overflow
max_reg = ice9_parser_global.get_next_register()
ice9_parser_global.emit_code('LDC', max_reg, get_follow_product(self.value, 0), 0, 'Array index get Max value')
ice9_parser_global.emit_code('SUB', max_reg, max_reg, register, 'Subtract index from maximum')
ice9_parser_global.emit_code('JGT', max_reg, 1, 7, 'If non-negative array index, skip halt')
ice9_parser_global.emit_code('LDC', 7, 5, 0, 'Array index out of bounds, write error and halt')
if ice9_parser_global.scope[-1] != 'GLOBAL':
temp_reg = ice9_parser_global.get_next_register()
ice9_parser_global.emit_code('LDC', temp_reg, -1, 0, 'Array variable: Load -1')
ice9_parser_global.emit_code('MUL', register, register, temp_reg, 'Array variable: Multilply index with -1')
ice9_parser_global.emit_code('LDC', temp_reg, ice9_st_var.st_var[self.value][-1].address, \
0, "Array variable in procedure: Load offset from symbol tab")
ice9_parser_global.emit_code('ADD', register, register, temp_reg, "Array variable in procedure")
ice9_parser_global.emit_code('ADD', register, register, 6, "Array variable in procedure: Add to FP")
return register
def generate_code(self):
# Issue halt
if self.rule == 'EXIT':
ice9_parser_global.emit_code('HALT', 0, 0, 0, "Stop execution")
elif self.rule == 'READ':
if self.pre_child.operation == 'ID':
register = self.pre_child.generate_code()
ice9_parser_global.emit_code('IN', register, 0, 0, "Read value from stdin")
ice9_parser_global.store_variable_to_memory(register)
elif self.pre_child.operation == 'ARRAY_REF':
operand = expr_node.generate_address(self.pre_child)
register = ice9_parser_global.get_next_register()
ice9_parser_global.emit_code('IN', register, 0, 0, "Read value from stdin")
ice9_parser_global.emit_code('ST', register, 0, operand, "Store array")
elif self.rule == 'BREAK':
ice9_parser_global.break_stack[-1] = ice9_parser_global.lno
ice9_parser_global.lno += 1
# Generate code for procedure definition
elif self.rule == 'PROC':
ice9_parser_global.emit_comment('---- Start of procedure definition for ' + str(self.pre_child) + ' ----')
# Store the starting address of the procedure definition
ice9_st_proc.st_proc[self.pre_child].starting_address = ice9_parser_global.lno
for stmt in self.post_child:
if stmt:
stmt.generate_code()
return_type = ice9_st_proc.st_proc[self.pre_child].return_type
# Store the return address in a register
address_register = ice9_parser_global.get_next_register()
ice9_parser_global.emit_code('LD', address_register, 1, 6, 'Store the return instruction in a register')
# Restore the FP
ice9_parser_global.emit_code('LD', 6, 0, 6, 'Restore the FP to the previous value')
# Get the length of local variables
local_variable_length = -1 * ice9_st_proc.st_proc[self.pre_child].local_variable_line
local_variable_length += 1
# Restore the SP
ice9_parser_global.emit_code('LDA', 4, local_variable_length, 4, 'Restore the SP to the previous value')
# Restore the PC
ice9_parser_global.emit_code('LDA', 7, 0, address_register, 'Restore the PC to the caller')
ice9_parser_global.emit_comment('---- End of procedure definition for ' + str(self.pre_child) + ' ----')
# Do a OUT on the result of the expression
elif self.rule in ['WRITE', 'WRITES']:
# Determine opcode based on the return value of expression
if self.pre_child.return_data_type == 'int':
# Generate code for the expression
register = self.pre_child.generate_code()
ice9_parser_global.emit_code('OUT', register, 0, 0, "Write to stdout")
elif self.pre_child.return_data_type == 'string':
# Case for a string literal
if self.pre_child.operation == 'SLIT':
ice9_parser_global.emit_code_for_string('.DATA', self.pre_child.length)
ice9_parser_global.emit_code_for_string('.SDATA', self.pre_child.value)
length_address = ice9_parser_global.string_location_dict[self.pre_child.value]
register = ice9_parser_global.get_next_register()
# Set GP to first character
ice9_parser_global.emit_code('LDC', 5, length_address, 0, 'Load address of string length')
ice9_parser_global.emit_code('LDA', 5, 1, 5,'GP points to first character')
# Load length
ice9_parser_global.emit_code('LDC', register, length_address, 0, 'Load address of string length')
ice9_parser_global.emit_code('LD', register, 0, register, 'Load string length')
# Case for a variable
elif self.pre_child.operation == 'ID':
register = self.pre_child.generate_code()
# Set GP to first character
ice9_parser_global.emit_code('LDA', 5, 1, register, 'GP points to first character')
# Load length
ice9_parser_global.emit_code('LD', register, 0, register, 'Load string length')
ice9_parser_global.set_register(register)
content_reg = ice9_parser_global.get_next_register()
ice9_parser_global.emit_code('JEQ', register, 5, 7, 'Check length, if zero jump')
ice9_parser_global.emit_code('LD', content_reg, 0, 5, 'Load character from memory')
ice9_parser_global.emit_code('OUTC', content_reg, 0, 0, 'Write character')
ice9_parser_global.emit_code('LDA', 5, 1, 5, 'Increment GP')
ice9_parser_global.emit_code('LDA', register, -1, register, 'Decrement length')
ice9_parser_global.emit_code('LDA', 7, -6, 7, 'Jump back to start of loop')
# If WRITES emit code for new line
if self.rule == 'WRITES':
ice9_parser_global.emit_code('OUTNL', 0, 0, 0, "New line")
# Reuse register
ice9_parser_global.reclaim_register()
# Simply generate code for the pre_child
elif self.rule in ['UN_MINUS', 'QUEST', 'INT', 'FALSE', 'TRUE', 'EXPR']:
self.pre_child.generate_code()
elif self.rule == 'FA':
# Push -1 on the break stack
ice9_parser_global.break_stack.append(-1)
initial_value_register = self.pre_child.pre_child.generate_code()
# VAR symbol table setup
# Obtain the location to store the fa loop variable
if ice9_parser_global.scope[-1] == 'GLOBAL':
address = ice9_parser_global.get_next_global_address()
else:
address = ice9_st_proc.st_proc[ice9_parser_global.scope[-1]].local_variable_line
ice9_st_proc.st_proc[ice9_parser_global.scope[-1]].local_variable_line -= 1
st_var_entry = ice9_st_var.st_var_entry('int', 0, address, None)
st_var_entry.basic_data_type = 'int'
# Bypass the checks in st_var.add_entry_to_st_var
# If variable not previously used, make an entry for it
if self.pre_child.value not in ice9_st_var.st_var:
self.pre_child.value_stack = list()
ice9_st_var.st_var[self.pre_child.value] = self.pre_child.value_stack
ice9_st_var.st_var[self.pre_child.value].append(st_var_entry)
# Store initial value of loop variable into memory
loop_register = ice9_parser_global.get_next_register()
ice9_parser_global.load_variable_from_memory(loop_register, self.pre_child.value)
ice9_parser_global.emit_code('LDA', loop_register, 0, initial_value_register, 'Loop variable : Copy initial value')
ice9_parser_global.store_variable_to_memory(loop_register)
ice9_parser_global.set_register(initial_value_register - 1)
# Jump back here at the end of the loop
jump_back_line = ice9_parser_global.lno
loop_register = ice9_parser_global.get_next_register()
ice9_parser_global.set_register(loop_register)
ice9_parser_global.load_variable_from_memory(loop_register, self.pre_child.value)
final_value_register = self.pre_child.post_child.generate_code()
ice9_parser_global.emit_code('LDA', final_value_register, 1, final_value_register, 'Increment final value, makes it easier for comparison')
ice9_parser_global.emit_code('SUB', final_value_register, final_value_register, loop_register, \
'Loop variable : Subtract current from final')
ice9_parser_global.emit_code('JNE', final_value_register, 1, 7, 'Loop variable : If not equal, go to loop body')
ice9_parser_global.reclaim_register()
# Loop exit instruction line
loop_exit_line = ice9_parser_global.lno
ice9_parser_global.lno += 1
for stmt in self.post_child:
stmt.generate_code()
decrement_register = ice9_parser_global.get_next_register()
ice9_parser_global.load_variable_from_memory(decrement_register, self.pre_child.value)
ice9_parser_global.emit_code('LDA', decrement_register, 1, decrement_register, 'Loop variabe : Increment')
ice9_parser_global.store_variable_to_memory(decrement_register)
ice9_parser_global.reclaim_register()
# Jump back to start of the loop
ice9_parser_global.emit_code('LDC', 7, jump_back_line, 0, 'Loop variable : Uncondition jump back to start')
exit_line = ice9_parser_global.lno
ice9_parser_global.emit_code_at_line(loop_exit_line, 'LDC', 7, exit_line, 0, 'Loop variable : Exit loop')
# VAR symbol table clean up
ice9_st_var.st_var[self.pre_child.value].pop()
if len(ice9_st_var.st_var[self.pre_child.value]) == 0:
del ice9_st_var.st_var[self.pre_child.value]
break_line = ice9_parser_global.break_stack.pop()
if break_line != -1:
ice9_parser_global.emit_code_at_line(break_line, 'LDC', 7, exit_line, 0, 'Break : Exit loop')
elif self.rule == 'IF':
# Generate code for expression
condition_register = self.condition.generate_code()
# Store the line number to jump if condition is false
false_number = ice9_parser_global.lno
ice9_parser_global.lno += 1
# Generate code for the 'then' part
for stmt in self.pre_child:
stmt.generate_code()
# Store the line number to jump if condition is true and the block has been executed
true_number = ice9_parser_global.lno
ice9_parser_global.lno += 1
# Emit the jump statement when condition is false
jump_offset = ice9_parser_global.lno - false_number - 1
ice9_parser_global.emit_code_at_line(false_number, 'JEQ', condition_register, jump_offset, 7, "If false, jump to the next if-else condition")
#Reuse condition register
ice9_parser_global.reclaim_register()
#ice9_parser_global.set_register(false_number)
# Generate code for any subsequent Else-If or Else
if self.post_child:
self.post_child.generate_code()
self.end_line = self.post_child.end_line
else:
self.end_line = ice9_parser_global.lno
# Emit missing unconditional jump to end of loop
jump_offset = self.end_line - true_number - 1
ice9_parser_global.emit_code_at_line(true_number, 'LDA', 7, jump_offset, 7, "Jump to the end of if-else block")
elif self.rule == 'DO':
# Push -1 on the break stack
ice9_parser_global.break_stack.append(-1)
condition_start_line_no = ice9_parser_global.lno
# Generate code for expression
condition_register = self.condition.generate_code()
# Store the line number to jump if condition is false
false_number = ice9_parser_global.lno
ice9_parser_global.lno += 1
# Generate code for the 'then' part
for stmt in self.pre_child:
stmt.generate_code()
difference = condition_start_line_no - ice9_parser_global.lno - 1
ice9_parser_global.emit_code('LDA', 7, difference, 7, "Jump back to the start of the loop")
# Emit the jump statement when condition is false
jump_offset = ice9_parser_global.lno - false_number - 1
ice9_parser_global.emit_code_at_line(false_number, 'JEQ', condition_register, jump_offset, 7, "If false, jump to the end of do block")
#Resure condition register
ice9_parser_global.reclaim_register()
end_line = ice9_parser_global.lno
break_line = ice9_parser_global.break_stack.pop()
if break_line != -1:
ice9_parser_global.emit_code_at_line(break_line, 'LDC', 7, end_line, 0, 'Break : Exit loop')
def handle_proc_call(self):
# Set scope
ice9_parser_global.register_variable_stack.append(ice9_parser_global.register_variable)
ice9_parser_global.register_variable = [-1] * ice9_parser_global.no_of_user_reg
# Save current state on the memory
ice9_parser_global.save_state()
jump_line_no = ice9_parser_global.lno
ice9_parser_global.lno += 3
# Store the current FP
ice9_parser_global.push(6)
# Get a free register for storing the return value
register = ice9_parser_global.get_next_register()
# Leave space for the return address
ice9_parser_global.emit_code('LDA', 4, -1, 4, 'Decrement stack pointer')
# Reset the next register
ice9_parser_global.set_register(-1)
# Push parameters on to stack
if self.expr_list:
for expr in self.expr_list:
param_register = expr.generate_code()
ice9_parser_global.push(param_register)
if ice9_st_proc.st_proc[self.value].defined:
# Move the SP to accomodate local variables
local_variable_length = ice9_st_proc.st_proc[self.value].local_variable_line + \
+ ice9_st_proc.st_proc[self.value].parameter_count + 2
ice9_parser_global.emit_code('LDA', 4, local_variable_length, 4, 'Move SP to accomodate local variables')
# Set the new FP
offset = (-1 * ice9_st_proc.st_proc[self.value].local_variable_line)
ice9_parser_global.emit_code('LDA', 6, offset, 4, 'Set the FP to the current top of stack')
else:
# Skip line to insert jump
ice9_parser_global.forward_proc_offset_dict[ice9_parser_global.lno] = self.value
ice9_parser_global.lno += 1
# Store the return instruction number
ice9_parser_global.emit_code_at_line(jump_line_no, 'LDC', register, ice9_parser_global.lno + 1, 0, \
'Calculate the return line number')
ice9_parser_global.emit_code_at_line(jump_line_no + 1, 'ST', register, 0, 4, \
'Push the return line number on the stack')
ice9_parser_global.emit_code_at_line(jump_line_no + 2, 'LDA', 4, -1, 4, 'Decrement stack pointer')
if ice9_st_proc.st_proc[self.value].defined:
# Load starting address of procedure into PC
ice9_parser_global.emit_code('LDC', 7, ice9_st_proc.st_proc[self.value].starting_address, 0, \
'Jump to starting address of the procedure')
else:
ice9_parser_global.forward_proc_call_dict[ice9_parser_global.lno] = self.value
ice9_parser_global.lno += 1
# Restore state from memory
ice9_parser_global.restore_state()
# Obtain return value from memory,
ice9_parser_global.emit_code('LD', register, -6, 4, 'Get the return value from procedure call')
# Clear scope
ice9_parser_global.register_variable = ice9_parser_global.register_variable_stack.pop()
return register
def generate_code(self):
#Default values
operand2 = -1
operand3 = -1
# Special case for ASSIGN, array variables need address calculation to be dynamic
# Operators that do not require a new register allocated
if self.operation == 'ASSIGN':
if self.pre_child.operation == 'ARRAY_REF':
operand2 = expr_node.generate_address(self.pre_child)
operand3 = expr_node.generate_code(self.post_child)
ice9_parser_global.emit_code('ST', operand3, 0, operand2, "Store array")
elif self.pre_child.return_data_type == 'string' \
and self.pre_child.operation == 'SLIT' :
operand2 = expr_node.generate_code(self.pre_child)
operand3 = expr_node.generate_code(self.post_child)
ice9_parser_global.emit_code('LDC', operand2, \
ice9_parser_global.string_location_dict[self.post_child.value], 0, 'String literal assignment')
ice9_parser_global.store_variable_to_memory(operand2)
else:
operand2 = expr_node.generate_code(self.pre_child)
operand3 = expr_node.generate_code(self.post_child)
ice9_parser_global.emit_code('LDA', operand2, 0, operand3, "Assignment")
ice9_parser_global.store_variable_to_memory(operand2)
# Re-use register
register = operand2
register -= 1
# Normal case
else:
if self.pre_child:
operand2 = expr_node.generate_code(self.pre_child)
if self.operation in ['PLUS_BOOL', 'STAR_BOOL']:
bool_jump_line = ice9_parser_global.lno
ice9_parser_global.lno += 2
if self.post_child:
operand3 = expr_node.generate_code(self.post_child)
post_child_end_line = ice9_parser_global.lno
# For boolean addition, jump on true
if self.operation == 'PLUS_BOOL':
ice9_parser_global.emit_code_at_line(bool_jump_line, 'JEQ', operand2, 1, 7, \
'Short circuit : On false, evaluation continues')
ice9_parser_global.emit_code_at_line(bool_jump_line + 1, 'LDC', 7, post_child_end_line, 0, \
'Short circuit : Evaluation of pre_child is true, skip post_child')
# For boolean multiplication, jump on false
elif self.operation == 'STAR_BOOL':
ice9_parser_global.emit_code_at_line(bool_jump_line, 'JNE', operand2, 1, 7, \
'Short circuit : On true, evaluation continues')
ice9_parser_global.emit_code_at_line(bool_jump_line + 1, 'LDC', 7, post_child_end_line, 0, \
'Short circuit : Evaluation of pre_child is true, skip post_child')
register = operand2
if self.operation == 'PLUS':
# If operation is PLUS, store the sum of left and right child in register
ice9_parser_global.emit_code('ADD', register, operand2, operand3, "Addition")
elif self.operation == 'PLUS_BOOL':
# If operation is PLUS, store the sum of left and right child in register
ice9_parser_global.emit_code('ADD', register, operand2, operand3, "Boolean addition")
elif self.operation == 'MINUS':
# If operation is PLUS, store the difference of left and right child in register
ice9_parser_global.emit_code('SUB', register, operand2, operand3, "Subtraction")
elif self.operation == 'STAR':
# If operation is PLUS, store the product of left and right child in register
ice9_parser_global.emit_code('MUL', register, operand2, operand3, "Multiplication")
elif self.operation == 'STAR_BOOL':
# If operation is PLUS, store the product of left and right child in register
ice9_parser_global.emit_code('MUL', register, operand2, operand3, "Boolean multiplication")
elif self.operation == 'SLASH':
# If operation is PLUS, store the division of left and right child in register
ice9_parser_global.emit_code('DIV', register, operand2, operand3, "Division")
elif self.operation == 'QUEST':
# If operation is Quest, ,compare result of left child with zero
ice9_parser_global.emit_code('JNE', register, 2, 7, "Jump on less than")
# When FALSE, jump over the TRUE line
ice9_parser_global.emit_code('LDC', register, 0, 0, "Load constant - false")
ice9_parser_global.emit_code('LDA', 7, 1, 7, "Unconditional jump")
# When TRUE
ice9_parser_global.emit_code('LDC', register, 1, 0, "Load constant - true")
elif self.operation in ['LT', 'LE', 'GT', 'GE', 'EQ', 'NEQ']:
# If operation is a logical operator, we first compute the difference on left and right child
ice9_parser_global.emit_code('SUB', register, operand2, operand3, "Subtraction before comparison")
# Depending upon the operation, do a comparison of register and 0
if self.operation == 'LT':
ice9_parser_global.emit_code('JLT', register, 2, 7, "Jump on less than")
elif self.operation == 'LE':
ice9_parser_global.emit_code('JLE', register, 2, 7, "Jump on less than or equal to")
elif self.operation == 'GT':
ice9_parser_global.emit_code('JGT', register, 2, 7, "Jump on greater than")
elif self.operation == 'GE':
ice9_parser_global.emit_code('JGE', register, 2, 7, "Jump on greater than or equal to")
elif self.operation == 'EQ':
ice9_parser_global.emit_code('JEQ', register, 2, 7, "Jump on equal to")
elif self.operation == 'NEQ':
ice9_parser_global.emit_code('JNE', register, 2, 7, "Jump on not equal to")
# When FALSE, jump over the TRUE line
ice9_parser_global.emit_code('LDC', register, 0, 0, "Load constant - false")
ice9_parser_global.emit_code('LDA', 7, 1, 7, "Unconditional jump")
# When TRUE
ice9_parser_global.emit_code('LDC', register, 1, 0, "Load constant - true")
elif self.operation == 'MOD':
# Since no direct instruction present for %, use / * -
temp_reg = ice9_parser_global.get_next_register()
ice9_parser_global.emit_code('DIV', temp_reg, operand2, operand3, "Modulo: division step")
ice9_parser_global.emit_code('MUL', operand3, temp_reg, operand3, "Modulo: multiplication step")
ice9_parser_global.emit_code('SUB', operand2, operand2, operand3, "Modulo: subtraction step")
ice9_parser_global.reclaim_register()
elif self.operation == 'UN_MINUS':
# If operation is Unary Minus, ,multiply result of left child with -1
temp_reg = ice9_parser_global.get_next_register()
ice9_parser_global.emit_code('LDC', temp_reg, -1, 0, "Unary minus: Load -1")
ice9_parser_global.emit_code('MUL', operand2, operand2, temp_reg, "Unary minus: Multiply with -1")
ice9_parser_global.reclaim_register()
elif self.operation == 'NOT':
ice9_parser_global.emit_code('LDA', operand2, -1, operand2, "Boolean NOT: Subtract 1")
ice9_parser_global.emit_code('JEQ', operand2, 2, 7, "Boolean NOT: Jump if operand was True")
ice9_parser_global.emit_code('LDC', operand2, 1, 0, "Boolean NOT: Load True")
ice9_parser_global.emit_code('JNE', operand2, 1, 7, "Boolean NOT: Unconditional jump, operand was False")
ice9_parser_global.emit_code('LDC', operand2, 0, 0, "Boolean NOT: Load False")
# Operators that do require a new register allocated
elif self.operation == 'ARRAY_REF':
register = expr_node.generate_address(self)
ice9_parser_global.load_array_variable_from_memory(register)
elif self.operation == 'PROC_CALL':
register = handle_proc_call(self)
else:
# Get a free register for use
register = ice9_parser_global.get_next_register()
if self.operation == 'INT':
# If operation is a integer constant, load register with it
ice9_parser_global.emit_code('LDC', register, self.value, 0, "Load constant")
elif self.operation == 'SLIT':
ice9_parser_global.emit_code_for_string('.DATA', self.length)
ice9_parser_global.emit_code_for_string('.SDATA', self.value)
ice9_parser_global.emit_code('LDC', register, \
ice9_parser_global.string_location_dict[self.value], 0, "Load address of string length")
elif self.operation == 'ID':
# If operation is a variable, load a register with it from memory
ice9_parser_global.load_variable_from_memory(register, self.value)
elif self.operation == 'TRUE':
# If operation is a true, load register with 1
ice9_parser_global.emit_code('LDC', register, 1, 0, "Load constant True")
elif self.operation == 'FALSE':
# If operation is a false, load register with 0
ice9_parser_global.emit_code('LDC', register, 0, 0, "Load constant False")
ice9_parser_global.set_register(register)
return register