def p_expression_new(p):
'expression : NEW type'
rule.append(70)
t = newtemp()
current_symbol_table[0].getVariable(t).datatype = p[2].place
code = ['FUNC_CALL,constructor,' + t]
p[0] = TREE.Expression(code=code, place=t, datatype=p[2].place)
def p_expression_id(p):
'expression : ID'
rule.append(60)
var = current_symbol_table[0].getVariable(p[1])
t = p[1]
p[0] = TREE.Expression(place=t, code=[])
def p_expression_at_function(p):
'expression : expression AT CLASS_TYPE PERIOD ID LPAREN RPAREN'
rule.append(75)
t = newtemp()
ode = p[1].code
code = ['to handle AT']
p[0] = TREE.Expression(code=code, place=t)
def p_expression_paren(p):
'expression : LPAREN expression RPAREN'
rule.append(58)
t = p[2].place
code = p[2].code
p[0] = TREE.Expression(place=t, code=code, datatype=p[2].datatype)
def p_expression_function_call_2(p):
'expression : ID LPAREN RPAREN'
rule.append(41)
met = current_symbol_table[0].getMethod(p[1])
t = newtemp()
code = ['FUNC_CALL,' + p[1] + ',' + t]
# datatype = met.datatype
p[0] = TREE.Expression(code=code, place=t)
def p_expression_at_function_with_arguments(p):
'expression : expression AT CLASS_TYPE PERIOD ID LPAREN argument_list RPAREN'
rule.append(74)
t = newtemp()
code = p[1].code
code.extend(p[7].code)
code = ['to handle AT']
p[0] = TREE.Expression(code=code, place=t)
def p_expression_tilda(p):
'expression : TILDA expression'
rule.append(57)
t = newtemp()
code = p[2].code
code.append('SUB,' + t + ',0,' + p[2].place)
p[0] = TREE.Expression(place=t, code=code, datatype=p[2].datatype)
def p_expression_and(p):
'expression : expression AND expression'
rule.append(55)
t = newtemp()
code = p[1].code
code.extend(p[3].code)
code.append('MUL,' + t + ',' + p[1].place + ',' + p[3].place)
p[0] = TREE.Expression(place=t, code=code, datatype=p[1].datatype)
def p_expression_or(p):
'expression : expression OR expression'
rule.append(54)
t = newtemp()
code = p[1].code
code.extend(p[3].code)
code.append('ADD,' + t + ',' + p[1].place + ',' + p[3].place)
p[0] = TREE.Expression(place=t, code=code, datatype=p[1].datatype)
def p_expression_divide(p):
'expression : expression DIVIDE expression'
rule.append(47)
t = newtemp()
code = p[1].code
code.extend(p[3].code)
code.append('DIV,' + t + ',' + p[1].place + ',' + p[3].place)
p[0] = TREE.Expression(place=t, code=code, datatype=p[1].datatype)
def p_expression_minus(p):
'expression : expression MINUS expression'
rule.append(45)
t = newtemp()
code = p[1].code
code.extend(p[3].code)
code.append('SUB,' + t + ',' + p[1].place + ',' + p[3].place)
p[0] = TREE.Expression(place=t, code=code, datatype=p[1].datatype)
def p_expression_arr(p):
'expression : ID LSQRBRACKET expression RSQRBRACKET'
rule.append(61)
var = current_symbol_table[0].getVariable(p[1])
t = newtemp()
code = p[3].code
code.append('INDEX_ASSIGN_R,' + t + ',' + p[1] + ',' + p[3].place)
p[0] = TREE.Expression(place=t, code=code, datatype='Array')
def p_expression_assign_arr(p):
'expression : ID LSQRBRACKET expression RSQRBRACKET GETS expression'
rule.append(39)
var = current_symbol_table[0].getVariable(p[1])
code = p[6].code
code.extend(p[3].code)
code.append('INDEX_ASSIGN_L,' + p[1] + ',' + p[3].place + ',' + p[6].place)
p[0] = TREE.Expression(code=code, place=p[6].place, datatype='Array')
def p_expression_assign(p):
'expression : ID GETS expression'
rule.append(38)
var = current_symbol_table[0].getVariable(p[1])
code = p[3].code
# print("CODE : ", code, p[3].place, p[3])
s = 'ASSIGN,' + p[1] + ',' + p[3].place
code.append(s)
p[0] = TREE.Expression(code=code, datatype=p[3].datatype)
def p_expression_function_call_with_arguments(p):
'expression : expression PERIOD ID LPAREN argument_list RPAREN'
rule.append(68)
t = newtemp()
code = p[1].code
code.extend(p[5].code)
# print(".................................", p[1].place)
code.append('FUNC_CALL,' +
current_symbol_table[0].getVariable(p[1].place).datatype +
'.' + p[3] + ',' + t)
# print("..........", current_symbol_table[0].getVariable(p[1].place).datatype)
datatype = (ClassDict[current_symbol_table[0].getVariable(
p[1].place).datatype].getMethod(p[3])).datatype
p[0] = TREE.Expression(code=code, place=t)
def p_expression_function_call(p):
'expression : expression PERIOD ID LPAREN RPAREN'
rule.append(69)
t = newtemp()
# print "calling object function : ",current_symbol_table[0].getVariable(p[1].place).datatype
# quit()
code = p[1].code
code.append('FUNC_CALL,' +
current_symbol_table[0].getVariable(p[1].place).datatype +
'.' + p[3] + ',' + t)
# print("..........", current_symbol_table[0].getVariable(p[1].place).datatype)
datatype = (ClassDict[current_symbol_table[0].getVariable(
p[1].place).datatype].getMethod(p[3])).datatype
p[0] = TREE.Expression(code=code, place=t, datatype=datatype)
def p_expression_not(p):
'expression : NOT expression'
rule.append(56)
t = newtemp()
j_if = newjump()
j_fi = newjump()
code = p[2].code
# code.append('LESS_THAN,' + t + ',' + p[1].place + ',' + p[3].place)
code.append("IFGOTO,EQUALS," + p[2].place + ',0,' + j_if)
code.append("ASSIGN," + t + ',0')
code.append("JUMP," + j_fi)
code.append("LABEL," + j_if)
code.append("ASSIGN," + t + ',1')
code.append("LABEL," + j_fi)
p[0] = TREE.Expression(code=code, place=t, datatype='Int')
def p_expression_gteq(p):
'expression : expression GTEQ expression'
rule.append(52)
t = newtemp()
j_if = newjump()
j_fi = newjump()
code = p[1].code
code.extend(p[3].code)
# code.append('LESS_THAN,' + t + ',' + p[1].place + ',' + p[3].place)
code.append("IFGOTO,GREATER_THAN_EQUALS," + p[1].place + ',' + p[3].place +
',' + j_if)
code.append("ASSIGN," + t + ',0')
code.append("JUMP," + j_fi)
code.append("LABEL," + j_if)
code.append("ASSIGN," + t + ',1')
code.append("LABEL," + j_fi)
p[0] = TREE.Expression(code=code, place=t, datatype='Int')
def p_expression_lt(p):
'expression : expression LT expression'
rule.append(49)
t = newtemp()
j_if = newjump()
j_fi = newjump()
# print("@@@@@@@@")
# print(p[3].code)
# print("@@@@@@@")
code = p[1].code
code.extend(p[3].code)
# code.append('LESS_THAN,' + t + ',' + p[1].place + ',' + p[3].place)
code.append("IFGOTO,LESS_THAN," + p[1].place + ',' + p[3].place + ',' +
j_if)
code.append("ASSIGN," + t + ',0')
code.append("JUMP," + j_fi)
code.append("LABEL," + j_if)
code.append("ASSIGN," + t + ',1')
code.append("LABEL," + j_fi)
p[0] = TREE.Expression(code=code, place=t, datatype='Int')
def p_expression_let_expression(p):
'expression : let_expression'
rule.append(72)
p[0] = TREE.Expression(code=p[1].code, datatype=p[1].datatype)
def p_expression_isvoid(p):
'expression : ISVOID expression'
rule.append(71)
t = newtemp()
code = ['FUNC_CALL,isvoid,' + t]
p[0] = TREE.Expression(code=code, place=t, datatype=p[2].datatype)
def p_expression_continue(p):
'expression : CONTINUE'
rule.append(67)
p[0] = TREE.Expression(code=['CONTINUE'])
def p_expression_self(p):
'expression : SELF'
rule.append(59)
p[0] = TREE.Expression(code=['SELF'])
def p_expression_false(p):
'expression : FALSE'
rule.append(65)
p[0] = TREE.Expression(place='0', code=[])
def p_expression_true(p):
'expression : TRUE'
rule.append(64)
p[0] = TREE.Expression(place='1', code=[])
def p_expression_string(p):
'expression : STRING'
rule.append(63)
p[0] = TREE.Expression(place=p[1], datatype='String', code=[])
def p_expression_integer(p):
'expression : INTEGER'
rule.append(62)
p[0] = TREE.Expression(code=[], place=str(p[1]), datatype='Int')
def p_expression_block_expression(p):
'expression : block_expression'
rule.append(34)
p[0] = TREE.Expression(code=p[1].code, datatype=p[1].datatype)
def p_expression_for(p):
'expression : for'
rule.append(80)
p[0] = TREE.Expression(code=p[1].code, datatype=p[1].datatype)
def p_expression_break(p):
'expression : BREAK'
rule.append(66)
p[0] = TREE.Expression(code=['BREAK'])
