def eval_plus(root: ASTNode, cnx=None) -> ASTNode:
childs: List[ASTNode] = root.childs
prev_code_l = ''
prev_code_r = ''
if childs[0].value:
prev_code_l = childs[0].code
izq = childs[0].value
else:
r = eval_expression(childs[0], cnx)
if isinstance(r, ASTNode):
prev_code_l = r.code
izq = r.value
else:
izq = r
if childs[1].value:
prev_code_r = childs[0].code
der = childs[1].value
else:
r = eval_expression(childs[1], cnx)
if isinstance(r, ASTNode):
prev_code_r = r.code
der = r.value
else:
der = r
root.code = "{}{}$t{} = {} {} {};\n".format(prev_code_l, prev_code_r,
str(root.nid), izq, root.typee,
der)
root.value = "$t{}".format(str(root.nid))
return root
def p_declaracion_arraymod(t):
"""declaracion_registros : otra ASIG expresion"""
NodoDeclaracion = ASTNode("declaracion_asignacion", t.lexer.lineno,
find_column(entrada, t.slice[2]))
NodoDeclaracion.add_child(t[1])
NodoDeclaracion.add_child(t[3])
t[0] = NodoDeclaracion
def p_expresion_number(t):
"""expresion : ENTERO
| DECIMAL
| CADENA"""
r_shiftreduce_grammar.append(("expresion_number", str(t[1])))
t[0] = ASTNode("expresion_number", t.lexer.lineno,
find_column(entrada, t.slice[1]), None, ASTNode(t[1]))
def p_declaracion_registros(t):
"""declaracion_registros : tipo_variable lista_ids"""
r_shiftreduce_grammar.append(
("declaracion_registros", "declaracion_variable"))
aux2 = ASTNode("lista_ids", t.lexer.lineno, 0, None, *[j for j in t[2]])
t[0] = ASTNode("declaracion_registros", t.lexer.lineno, 0, None, t[1],
aux2)
def p_sentencia_for(t):
"""sentencia_for : FOR PARIZQ forinit PTCOMA expresion PTCOMA aum_dec PARDER LLAVEIZQ lsentencias LLAVEDER"""
r_shiftreduce_grammar.append(("sentencia_for", "instrucciones"))
a = ASTNode("linstr", t.lexer.lineno, 0, 0, *[j for j in t[10]])
c = [t[3], t[5], t[7], a]
t[0] = ASTNode("sentencia_for", t.lexer.lineno,
find_column(entrada, t.slice[1]), 0, *c)
def p_declaracoin_funcionmain(t):
"""declaracion_funciones : INT MAIN PARIZQ PARDER LLAVEIZQ lsentencias LLAVEDER"""
r_shiftreduce_grammar.append(("declaracion_funciones", "main"))
aux = ASTNode("linstr", t.lexer.lineno, 0, 0, *[j for j in t[6]])
t[0] = ASTNode("declaracion_funcion", t.lexer.lineno,
find_column(entrada, t.slice[1]), 0, ASTNode(t[1]),
ASTNode(t[2]), aux)
def p_sentencia_else(t):
"""sentencia_if : IF PARIZQ expresion PARDER LLAVEIZQ lsentencias LLAVEDER ELSE LLAVEIZQ lsentencias LLAVEDER"""
r_shiftreduce_grammar.append(("sentencia_if", "if_else"))
a = ASTNode("linstr", t.lexer.lineno, 0, 0, *[i for i in t[6]])
b = ASTNode("linstr", t.lexer.lineno, 0, 0, *[i for i in t[10]])
t[0] = ASTNode("sentencia_if", t.lexer.lineno,
find_column(entrada, t.slice[1]), 0, t[3], a, b)
def p_casteos(t):
"""casteos : PARIZQ tipo_casteo PARDER expresion"""
NodoCasteo = ASTNode("casteos", t.lexer.lineno,
find_column(entrada, t.slice[1]))
NodoCasteo.add_child(t[2])
NodoCasteo.add_child(t[4])
t[0] = NodoCasteo
def p_expresion_unaria(t):
"""expresion : MENOS expresion %prec UMENOS
| NOT expresion
| NOTBIT expresion"""
r_shiftreduce_grammar.append(("expresion", str(t[1])))
t[0] = ASTNode("expresion_unaria", t.lexer.lineno,
find_column(entrada, t.slice[1]), None, ASTNode(t[1]), t[2])
def p_expresion_acceso_array(t):
"""expresion : ID lista_accesos"""
childs = [
ASTNode(t[1]),
ASTNode("l_acceso", t.lexer.lineno, 0, None, *[i for i in t[2]])
]
t[0] = ASTNode("acceso", t.lexer.lineno, find_column(entrada, t.slice[1]),
None, childs)
def p_declaracion_funcion2(t):
"""declaracion_funciones : tipo_variable ID PARIZQ lista_params PARDER LLAVEIZQ lsentencias LLAVEDER """
r_shiftreduce_grammar.append(("declaracion_funciones", str(t[2])))
aux = ASTNode("param_func", t.lexer.lineno, 0, 0, *[i for i in t[4]])
aux2 = ASTNode("linstr", t.lexer.lineno, 0, 0, *[j for j in t[7]])
c = [t[1], ASTNode(t[2]), aux, aux2]
t[0] = ASTNode("declaracion_funcion", t.lexer.lineno,
find_column(entrada, t.slice[2]), 0, *c)
def p_tipo_variable(t):
"""tipo_variable : DOUBLE
| INT
| FLOAT
| CHAR
| VOID"""
r_shiftreduce_grammar.append(("tipo_variable", str(t[1])))
t[0] = ASTNode("tipo_variable", t.lexer.lineno,
find_column(entrada, t.slice[1]), None, ASTNode(t[1]))
def p_expresion_llamada_funcion(t):
"""callfuncion : ID PARIZQ l_expresion PARDER"""
r_shiftreduce_grammar.append(("call_funcion", str(t[1])))
childs = [
ASTNode(t[1]),
ASTNode("l_expresiones", t.lexer.lineno, 0, 0, *[i for i in t[3]])
]
t[0] = ASTNode("call_funcion", t.lexer.lineno,
find_column(entrada, t.slice[1]), None, *childs)
def evaluar_ast(ast: ASTNode):
ast.code = ''
value = ast.typee
if isinstance(value, float) or isinstance(value, int):
ast.value = ast.typee
return ast
elif isinstance(value, str):
ast.value = "'{}'".format(ast.typee)
return ast
return 0
def p_tipo_casteo(t):
"""tipo_casteo : RINT
| RFLOAT
| RCHAR """
NodoCasteo = ASTNode("tipo_casteo", t.lexer.lineno,
find_column(entrada, t.slice[1]))
NodoauxCast = ASTNode(t[1], t.lexer.lineno,
find_column(entrada, t.slice[1]))
NodoCasteo.add_child(NodoauxCast)
t[0] = NodoCasteo
def p_declar_opcion5(t):
"""declar_opcion : ID CORIZQ CORDER tipos_asignacion expresion"""
childs = [
ASTNode(t[1]),
t[4],
t[5],
]
r_shiftreduce_grammar.append(("declar_opcion", str(t[1])))
t[0] = ASTNode("tipo_declaracion5", t.lexer.lineno,
find_column(entrada, t.slice[1]), None, *childs)
def p_l_param(t):
"""l_param : tipo_variable ID
| STRUCT ID declar_opcion"""
r_shiftreduce_grammar.append(("l_param", "tipo_parametro"))
if t[1] == 'struct':
t[0] = ASTNode("l_param", t.lexer.lineno,
find_column(entrada, t.slice[2]), 0, ASTNode(t[2]),
t[3])
else:
t[0] = ASTNode("l_param", t.lexer.lineno,
find_column(entrada, t.slice[2]), 0, t[1],
ASTNode(t[2]))
def p_expresion_number(t):
"""expresion : ENTERO
| DECIMAL
| ID
| CADENA
| RABS PARIZQ expresion PARDER
| RARRAY PARIZQ PARDER
| RREAD PARIZQ PARDER"""
if t[1] == "abs":
t[0] = ASTNode("abs", t.lexer.lineno, find_column(entrada, t.slice[1]),
None, t[3])
else:
t[0] = ASTNode("expresion_number", t.lexer.lineno,
find_column(entrada, t.slice[1]), None, ASTNode(t[1]))
def p_tipos_asignacion(t):
"""tipos_asignacion : ASIG
| ASIGMAS
| ASIGMENOS
| ASIGPOR
| ASIGDIV
| ASIGMODULO
| ASIGSHIFTIZQ
| ASIGSHITFDER
| ASIGAND
| ASIGOR
| ASIGXOR"""
r_shiftreduce_grammar.append(("tipo_asignacion", str(t[1])))
t[0] = ASTNode("tipo_asignacion", t.lexer.lineno,
find_column(entrada, t.slice[1]), None, ASTNode(t[1]))
def p_sentencias_control(p):
"""sentencias_control : sentencia_if
| sentencia_while
| sentencia_dowhile
| sentencia_switch
| sentencia_for"""
r_shiftreduce_grammar.append(("sentencias_control", "flujos_control"))
p[0] = ASTNode("sentencias_control", p.lexer.lineno, 0, 0, p[1])
def p_acceso_arrayExp(t):
"""accesos_array : ID lista_accesos"""
NodoAccesArray = ASTNode("access_arrayexp", t.lexer.lineno,
find_column(entrada, t.slice[1]))
NodoAccesArray.add_child(ASTNode(t[1]))
NodoAccesArray.add_child(t[2])
t[0] = NodoAccesArray
def p_otra(t):
"""otra : ID lista_accesos"""
NodoModificacion = ASTNode("modificar_array", t.lexer.lineno,
find_column(entrada, t.slice[1]))
NodoModificacion.add_child(ASTNode(t[1]))
NodoModificacion.add_child(t[2])
t[0] = NodoModificacion
def p_instruccion_control(t):
"""instruccion_control : RIF PARIZQ expresion PARDER RGOTO ETIQUETA"""
NodoControl = ASTNode("sentencia_control", t.lexer.lineno,
find_column(entrada, t.slice[1]))
NodoControl.add_child(t[3])
NodoControl.add_child(ASTNode(t[6]))
t[0] = NodoControl
def p_instrucciones_evaluar(p):
"""instruccion : declaracion_registros PTCOMA
| asignacion_registros PTCOMA
| declaracion_structs PTCOMA
| declaracion_funciones
| sentencias_control
| funcion_print PTCOMA
| crear_struct PTCOMA"""
r_shiftreduce_grammar.append(("instruccion", "sentencias"))
p[0] = ASTNode("sentencias", p.lexer.lineno, 0, 0, p[1])
def p_expresion_unaria(t):
"""expresion : MENOS expresion %prec UMENOS
| RNOT expresion
| RNOTBIT expresion"""
NodoExpresionUnaria = ASTNode("expresion_unaria", t.lexer.lineno,
find_column(entrada, t.slice[1]))
NodoExpresionUnaria.add_child(ASTNode(t[1]))
NodoExpresionUnaria.add_child(t[2])
t[0] = NodoExpresionUnaria
def p_expression_binop(p):
"""expr : expr PLUS expr
| expr MINUS expr
| expr TIMES expr
| expr DIV expr"""
line = p.lineno(0)
col = p.lexpos(0)
if p[2] == "/":
if p[3] == 0:
print("Can't divide by 0")
raise ZeroDivisionError("integer division by 0")
p[0] = ASTNode(ASTTypes.EXPRESSION.value, line, col, p[2], p[1], p[3])
def p_expresion_binaria(t):
"""expresion : expresion MAS expresion
| expresion MENOS expresion
| expresion POR expresion
| expresion DIVIDIDO expresion
| expresion MODULO expresion
| expresion AND expresion
| expresion OR expresion
| expresion MAYOR expresion
| expresion MENOR expresion
| expresion MAYORIGUAL expresion
| expresion MENORIGUAL expresion
| expresion IGUAL expresion
| expresion DIFERENTE expresion
| expresion ANDBIT expresion
| expresion ORBIT expresion
| expresion XORBIT expresion
| expresion SHIFTIZQ expresion
| expresion SHIFTDER expresion"""
r_shiftreduce_grammar.append(("expresion", str(t[2])))
t[0] = ASTNode(t[2], t.lexer.lineno, find_column(entrada, t.slice[2]),
None, t[1], t[3])
def p_expresion_binaria(t):
"""expresion : expresion MAS expresion
| expresion MENOS expresion
| expresion POR expresion
| expresion DIVIDIDO expresion
| expresion MODULO expresion
| expresion RAND expresion
| expresion ROR expresion
| expresion RXOR expresion
| expresion MAYOR expresion
| expresion MENOR expresion
| expresion MAYORIGUAL expresion
| expresion MENORIGUAL expresion
| expresion IGUAL expresion
| expresion DIFERENTE expresion
| expresion RANDBIT expresion
| expresion RORBIT expresion
| expresion RXORBIT expresion
| expresion SHIFTIZQ expresion
| expresion SHIFTDER expresion"""
t[0] = ASTNode(t[2], t.lexer.lineno, find_column(entrada, t.slice[2]),
None, t[1], t[3])
def p_funcion_unset(t):
"""funcion_unset : RUNSET PARIZQ expresion PARDER"""
NodoUnset = ASTNode("unset", t.lexer.lineno,
find_column(entrada, t.slice[1]))
NodoUnset.add_child(t[3])
t[0] = NodoUnset
def p_salto_condicional(t):
"""salto_condicional : RGOTO ETIQUETA"""
NodoSaltoCond = ASTNode("salto_incondicional", t.lexer.lineno,
find_column(entrada, t.slice[1]))
NodoSaltoCond.add_child(ASTNode(t[2]))
t[0] = NodoSaltoCond
