def crearCuadruploExpresion(validOperators):
if (len(globals.operadores) > 0):
if globals.operadores[-1] in validOperators:
operando_der = globals.operandos.pop()
operando_izq = globals.operandos.pop()
tipo_der = globals.tipos.pop()
tipo_izq = globals.tipos.pop()
operador = globals.operadores.pop()
resultType = isValidResult(operador, tipo_izq, tipo_der)
if operador == '=':
cuad = Cuadruplo(operador,
operand1=operando_izq,
result=operando_der,
counter=globals.cuadCounter)
else:
result = memory.ADD_NEW_VAR(resultType, size=1)
st.ADD_MEMORY(globals.currentScope, resultType, 1, True)
cuad = Cuadruplo(operador,
operando_izq,
operando_der,
result=result,
counter=globals.cuadCounter)
globals.tipos.append(resultType)
globals.operandos.append(result)
globals.cuadCounter = globals.cuadCounter + 1
globals.cuadruplos.append(cuad)
def viendo(self):
falso=self.saltos.pop()
retorno=self.saltos.pop()
cuad = Cuadruplo("goto",'_',retorno,'_')
self.estatutos.append(cuad)
cuad = self.estatutos[falso]
cuad.direccion2 = str(len(self.estatutos))
def talvez(self):
cuad = Cuadruplo("goto",'_','_','_')
self.estatutos.append(cuad)
cont = self.saltos.pop()
cuad = self.estatutos[cont]
cuad.direccion2 = str(len(self.estatutos))
self.saltos.append(len(self.estatutos)-1)
def p_crea_else_cuadruplo(p): '''crea_else_cuadruplo : ''' cuadruplo = Cuadruplo(edjo.numCuadruplo, 'GOTO', None, None, None) edjo.cuadruplos.append(cuadruplo) cuadruploALlenar = edjo.saltos.pop() cuadruplo = edjo.cuadruplos[cuadruploALlenar] edjo.saltos.append(edjo.numCuadruplo - 1) edjo.numCuadruplo += 1 cuadruplo.LlenaResultado(edjo.numCuadruplo)
def vez(self):
while self.cuadruplosFor:
self.estatutos.append(self.cuadruplosFor.pop())
falso=self.saltos.pop()
retorno=self.saltos.pop()
cuad = Cuadruplo("goto",'_',retorno,'_')
self.estatutos.append(cuad)
cuad = self.estatutos[falso]
cuad.direccion2 = str(len(self.estatutos))
def createERA(functionCalled):
cuad = Cuadruplo(
'ERA',
operand1=st.SYMBOL_TABLE[st.FUNC][functionCalled][st.NEEDS],
counter=globals.cuadCounter)
globals.cuadCounter = globals.cuadCounter + 1
globals.cuadruplos.append(cuad)
def p_crea_cuadruplo_colorPen(p): ''' crea_cuadruplo_colorPen : ''' operando = edjo.pilaOperandos.pop() cuadruplo = Cuadruplo(edjo.numCuadruplo, 'TUR_COLORPEN', operando, None, None) edjo.cuadruplos.append(cuadruplo) edjo.numCuadruplo += 1
def p_crea_print(p): '''crea_print : ''' operando = edjo.pilaOperandos.pop() cuadruplo = Cuadruplo(edjo.numCuadruplo, 'PRINT', operando, None, None) edjo.cuadruplos.append(cuadruplo) edjo.numCuadruplo += 1
def p_crea_cuadruplo_triangle(p): '''crea_cuadruplo_triangle : ''' operando = edjo.pilaOperandos.pop() cuadruplo = Cuadruplo(edjo.numCuadruplo, 'TUR_TRIANGLE', operando, None, None) edjo.cuadruplos.append(cuadruplo) edjo.numCuadruplo += 1
def p_crea_cuadruplo_left(p): '''crea_cuadruplo_left : ''' operando = edjo.pilaOperandos.pop() cuadruplo = Cuadruplo(edjo.numCuadruplo, 'TUR_LEFT', operando, None, None) edjo.cuadruplos.append(cuadruplo) edjo.numCuadruplo += 1
def p_crea_cuadruplo_colorFill(p): ''' crea_cuadruplo_colorFill : ''' operando = edjo.pilaOperandos.pop() cuadruplo = Cuadruplo(edjo.numCuadruplo, 'TUR_FILL', operando, None, None) edjo.cuadruplos.append(cuadruplo) edjo.numCuadruplo += 1
def p_crea_cuadruplo_forward(p): '''crea_cuadruplo_forward : ''' operando = edjo.pilaOperandos.pop() cuadruplo = Cuadruplo(edjo.numCuadruplo, 'TUR_FORWARD', operando, None, None) edjo.cuadruplos.append(cuadruplo) edjo.numCuadruplo += 1
def p_crea_cuadruplo_circle(p): '''crea_cuadruplo_circle : ''' operando = edjo.pilaOperandos.pop() cuadruplo = Cuadruplo(edjo.numCuadruplo, 'TUR_CIRCLE', operando, None, None) edjo.cuadruplos.append(cuadruplo) edjo.numCuadruplo += 1
def p_crea_cuadruplo_square(p): '''crea_cuadruplo_square : ''' operando = edjo.pilaOperandos.pop() cuadruplo = Cuadruplo(edjo.numCuadruplo, 'TUR_SQUARE', operando, None, None) edjo.cuadruplos.append(cuadruplo) edjo.numCuadruplo += 1
def p_crea_cuadruplo_pos(p): '''crea_cuadruplo_pos : ''' y = edjo.pilaOperandos.pop() x = edjo.pilaOperandos.pop() cuadruplo = Cuadruplo(edjo.numCuadruplo, 'TUR_POS', x, y, None) edjo.cuadruplos.append(cuadruplo) edjo.numCuadruplo += 1
def p_crea_cuadruplo_rectangle(p): ''' crea_cuadruplo_rectangle : ''' altura = edjo.pilaOperandos.pop() ancho =edjo.pilaOperandos.pop() cuadruplo = Cuadruplo(edjo.numCuadruplo, 'TUR_RECTANGLE', altura, ancho, None) edjo.cuadruplos.append(cuadruplo) edjo.numCuadruplo += 1
def createParam(paramCounter, operand, size):
cuad = Cuadruplo('PARAMETER',
operand,
result='{}{}'.format(
paramCounter,
'' if size == 0 else '(' + str(size) + ')'),
counter=globals.cuadCounter)
globals.cuadCounter = globals.cuadCounter + 1
globals.cuadruplos.append(cuad)
def p_regresa_inicio_while(p): '''regresa_inicio_while : ''' cuadruploALlenar = edjo.saltos.pop() regresarCuadruplo = edjo.saltos.pop() cuadruploWhile = Cuadruplo(edjo.numCuadruplo, 'GOTO', None, None, regresarCuadruplo) edjo.cuadruplos.append(cuadruploWhile) edjo.numCuadruplo += 1 cuadruploWhileALlenar = edjo.cuadruplos[cuadruploALlenar] cuadruploWhileALlenar.LlenaResultado(edjo.numCuadruplo)
def p_resuelve_return(p):
'''resuelve_return :
'''
edjo.tieneReturn = True
operando = edjo.pilaOperandos.pop()
tipoOperando = edjo.pilaTipos.pop()
funcion = edjo.dirFuncion.RegresaFuncion(edjo.funcionLocal)
tipoFuncion = funcion['Return']
memValorRetorno = funcion['ReturnMemory']
if tipoFuncion != tipoOperando:
print("Return type of function {0} doesn't match function return type".format(edjo.funcionLocal))
sys.exit()
cuadruplo = Cuadruplo(edjo.numCuadruplo, 'RETURN', operando, None, memValorRetorno)
edjo.cuadruplos.append(cuadruplo)
edjo.numCuadruplo += 1
cuadruplo = Cuadruplo(edjo.numCuadruplo, 'GOTO', None, None, None)
edjo.regresa.append(edjo.numCuadruplo)
edjo.cuadruplos.append(cuadruplo)
edjo.numCuadruplo += 1
def createGoSub(functionCalled):
initialAddress = None
if st.PROC_START in st.SYMBOL_TABLE[st.FUNC][functionCalled]:
initialAddress = st.SYMBOL_TABLE[st.FUNC][functionCalled][
st.PROC_START]
cuad = Cuadruplo('GOSUB',
functionCalled,
result=initialAddress,
counter=globals.cuadCounter)
globals.cuadCounter = globals.cuadCounter + 1
globals.cuadruplos.append(cuad)
def p_crea_cuadruplo_read(p): '''crea_cuadruplo_read : ''' direccionRead = edjo.pilaOperandos.pop() edjo.pilaTipos.pop() tipoVariable = edjo.pilaTipos[-1] dirTemporal = edjo.memoria.MemoriaTemporal(tipoVariable) edjo.pilaOperandos.append(dirTemporal) edjo.pilaTipos.append(tipoVariable) cuadruplo = Cuadruplo(edjo.numCuadruplo, 'INPUT', tipoVariable, direccionRead, dirTemporal) edjo.cuadruplos.append(cuadruplo) edjo.numCuadruplo += 1
def p_resuelve_llamada_funcion(p):
'''resuelve_llamada_funcion :
'''
if not edjo.tiposArgumentos:
funcion = p[-7]
numInicioFuncion = edjo.dirFuncion.RegresaNumeroCuadruplo(funcion)
cuadruplo = Cuadruplo(edjo.numCuadruplo, 'GOSUB', funcion, None, numInicioFuncion)
edjo.cuadruplos.append(cuadruplo)
edjo.numCuadruplo += 1
else:
print('Argument number mismatch at {0} line '.format(p.lexer.lineno))
sys.exit()
def p_checa_funcion_si_existe(p):
'''checa_funcion_si_existe :
'''
funcion = p[-3]
if edjo.dirFuncion.TieneFuncion(funcion):
cuadruplo = Cuadruplo(edjo.numCuadruplo, 'ERA', funcion, None, None)
edjo.cuadruplos.append(cuadruplo)
edjo.numCuadruplo += 1
parametros = edjo.dirFuncion.RegresaParametrosFuncion(funcion)
edjo.tiposArgumentos = list(parametros['Types'])
else:
print("The function " + funcion + " doesn't exist")
sys.exit()
def p_crea_GOTOF(p):
'''crea_GOTOF :
'''
tipoResultado = edjo.pilaTipos.pop()
if tipoResultado != 'bool':
print('Operation type mismatch in line {0}'.format(p.lexer.lineno))
sys.exit()
else:
resultado = edjo.pilaOperandos.pop()
cuadruplo = Cuadruplo(edjo.numCuadruplo, 'GOTOF', resultado, None, None)
edjo.cuadruplos.append(cuadruplo)
edjo.saltos.append(edjo.numCuadruplo - 1)
edjo.numCuadruplo += 1
def p_guarda_resultado_funcion(p): '''guarda_resultado_funcion : ''' nomFuncion = p[-8] funcion = edjo.dirFuncion.RegresaFuncion(nomFuncion) valorRetorno = funcion['ReturnMemory'] tipoFuncion = funcion['Return'] memTemp = edjo.memoria.MemoriaTemporal(tipoFuncion) edjo.dirFuncion.AgregaTemporal(edjo.funcionLocal, tipoFuncion) cuadruplo = Cuadruplo(edjo.numCuadruplo, '=', valorRetorno, None, memTemp) edjo.cuadruplos.append(cuadruplo) edjo.numCuadruplo += 1 edjo.pilaOperandos.append(memTemp) edjo.pilaTipos.append(tipoFuncion)
def p_crea_cuadruplo_ver(p):
'''crea_cuadruplo_ver :
'''
#El numero que va adentro de los []
numeroArreglo = edjo.pilaOperandos.pop()
#Tiene que ser int
tipoNumeroArreglo = edjo.pilaTipos.pop()
variable = edjo.stackArreglos.pop()
if tipoNumeroArreglo != 'int':
print("Error, array index must be integer")
sys.exit()
else:
cuadruplo = Cuadruplo(edjo.numCuadruplo, 'VER', numeroArreglo, variable['LimiteInferior'], variable['LimiteSuperior'])
edjo.cuadruplos.append(cuadruplo)
edjo.numCuadruplo += 1
dir = edjo.memoria.MemoriaGlobal('int', variable['MemoryAddress'])
resultado = edjo.memoria.MemoriaGlobal('int')
cuadruplo = Cuadruplo(edjo.numCuadruplo, '+', dir, numeroArreglo, resultado)
edjo.cuadruplos.append(cuadruplo)
edjo.numCuadruplo += 1
res = {'Address' : resultado}
edjo.pilaOperandos.append(res)
edjo.pilaTipos.append(variable['Type'])
def p_resuelve_asignacion(p):
'''resuelve_asignacion :
'''
operador = edjo.pilaOperadores.pop()
if operador == '=':
operandoDer = edjo.pilaOperandos.pop()
tipoOperandoDer = edjo.pilaTipos.pop()
operandoIzq = edjo.pilaOperandos.pop()
tipoOperandoIzq = edjo.pilaTipos.pop()
resultado = edjo.cuboSemantico.Tipo(tipoOperandoIzq, tipoOperandoDer, operador)
if resultado != 'error':
cuadruplo = Cuadruplo(edjo.numCuadruplo, operador, operandoDer, None, operandoIzq)
edjo.cuadruplos.append(cuadruplo)
edjo.numCuadruplo += 1
else:
print('Operation type mismatch at {0}'.format(p.lexer.lineno))
sys.exit()
def p_resuelve_argumentos(p):
'''resuelve_argumentos :
'''
if edjo.tiposArgumentos:
argumento = edjo.pilaOperandos.pop()
tipoArgumento = edjo.pilaTipos.pop()
tipoParametro = edjo.tiposArgumentos.pop(0)
if tipoArgumento == tipoParametro:
cuadruplo = Cuadruplo(edjo.numCuadruplo, 'PARAMETER', argumento, None, None)
edjo.cuadruplos.append(cuadruplo)
edjo.numCuadruplo += 1
else:
print('Argument type mismatch at {0} lines'.format(p.lexer.lineno))
sys.exit()
else:
print('Argument number mismatch at {0} lines'.format(p.lexer.lineno))
sys.exit()
def resuelve_operacion(p):
operandoDer = edjo.pilaOperandos.pop()
operandoIzq = edjo.pilaOperandos.pop()
tipoOperandoDer = edjo.pilaTipos.pop()
tipoOperandoIzq = edjo.pilaTipos.pop()
operador = edjo.pilaOperadores.pop()
resultado = edjo.cuboSemantico.Tipo(tipoOperandoIzq, tipoOperandoDer, operador)
if resultado != 'error':
memTemp = edjo.memoria.MemoriaTemporal(resultado)
edjo.dirFuncion.AgregaTemporal(edjo.funcionLocal, resultado)
cuadruplo = Cuadruplo(edjo.numCuadruplo, operador, operandoIzq, operandoDer, memTemp)
edjo.cuadruplos.append(cuadruplo)
edjo.numCuadruplo += 1
edjo.pilaOperandos.append(memTemp)
edjo.pilaTipos.append(resultado)
else:
print('Operation type mismatch at {0}'.format(p.lexer.lineno))
sys.exit()
def crearCuadruploUnario(validOperators):
if (len(globals.operadores) > 0):
if globals.operadores[-1] in validOperators:
operando = globals.operandos.pop()
tipo = globals.tipos.pop()
operador = globals.operadores.pop()
resultType = isValidResult(operador, tipo)
virtualAddress = memory.ADD_NEW_VAR(resultType, size=1)
st.ADD_MEMORY(globals.currentScope, resultType, 1, True)
cuad = Cuadruplo(operador,
operand1=operando,
result=virtualAddress,
counter=globals.cuadCounter)
globals.cuadCounter = globals.cuadCounter + 1
globals.operandos.append(virtualAddress)
globals.tipos.append(resultType)
globals.cuadruplos.append(cuad)
def p_fin_func_cuad(p):
'''fin_func_cuad :
'''
tipoFuncion = p[-10]
if tipoFuncion == 'void' and edjo.tieneReturn:
print('Function {0} of type {1} should not have return statement'.format(edjo.funcionLocal, tipoFuncion))
sys.exit()
elif tipoFuncion != 'void' and not edjo.tieneReturn:
print('Function {0} of type {1} should have return statement'.format(edjo.funcionLocal, tipoFuncion))
sys.exit()
else:
cuadruplo = Cuadruplo(edjo.numCuadruplo, 'ENDPROC', None, None, None)
edjo.cuadruplos.append(cuadruplo)
if edjo.tieneReturn:
while edjo.regresa:
cuadruploALlenar = edjo.regresa.pop()
edjo.cuadruplos[cuadruploALlenar - 1].LlenaResultado(edjo.numCuadruplo)
edjo.numCuadruplo += 1
edjo.tieneReturn = False
edjo.funcionLocal = edjo.funcionGlobal
edjo.memoria.ReseteaMemoria()
def p_crea_primer_cuadruplo(p): '''crea_primer_cuadruplo : ''' cuadruplo = Cuadruplo(edjo.numCuadruplo,'GOTO', 'MAIN', None, None) edjo.cuadruplos.append(cuadruplo) edjo.numCuadruplo += 1
def createEndProc():
cuad = Cuadruplo('ENDPROC', counter=globals.cuadCounter)
globals.cuadCounter = globals.cuadCounter + 1
globals.cuadruplos.append(cuad)