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