def p_r_genera_escribe_string(p):
'r_genera_escribe_string : '
global constant_string
insertion = const_table.insert_constant(p[-1], 'string', constant_string)
if insertion != constant_string:
cuad = Quadruple("write", None, None, insertion)
else:
cuad = Quadruple("write", None, None, constant_string)
constant_string += 1
cuadruplos.append(cuad)
def p_r_pop_comp(p):
'r_pop_comp : '
if len(pila_operadores) > 0:
if (pila_operadores[len(pila_operadores) - 1] in comp_set):
operando_der = pila_operandos.pop()
operando_izq = pila_operandos.pop()
tipo_der = pila_tipos.pop()
tipo_izq = pila_tipos.pop()
operator = pila_operadores.pop()
print(operator)
print(tipo_izq)
print(tipo_der)
res_type = semantic_cube[tipo_izq][tipo_der][operator]
print(res_type)
if res_type != "Error":
global temporal_float
global temporal_int
global temporal_bool
#verifica que el tipo se tal (ESTE TIPO,-1)
if res_type == 'float':
cuad = Quadruple(operator, operando_izq, operando_der,
temporal_float)
pila_operandos.append(temporal_float)
temporal_float += 1
fun_dict.curr_function.temporal_float_spaces += 1
elif res_type == 'int':
cuad = Quadruple(operator, operando_izq, operando_der,
temporal_int)
pila_operandos.append(temporal_int)
temporal_int += 1
fun_dict.curr_function.temporal_int_spaces += 1
elif res_type == 'bool':
cuad = Quadruple(operator, operando_izq, operando_der,
temporal_bool)
pila_operandos.append(temporal_bool)
temporal_bool += 1
fun_dict.curr_function.temporal_bool_spaces += 1
pila_tipos.append(res_type)
tabla_temporales.append((-1, -1))
cuadruplos.append(cuad)
else:
raise Exception("La combinación de tipos no es compatible " +
tipo_izq + ' ' + operator + ' ' + tipo_der)
def p_r_if_paso_2(p):
'r_if_paso_2 : '
cuad = Quadruple('goto', None, None, None)
cuadruplos.append(cuad)
salto = pila_saltos.pop()
pila_saltos.append(len(cuadruplos) - 1)
cuadruplos[salto].modificar_resultado(len(cuadruplos))
def p_r_while_paso_2(p):
'r_while_paso_2 : '
#preguntar el tipo si el operando es boolano
resultado = pila_operandos.pop()
cuad = Quadruple('gotof', resultado, None, None)
pila_saltos.append(len(cuadruplos))
cuadruplos.append(cuad)
def p_r_if_paso_1(p):
'r_if_paso_1 : '
#preguntar el tipo si el operando es boolano
result = pila_operandos.pop()
cuad = Quadruple('gotof', result, None, None)
cuadruplos.append(cuad)
pila_saltos.append(len(cuadruplos) - 1)
def p_r_while_paso_3(p):
'r_while_paso_3 : '
#preguntar el tipo si el operando es boolano
salto_al_final = pila_saltos.pop()
salto_al_regreso = pila_saltos.pop()
cuad = Quadruple('goto', None, None, salto_al_regreso)
cuadruplos.append(cuad)
cuadruplos[salto_al_final].modificar_resultado(len(cuadruplos))
def p_r_for_paso_1(p):
'r_for_paso_1 : '
global temporal_bool
valor_limite = pila_operandos.pop()
valor_de_comp = pila_operandos.pop()
#verificar que valor limite sea int
pila_saltos.append(len(cuadruplos))
cuad = Quadruple('<', valor_de_comp, valor_limite, temporal_bool)
pila_operandos.append(valor_de_comp)
pila_tipos.append('int')
#pila_operandos.append((0,len(tabla_temporales)))
#tabla_temporales.append((-1,-1))
cuadruplos.append(cuad)
#guardar salto del gotof
pila_saltos.append(len(cuadruplos))
#resultado_gotof = pila_operandos.pop()
cuad2 = Quadruple('gotof', temporal_bool, None, None)
temporal_bool += 1
cuadruplos.append(cuad2)
def p_r_verifica_arrexp_dos(p):
'r_verifica_arrexp_dos : '
global pointers
global temporal_int
global constant_int
pila_operadores.pop()
verifica = pila_guardar_variable.pop()
if (verifica == "tipo arreglo"):
raise Exception("La variable no es una matriz")
name_var = pila_guardar_variable.pop()
var = fun_dict.get_variable(name_var)
if ("dim_uno" in var
and var["dim_uno"] != None) and ("dim_dos" in var
and var["dim_dos"] != None):
pila_guardar_variable.append("tipo arreglo")
index = pila_operandos.pop()
tipo_var = pila_tipos.pop()
if tipo_var != "int":
raise Exception("La expresion tiene que ser de tipo entero")
l_limit = const_table.insert_constant(0, "int", constant_int)
if l_limit == constant_int:
constant_int += 1
u_limit = const_table.insert_constant(var["dim_dos"], "int",
constant_int)
if u_limit == constant_int:
constant_int += 1
quad = Quadruple('ver', index, l_limit, u_limit)
cuadruplos.append(quad)
temporal_index = pila_operandos.pop()
pila_tipos.pop()
quad = Quadruple('+', temporal_index, index, temporal_int)
cuadruplos.append(quad)
quad = Quadruple('+_', temporal_int, var["virtual_address"], pointers)
cuadruplos.append(quad)
temporal_int += 1
pila_tipos.append(var["type"])
pila_operandos.append(pointers)
pointers += 1
def p_r_pila_operandos_push(p):
'r_pila_operandos_push : '
global temporal_float
global temporal_int
oper = pila_guardar_variable.pop()
if oper != "tipo matriz":
if oper != "tipo arreglo":
var = fun_dict.get_variable(oper)
if var:
if ("dim_uno" in var and var["dim_uno"] == None) and (
"dim_dos" in var and var["dim_dos"] == None):
pila_operandos.append(var['virtual_address'])
pila_tipos.append(var["type"])
else:
raise Exception("La variable tiene dimensiones")
else:
funcion = fun_dict.search_function(oper)
if not funcion:
raise Exception("El identificador " + oper + " no existe")
else:
return_type = funcion.type
if return_type == "float":
new_quad = Quadruple('=', oper, None, temporal_float)
pila_operandos.append(temporal_float)
pila_tipos.append("float")
temporal_float += 1
else:
func = fun_dict.search_global(oper + "_func")
new_quad = Quadruple('=', func["virtual_address"],
None, temporal_int)
pila_operandos.append(temporal_int)
pila_tipos.append("int")
temporal_int += 1
cuadruplos.append(new_quad)
else:
raise Exception("La variable debe ser matriz")
def p_r_extraer_parametro(p):
'r_extraer_parametro : '
global apuntador_argumento
print(apuntador_argumento)
print(tipos_argumentos)
if apuntador_argumento < len(tipos_argumentos) and len(
tipos_argumentos) > 0:
resultado = pila_operandos.pop()
if tipos_argumentos[apuntador_argumento] == 'int':
cuad = Quadruple('parameter', resultado, None,
"parameter" + str(apuntador_argumento))
cuadruplos.append(cuad)
apuntador_argumento += 1
elif tipos_argumentos[apuntador_argumento] == 'float':
cuad = Quadruple('parameter', resultado, None,
"parameter" + str(apuntador_argumento))
cuadruplos.append(cuad)
apuntador_argumento += 1
else:
raise Exception(
"el tipo de argumento no es del tipo del parametro")
else:
raise Exception("La funcion no tiene ese numero de parametros")
def p_r_for_paso_2(p):
'r_for_paso_2 : '
resultado = pila_operandos.pop()
#guardar constante 1
global constant_int
global temporal_int
insertion = const_table.insert_constant(1, 'int', constant_int)
if insertion != constant_int:
cuad = Quadruple('+', insertion, resultado, temporal_int)
else:
cuad = Quadruple('+', constant_int, resultado, temporal_int)
constant_int += 1
cuadruplos.append(cuad)
cuadasignacion = Quadruple('=', temporal_int, None, resultado)
temporal_int += 1
cuadruplos.append(cuadasignacion)
gotof = pila_saltos.pop()
retorno = pila_saltos.pop()
cuadgoto = Quadruple('goto', None, None, retorno)
cuadruplos.append(cuadgoto)
cuadruplos[gotof].modificar_resultado(len(cuadruplos))
def p_r_return_func(p):
'r_return_func : '
global flag_return
flag_return = True
result = pila_operandos.pop()
tipo = pila_tipos.pop()
if tipo == fun_dict.curr_function.type:
space = fun_dict.search_global(fun_dict.curr_function.name +
'_func')["virtual_address"]
cuad = Quadruple('return', space, None, result)
cuadruplos.append(cuad)
else:
curr_func = fun_dict.curr_function
raise Exception("Error, la función " + curr_func.name +
" es de tipo " + curr_func.type +
" y el retorno de tipo " + tipo)
def p_r_pop_igu_for(p):
'r_pop_igu_for : '
operando_der = pila_operandos.pop()
operando_izq = pila_operandos.pop()
tipo_der = pila_tipos.pop()
tipo_izq = pila_tipos.pop()
operator = pila_operadores.pop()
res_type = semantic_cube[tipo_izq][tipo_der][operator]
if tipo_der == "int" and tipo_izq == "int":
cuad = Quadruple(operator, operando_der, None, operando_izq)
#verifica que el tipo se tal (ESTE TIPO,-1)
#verifica que sea del tipo igual a
pila_operandos.append(operando_izq)
pila_tipos.append('int')
cuadruplos.append(cuad)
else:
raise Exception("Los dos operandos deben ser enteros")
def p_r_pop_igu(p):
'r_pop_igu : '
if len(pila_operadores) > 0:
if (pila_operadores[len(pila_operadores) - 1] == '='):
operando_der = pila_operandos.pop()
operando_izq = pila_operandos.pop()
tipo_der = pila_tipos.pop()
tipo_izq = pila_tipos.pop()
operator = pila_operadores.pop()
res_type = semantic_cube[tipo_izq][tipo_der][operator]
if res_type != "Error":
cuad = Quadruple(operator, operando_der, None, operando_izq)
cuadruplos.append(cuad)
else:
raise Exception("La combinación de tipos no es compatible " +
tipo_izq + ' ' + operator + ' ' + tipo_der)
def p_r_era_funcion_retorno(p):
'r_era_funcion_retorno : '
# guardar nombre de la función llamada
pila_operadores.append("FUNC")
nombre_func = pila_guardar_variable[-1]
pila_nombre_func.append(nombre_func)
func = fun_dict.search_function(nombre_func)
if func:
if func.type != "void":
global apuntador_argumento
cuad = Quadruple('era', None, None, nombre_func)
cuadruplos.append(cuad)
if apuntador_argumento > -1:
pila_apuntador_argumentos.append(apuntador_argumento)
if len(tipos_argumentos) > 0:
apuntador_argumento = 0
else:
raise Exception("La función " + nombre_func + " es de tipo void")
else:
raise Exception("La función " + nombre_func + " no ha sido declarada")
def p_r_terminar_parametro_void(p):
'r_terminar_parametro_void : '
global apuntador_argumento
global tipos_argumentos
global temporal_int
pila_operadores.pop()
nombrefunc = pila_nombre_func.pop()
num_quad = fun_dict.search_quad(nombrefunc)
cuad = Quadruple('gosub', None, None, num_quad)
cuadruplos.append(cuad)
if apuntador_argumento != -1:
if apuntador_argumento < len(tipos_argumentos):
raise Exception("Faltaron argumentos a la llamada de funcion")
else:
if len(pila_apuntador_argumentos) > 0:
apuntador_argumento = pila_apuntador_argumentos.pop()
else:
apuntador_argumento = -1
if len(pila_tipos_argumentos) > 0:
tipos_argumentos = pila_tipos_argumentos.pop()
else:
tipos_argumentos = []
def p_r_endfunc(p):
'r_endfunc : '
cuad = Quadruple('endfunc', None, None, None)
cuadruplos.append(cuad)
def p_r_genera_lectura(p):
'r_genera_lectura : '
cuad = Quadruple("read", None, None, pila_operandos.pop())
pila_tipos.pop()
cuadruplos.append(cuad)
def p_r_register_gotomain(p):
'r_register_gotomain : '
cuad = Quadruple('goto', None, None, None)
cuadruplos.append(cuad)
pila_saltos.append(len(cuadruplos) - 1)
def p_r_verifica_arrexp_uno(p):
'r_verifica_arrexp_uno : '
global pointers
global temporal_int
global constant_int
name_var = pila_guardar_variable.pop()
var = fun_dict.get_variable(name_var)
pila_operadores.pop()
if var["dim_uno"] == None:
raise Exception("La variable " + name_var + " no es un arreglo")
elif ("dim_uno" in var
and var["dim_uno"] != None) and ("dim_dos" in var
and var["dim_dos"] == None):
print("Entra")
index = pila_operandos.pop()
tipo_var = pila_tipos.pop()
if tipo_var != "int":
raise Exception("La expresion tiene que ser de tipo entero")
l_limit = const_table.insert_constant(0, "int", constant_int)
if l_limit == constant_int:
constant_int += 1
u_limit = const_table.insert_constant(var["dim_uno"], "int",
constant_int)
if u_limit == constant_int:
constant_int += 1
quad = Quadruple('ver', index, l_limit, u_limit)
cuadruplos.append(quad)
quad = Quadruple('+_', index, var["virtual_address"], pointers)
cuadruplos.append(quad)
pila_tipos.append(var["type"])
pila_operandos.append(pointers)
pila_guardar_variable.append("tipo arreglo")
pointers += 1
elif ("dim_uno" in var
and var["dim_uno"] != None) and ("dim_dos" in var
and var["dim_dos"] != None):
pila_guardar_variable.append(name_var)
pila_guardar_variable.append("tipo matriz")
index = pila_operandos.pop()
tipo_var = pila_tipos.pop()
if tipo_var != "int":
raise Exception("La expresion tiene que ser de tipo entero")
l_limit = const_table.insert_constant(0, "int", constant_int)
if l_limit == constant_int:
constant_int += 1
u_limit = const_table.insert_constant(var["dim_uno"], "int",
constant_int)
if u_limit == constant_int:
constant_int += 1
quad = Quadruple('ver', index, l_limit, u_limit)
cuadruplos.append(quad)
print("La dimension dos es:")
print(var["dim_dos"])
quad = Quadruple('*_', index, var["dim_dos"], temporal_int)
cuadruplos.append(quad)
pila_tipos.append("int")
pila_operandos.append(temporal_int)
temporal_int += 1
def p_r_genera_escribe(p):
'r_genera_escribe : '
cuad = Quadruple("write", None, None, pila_operandos.pop())
pila_tipos.pop()
cuadruplos.append(cuad)