408 lines
14 KiB
Python
408 lines
14 KiB
Python
import sly
|
|
from lexer import Lexer
|
|
from helper import *
|
|
from items import *
|
|
|
|
# Notes from reading:
|
|
# - it seems no scoping is needed, as it contains only one scope per program
|
|
|
|
class Parser(sly.Parser):
|
|
tokens = Lexer.tokens
|
|
symbol_table = {}
|
|
had_errors = False # Simply to know if we need to write the program in the end
|
|
lines = [ '' ] # Start with en empty line, so len(lines) will represent the next line
|
|
last_used_temp = 0 # cpl doesnt allow _ in ids, so use t_NUM as variables
|
|
|
|
def next_temp(self):
|
|
# returns the next temp variable name
|
|
self.last_used_temp += 1
|
|
return f't_{self.last_used_temp}'
|
|
|
|
def error(self, p):
|
|
self.had_errors = True
|
|
|
|
@_('declarations stmt_block')
|
|
def program(self, p):
|
|
self.lines.append('HALT')
|
|
self.lines.append('Aviv Romem')
|
|
self.lines.pop(0) # remove the empty line
|
|
return None
|
|
|
|
@_('declarations declaration')
|
|
def declarations(self, p):
|
|
return None
|
|
|
|
@_('')
|
|
def declarations(self, p):
|
|
# Empty
|
|
return None
|
|
|
|
# declaration errors
|
|
@_(
|
|
'idlist error ":" type ";"',
|
|
'error idlist ":" type ";"',
|
|
'idlist error idlist ":" type ";"',
|
|
'idlist error type ";"',
|
|
'idlist ":" error ";"',
|
|
'idlist ":" type error',
|
|
'error ":" type ";"'
|
|
)
|
|
def declaration(self, p):
|
|
self.had_errors = True
|
|
print_err(f"Invalid declaration in line {p.lineno}")
|
|
|
|
@_('idlist ":" type ";"')
|
|
def declaration(self, p):
|
|
floats = p[2].is_float
|
|
ids = p[0]
|
|
for i in ids:
|
|
if self.symbol_table.get(i.id):
|
|
self.had_errors = True
|
|
print_err(f'ID {i.id} defined twice, first in line {self.symbol_table[i.id].line}, second time in line {i.line}')
|
|
else:
|
|
self.symbol_table[i.id] = Symbol(floats, i.line)
|
|
return None
|
|
|
|
|
|
@_('INT', 'FLOAT')
|
|
def type(self, p):
|
|
return Expression('', p[0] == 'FLOAT') # return an item with the type and an empty result
|
|
|
|
@_('idlist "," ID')
|
|
def idlist(self, p):
|
|
return p[0] + [ Id(p[2], p.lineno) ]
|
|
|
|
@_('ID')
|
|
def idlist(self, p):
|
|
return [ Id(p[0], p.lineno) ]
|
|
|
|
@_(
|
|
'assignment_stmt', 'input_stmt', 'output_stmt', 'if_stmt',
|
|
'while_stmt', 'switch_stmt', 'break_stmt', 'stmt_block'
|
|
)
|
|
def stmt(self, p):
|
|
return p[0]
|
|
|
|
@_('error ";"')
|
|
def stmt(self, p):
|
|
self.had_errors = True
|
|
print_err(f'Invalid statement in line {p.lineno}')
|
|
return Statement([])
|
|
|
|
@_('ID "=" expression ";"')
|
|
def assignment_stmt(self, p):
|
|
id = p[0]
|
|
exp = p[2]
|
|
if self.symbol_table.get(id) is None:
|
|
self.had_errors = True
|
|
print_err(f'Unknown variable {id} at line {p.lineno}')
|
|
return Statement([])
|
|
sym = self.symbol_table.get(id)
|
|
if not sym.is_float and exp.is_float:
|
|
self.had_errors = True
|
|
print_err(f'Trying to assign a float to an int at line {p.lineno}, did you forget a cast?')
|
|
if sym.is_float and not exp.is_float: # we need to cast exp to float
|
|
new_exp = self.next_temp()
|
|
self.lines.append(f'ITOR {new_exp} {exp.result}')
|
|
exp = Exception(new_exp, False)
|
|
command = 'RASN' if sym.is_float else 'IASN'
|
|
self.lines.append(f'{command} {id} {exp.result}')
|
|
return Statement([])
|
|
|
|
|
|
|
|
@_('INPUT error ";"')
|
|
def input_stmt(self, p):
|
|
self.had_errors = True
|
|
print_err(f'Invalid input statement in line {p.lineno}')
|
|
return Statement([])
|
|
|
|
@_('INPUT "(" ID ")" ";"')
|
|
def input_stmt(self, p):
|
|
id = p[2]
|
|
if self.symbol_table.get(id) is None:
|
|
self.had_errors = True
|
|
print_err(f'Unknown variable {id} at line {p.lineno}')
|
|
else:
|
|
sym = self.symbol_table.get(id)
|
|
command = 'RINP' if sym.is_float else 'IINP'
|
|
self.lines.append(f'{command} {id}')
|
|
return Statement([])
|
|
|
|
@_('OUTPUT error ";"')
|
|
def output_stmt(self, p):
|
|
self.had_errors = True
|
|
print_err(f'Invalid output statement in line {p.lineno}')
|
|
|
|
@_('OUTPUT "(" ID ")" ";"')
|
|
def output_stmt(self, p):
|
|
id = p[2]
|
|
if self.symbol_table.get(id) is None:
|
|
self.had_errors = True
|
|
print_err(f'Unknown variable {id} at line {p.lineno}')
|
|
else:
|
|
sym = self.symbol_table.get(id)
|
|
command = 'RPRT' if sym.is_float else 'IPRT'
|
|
self.lines.append(f'{command} {id}')
|
|
return Statement([])
|
|
|
|
@_('IF error stmt')
|
|
def if_stmt(self, p):
|
|
self.had_errors = True
|
|
print_err(f'Invalid if statement in line {p.lineno}')
|
|
return Statement([])
|
|
|
|
@_('IF "(" boolexpr ")" if_jump stmt if_jump ELSE stmt')
|
|
def if_stmt(self, p):
|
|
exp = p[2]
|
|
jump_else = p[4]
|
|
jump_end = p[6]
|
|
self.lines[jump_else] = f'JMPZ {jump_end + 1} {exp.result}'
|
|
self.lines[jump_end] = f'JUMP {len(self.lines)}'
|
|
return Statement(p[5].breaks + p[8].breaks) # return the list of breaks from both stmt s
|
|
|
|
|
|
@_('')
|
|
def if_jump(self, p):
|
|
# append an empty line as a placeholder for the jump
|
|
line = len(self.lines)
|
|
self.lines.append('')
|
|
return line
|
|
|
|
@_('WHILE error stmt')
|
|
def while_stmt(self, p):
|
|
self.had_errors = True
|
|
print_err(f'Invalid while statement in line {p.lineno}')
|
|
return Statement([])
|
|
|
|
@_('WHILE seen_WHILE "(" boolexpr ")" while_quit stmt')
|
|
def while_stmt(self, p):
|
|
# return to the start
|
|
check_line = p[1]
|
|
self.lines.append(f'JUMP {check_line}')
|
|
# add the check for the boolexpr
|
|
exp = p[3]
|
|
jump_if_fail = len(self.lines)
|
|
jump_line = p[5] # while_quit
|
|
exit_line = f'JMPZ {jump_if_fail} {exp.result}'
|
|
self.lines[jump_line] = exit_line
|
|
for break_line in p.stmt.breaks:
|
|
self.lines[break_line] = f'JUMP {jump_if_fail}'
|
|
return Statement([])
|
|
|
|
@_('')
|
|
def while_quit(self, p):
|
|
# append an empty line as a placeholder for the jump if the while check failed
|
|
line = len(self.lines)
|
|
self.lines.append('')
|
|
return line
|
|
|
|
@_('')
|
|
def seen_WHILE(self, p):
|
|
# helper to get the line number of when we start the check thing for a while expr
|
|
return len(self.lines)
|
|
|
|
@_('SWITCH error "}"', 'SWITCH "(" expression ")" "{" caselist "}"')
|
|
def switch_stmt(self, p):
|
|
self.had_errors = True
|
|
print_err(f'Invalid switch statement in line {p.lineno}')
|
|
return Statement([])
|
|
|
|
@_('SWITCH "(" expression ")" "{" caselist DEFAULT ":" stmtlist "}"')
|
|
def switch_stmt(self, p):
|
|
# The way this works is, every caselist (and case) return a list of where to put the comparison and jump
|
|
# also, where to jump(as in, where is the next case)
|
|
# they also add a little jump over the next case check, which would probably be
|
|
# removed by the optimizer if there is a break (since we will have 2 jumps one after the other)
|
|
exp = p[2]
|
|
cases = p[5]
|
|
if exp.is_float:
|
|
self.had_errors = True
|
|
print_err(f'Invalid switch statement expression at line {p.lineno}: Expected an integer expression but found float')
|
|
cmp = self.next_temp()
|
|
break_line = f'JUMP {len(self.lines)}'
|
|
for c in cases:
|
|
self.lines[c.line] = f'IEQL {cmp} {exp.result} {c.num}'
|
|
self.lines[c.line + 1] = f'JMPZ {c.end} {cmp}'
|
|
for b in c.breaks:
|
|
self.lines[b] = break_line
|
|
if len(cases) > 0:
|
|
last_case = cases[-1]
|
|
# modify the last jump(that skips over the next check) to not skip the default case
|
|
self.lines[last_case.end - 1] = f'JUMP {last_case.end}' # it is stupid, but an optimizer will hae no problem fixing it
|
|
for b in p[8].breaks: # breaks in default
|
|
self.lines[b] = break_line
|
|
return Statement([])
|
|
|
|
|
|
@_('caselist CASE NUM case_check ":" stmtlist')
|
|
def caselist(self, p):
|
|
# Check that NUM doesnt have a dot(and indeed is an integer)
|
|
if p[2].find('.') != -1:
|
|
self.had_errors = True
|
|
print_err(f'Invalid case constant at line {p.lineno}: Expected an integer but found a float')
|
|
# continue as if nothing happend
|
|
self.lines.append(f'JUMP {len(self.lines) + 3}') # Jump over the next comparison in the case of fallthrough
|
|
|
|
line = p[3]
|
|
return p[0] + [ Case(p[2], line, len(self.lines), p[5].breaks) ]
|
|
|
|
|
|
@_('')
|
|
def case_check(self, p):
|
|
line = len(self.lines)
|
|
self.lines.append('') # IEQL
|
|
self.lines.append('') # JPMZ
|
|
return line
|
|
|
|
@_('')
|
|
def caselist(self, p):
|
|
return []
|
|
|
|
@_('BREAK ";"')
|
|
def break_stmt(self, p):
|
|
line = len(self.lines)
|
|
self.lines.append('') # Empty line for break()
|
|
return Statement([line])
|
|
|
|
@_('"{" stmtlist "}"')
|
|
def stmt_block(self, p):
|
|
return p[1]
|
|
|
|
@_('stmtlist stmt')
|
|
def stmtlist(self, p):
|
|
return Statement(p[0].breaks + p[1].breaks)
|
|
|
|
@_('')
|
|
def stmtlist(self, p):
|
|
return Statement([]) # Empty item
|
|
|
|
@_('boolexpr OR boolterm')
|
|
def boolexpr(self, p):
|
|
res = self.next_temp()
|
|
# add, if one is not 0(aka true), result shall be non zero
|
|
self.lines.append(f'IADD {res} {p[0].result} {p[2].result}')
|
|
return Expression(res, False)
|
|
|
|
@_('boolterm')
|
|
def boolexpr(self, p):
|
|
return p[0]
|
|
|
|
@_('boolterm AND boolfactor')
|
|
def boolterm(self, p):
|
|
res = self.next_temp()
|
|
# multiply, as if one side is 0(aka false), it will be false
|
|
# also, bool items are always int
|
|
self.lines.append(f'IMLT {res} {p[0].result} {p[2].result}')
|
|
return Statement(res, False)
|
|
|
|
@_('boolfactor')
|
|
def boolterm(self, p):
|
|
return p[0]
|
|
|
|
@_('NOT "(" boolexpr ")"')
|
|
def boolfactor(self, p):
|
|
# as far as i understand, all bool expressions are integers(as RELOP always returns an int)
|
|
exp = p[2]
|
|
res = self.next_temp()
|
|
self.lines.append(f'IEQL {res} {exp.result} 0')
|
|
return Expression(res, False)
|
|
|
|
@_('expression RELOP expression')
|
|
def boolfactor(self, p):
|
|
float_op = p[0].is_float or p[2].is_float
|
|
lhs = p[0].result
|
|
rhs = p[2].result
|
|
if float_op: # Check if we need to cast someone to float
|
|
if not p[0].is_float:
|
|
new_term = self.next_temp()
|
|
self.lines.append(f'ITOR {new_term} {lhs}')
|
|
lhs = new_term
|
|
elif not p[2].is_float: # elif since if both are false we wont be here to begin with
|
|
new_term = self.next_temp()
|
|
self.lines.append(f'ITOR {new_term} {rhs}')
|
|
rhs = new_term
|
|
# RELOP to command map
|
|
com_map = { '<': 'LSS', '>': 'GRT', '==': 'EQL', '!=': 'NQL', '<=': 'GRT', '>=': 'LSS' }
|
|
# if we need to negate(since quad doesnt have a built in support for it)
|
|
should_negate = [ '<=', '>=' ]
|
|
command = ('R' if float_op else 'I') + com_map[p[1]]
|
|
result = self.next_temp()
|
|
self.lines.append(f'{command} {result} {lhs} {rhs}')
|
|
if p[1] in should_negate:
|
|
self.lines.append(f'IEQL {result} {result} 0')
|
|
return Expression(result, False)
|
|
|
|
@_('expression ADDOP term')
|
|
def expression(self, p):
|
|
float_op = p[0].is_float or p[2].is_float
|
|
lhs = p[0].result
|
|
rhs = p[2].result
|
|
if float_op: # Check if we need to cast someone to float
|
|
if not p[0].is_float:
|
|
new_term = self.next_temp()
|
|
self.lines.append(f'ITOR {new_term} {lhs}')
|
|
lhs = new_term
|
|
elif not p[2].is_float: # elif since if both are false we wont be here to begin with
|
|
new_term = self.next_temp()
|
|
self.lines.append(f'ITOR {new_term} {rhs}')
|
|
rhs = new_term
|
|
command = ('R' if float_op else 'I') + ('ADD' if p[1] == '+' else 'SUB')
|
|
result = self.next_temp()
|
|
self.lines.append(f'{command} {result} {lhs} {rhs}')
|
|
return Expression(result, float_op)
|
|
|
|
@_('term')
|
|
def expression(self, p):
|
|
return p[0]
|
|
|
|
@_('term MULOP factor')
|
|
def term(self, p):
|
|
float_op = p[0].is_float or p[2].is_float
|
|
lhs = p[0].result
|
|
rhs = p[2].result
|
|
if float_op: # Check if we need to cast someone to float
|
|
if not p[0].is_float:
|
|
new_term = self.next_temp()
|
|
self.lines.append(f'ITOR {new_term} {lhs}')
|
|
lhs = new_term
|
|
elif not p[2].is_float: # elif since if both are false we wont be here to begin with
|
|
new_term = self.next_temp()
|
|
self.lines.append(f'ITOR {new_term} {rhs}')
|
|
rhs = new_term
|
|
command = ('R' if float_op else 'I') + ('MLT' if p[1] == '*' else 'DIV')
|
|
result = self.next_temp()
|
|
self.lines.append(f'{command} {result} {lhs} {rhs}')
|
|
return Expression(result, float_op)
|
|
|
|
@_('factor')
|
|
def term(self, p):
|
|
return p[0]
|
|
|
|
@_('"(" expression ")"')
|
|
def factor(self, p):
|
|
return p[1]
|
|
|
|
@_('CAST "(" expression ")"')
|
|
def factor(self, p):
|
|
cast_to_float = p[0].find('float') != -1 # if its not a cast to float, its probably a cast to int
|
|
exp = p[2]
|
|
if(cast_to_float != exp.is_float): # if we cast from int to float or from float to int
|
|
casted = self.next_temp()
|
|
command = 'ITOR' if cast_to_float else 'RTOI'
|
|
self.lines.append(f'{command} {casted} {exp.result}')
|
|
return Expression(casted, cast_to_float)
|
|
return Expression(exp.result, cast_to_float)
|
|
|
|
@_('ID')
|
|
def factor(self, p):
|
|
if self.symbol_table.get(p[0]) is None:
|
|
self.had_errors = True
|
|
print_err(f'Unknown variable {p[0]} at line {p.lineno}')
|
|
return Expression('0', False)
|
|
return Expression(p[0], self.symbol_table[p[0]].is_float)
|
|
|
|
@_('NUM')
|
|
def factor(self, p):
|
|
return Expression(p.NUM, p[0].find('.') != -1)
|