def traducir(self, ent, arbol, ventana):
simbolo = ent.obtener(str(self.id))
if (simbolo == None):
error = Error(
"SEMANTICO",
"Error semantico, No existe la variable con identificador " +
self.id, self.linea, self.columna)
ReporteErrores.func(error)
return None
strAccesos = ""
for llave in self.llaves:
expresion = llave.traducir(ent, arbol, ventana)
if (expresion == None): return None
if (expresion.codigo3D != ""):
ventana.editor.append("\n" + expresion.codigo3D)
temporal = expresion.temporal.utilizar()
if ' ' in temporal:
temp2 = Temp.nuevoTemporal(1)
ventana.editor.append("\n" + temp2.utilizar() + " = " +
temporal + ";")
temporal = temp2.utilizar()
strAccesos += "[" + temporal + "]"
resultado3D = Resultado3D()
resultado3D.codigo3D = ""
resultado3D.tipo = simbolo.tipo
resultado3D.temporal = Temporal(simbolo.temporal + strAccesos)
return resultado3D
def t_error(t):
error = Error.Error(
"LEXICO", "Error lexico, Caracter " + t.value[0] + " no es valido.",
t.lexer.lineno, find_column(t))
ReporteErrores.func(error)
#print("Illegal character '%s'" % t.value[0])
t.lexer.skip(1)
def obtenerValorNumerico(self, cadena):
decimal = False
retorno = ""
for caracter in cadena:
if (caracter.isdigit()):
retorno += caracter
elif (caracter == "." and retorno != ""):
if not decimal:
decimal = True
retorno += caracter
else:
error = Error(
"SEMANTICO",
"Error semantico, No es posible convertir la cadena ("
+ cadena + ") a un número", self.linea, self.columna)
ReporteErrores.func(error)
break
else:
error = Error(
"SEMANTICO",
"Error semantico, No es posible convertir la cadena (" +
cadena + ") a un número", self.linea, self.columna)
ReporteErrores.func(error)
break
if (retorno == ""): return 0
if retorno.endswith("."): return int(retorno[0:len(retorno) - 1])
if decimal: return float(retorno)
return int(retorno)
def p_error(t):
try:
error = Error.Error("SINTACTICO","Error sintactico, no se esperaba el valor "+t.value,t.lineno,find_column(t))
ReporteErrores.func(error)
except:
error = Error.Error("SINTACTICO","Error sintactico",1,1)
ReporteErrores.func(error)
def debug(self):
self.hilo_terminado = False
main = self.ast.obtenerEtiqueta("main")
if (main != None):
salir = False
self.editor.setCursorPosition(0, 0)
self.editor.setFocus()
time.sleep(2)
for ins in main.instrucciones:
QApplication.processEvents()
try:
self.editor.setCursorPosition(ins.linea - 1, 0)
self.editor.setFocus()
time.sleep(2)
if (isinstance(ins, Asignacion.Asignacion)
or isinstance(ins, Conversion.Conversion)):
ins.setAmbito("main")
if (ins.ejecutar(self.ts_global, self.ast, self,
True) == True):
salir = True
break
contador = 1
self.tableWidget.setRowCount(0)
self.tableWidget.setRowCount(100)
self.tableWidget.setItem(0, 0, QTableWidgetItem("No."))
self.tableWidget.setItem(0, 1, QTableWidgetItem("Simbolo"))
self.tableWidget.setItem(0, 2, QTableWidgetItem("Valor"))
for key in self.ts_global.tabla:
s = self.ts_global.tabla[key]
self.tableWidget.setItem(
contador, 0, QTableWidgetItem(str(contador)))
self.tableWidget.setItem(contador, 1,
QTableWidgetItem(s.id))
self.tableWidget.setItem(
contador, 2, QTableWidgetItem(str(s.valor)))
contador = contador + 1
except:
pass
if (not salir):
siguiente = self.ast.obtenerSiguienteEtiqueta("main")
if (siguiente != None):
siguiente.ejecutar(self.ts_global, self.ast, self, True)
else:
error = Error.Error(
"SEMANTICO",
"Error semantico, No puede iniciarse el programa ya que no existe la etiqueta main:",
0, 0)
ReporteErrores.func(error)
listado = ReporteErrores.func(None)
if (len(listado) > 0):
QMessageBox.critical(
self.centralwidget, "Errores en Ejecución",
"Se obtuvieron errores en la ejecución del Código Ingresado, verifique reporte de Errores"
)
self.hilo_terminado = True
def traducir(self,ent,arbol,ventana):
valorfinal = "print(\""
cadena = self.cad.traducir(ent,arbol,ventana)
if(cadena == None): return None
if(self.expresiones==None):
if(cadena.tipo == Tipo.CHAR):
valorfinal = "print("+cadena.temporal.utilizar()+");"
else:
valorfinal += cadena.temporal.utilizar()+"\");"
else:
cadena = cadena.temporal.utilizar()
cadena = cadena[1:-1]
for expresion in self.expresiones:
exp_3D = expresion.traducir(ent,arbol,ventana)
if(exp_3D == None): return None
if(expresion.tipo == Op.PRIMITIVO):
if(exp_3D.codigo3D != ""): ventana.editor.append("\n"+exp_3D.codigo3D)
pos = cadena.index("%")
if(pos==-1):
error = Error("SEMANTICO","Error semantico, La expresión es incorrecta para imprimir.",self.linea,self.columna)
ReporteErrores.func(error)
return None
llave = cadena[pos:pos+2]
cadena = self.concatenar(cadena,llave,exp_3D.temporal.utilizar())
if(cadena == None): return None
else:
#if(exp_3D.codigo3D != ""): ventana.editor.append("\n"+exp_3D.codigo3D)
pos = cadena.index("%")
if(pos==-1):
error = Error("SEMANTICO","Error semantico, La expresión es incorrecta para imprimir.",self.linea,self.columna)
ReporteErrores.func(error)
return None
temporal = exp_3D.temporal.utilizar()
if ' ' in temporal:
temp2 = Temp.nuevoTemporal(1)
ventana.editor.append("\n"+temp2.utilizar()+" = "+temporal+";")
temporal = temp2.utilizar()
ventana.editor.append("\n"+"print(\""+cadena[0:pos]+"\");")
if(exp_3D.codigo3D != ""): ventana.editor.append("\n"+exp_3D.codigo3D)
ventana.editor.append("\n"+"print("+temporal+");")
cadena = cadena[pos+2:]
valorfinal += cadena+"\");"
ventana.editor.append("\n"+valorfinal)
def ejecutar(self,ent,arbol,ventana,isDebug):
etiqueta = arbol.obtenerEtiqueta(self.id)
if(etiqueta == None):
error = Error("SEMANTICO","Error semantico, no existe la etiqueta "+self.id,self.linea,self.columna)
ReporteErrores.func(error)
else:
etiqueta.ejecutar(ent,arbol,ventana,isDebug)
# if(type(resultado) is Exit.Exit):
# return resultado
return True
return False
def ejecutar(self, ent, arbol, ventana, isDebug):
value = self.valor.getValorImplicito(ent, arbol)
if (isinstance(value, dict)):
els = list(value.items())
value = els[0][1]
if (isinstance(value, dict)):
error = Error.Error(
"SEMANTICO",
"Error semantico, La primera posición del array es otro array. ",
self.linea, self.columna)
ReporteErrores.func(error)
return False
if (self.tipo == 'int'):
if (isinstance(value, float)):
value = int(value)
elif (isinstance(value, str)):
value = ord(value[0])
else:
value = value
elif (self.tipo == 'float'):
if (isinstance(value, int)):
value = float(value)
elif (isinstance(value, str)):
value = float(ord(value[0]))
else:
value = value
else:
if (isinstance(value, float)): value = int(value)
if (isinstance(value, int)):
if (value > 255): value = value - 256
value = chr(value)
elif (isinstance(value, str)):
value = value[0]
else:
value = value
primitivo = Primitivo(value, self.linea, self.columna)
asignacion = Asignacion(self.id, primitivo, self.linea, self.columna,
False)
asignacion.setAmbito(self.declarada)
asignacion.ejecutar(ent, arbol, ventana, isDebug)
return False
def concatenar(self,cadena, llave, valor):
pos = cadena.index("%")
pos2 = cadena.index(llave)
if (pos == -1 or pos2 == -1):
error = Error("SEMANTICO","Error semantico, La expresión es incorrecta para imprimir.",self.linea,self.columna)
ReporteErrores.func(error)
return None
if (pos == pos2):
cadena = cadena.replace(llave, valor,1)
else:
error = Error("SEMANTICO","Error semantico, La expresión es incorrecta para imprimir.",self.linea,self.columna)
ReporteErrores.func(error)
return None
return cadena
def ejecutar(self, ent, arbol, ventana, isDebug):
resultado = self.condicion.getValorImplicito(ent, arbol)
if (resultado == 0 or resultado == 0.0): resultado = False
if (resultado == 1 or resultado == 1.0): resultado = True
if (not isinstance(resultado, bool)):
error = Error(
"SEMANTICO",
"Error semantico, Se esperaba un valor 1 o 0 para validar el IF.",
self.linea, self.columna)
ReporteErrores.func(error)
if (bool(resultado)):
# try:
return self.instruccionV.ejecutar(ent, arbol, ventana, isDebug)
# except:
# return False
return False
def ejecutar(self,ent,arbol,ventana,isDebug):
simbolo = ent.obtener(str(self.id))
if(simbolo == None):
error = Error("SEMANTICO","Error semantico, El identificador "+str(self.id)+" no existe!!",self.linea,self.columna)
ReporteErrores.func(error)
else:
if(self.id == "$ra" or self.id == "$sp"):
error = Error("SEMANTICO","Error semantico, No es permitido eliminar la variable "+str(self.id)+" ya que es una variable del sistema!!",self.linea,self.columna)
ReporteErrores.func(error)
return None
if(len(simbolo.punteros)>0):
for var in simbolo.punteros:
simboloP = ent.obtener(str(var))
simboloP.valor = simbolo.valor
simboloP.puntero = ""
ent.reemplazar(simboloP)
ent.eliminar(str(self.id))
def ejecutar(self,ent,arbol,ventana,isDebug):
valor = self.cad.getValorImplicito(ent,arbol)
if(isinstance(valor,dict)):
error = Error("SEMANTICO","Error semantico, no es posible imprimir un Array!!",self.linea,self.columna)
ReporteErrores.func(error)
elif(valor == None):
return False
elif(str(valor) == "\n"):
print('> ', "")
ventana.consola.appendPlainText("")
else:
print('> ', valor)
cadenas = str(valor).split("\\n")
if(len(cadenas) == 1):
ventana.consola.insertPlainText(str(valor))
else:
contador = 1
for value in cadenas:
ventana.consola.insertPlainText(str(value))
if(contador < len(cadenas)):
ventana.consola.appendPlainText("")
contador = contador + 1
def traducir(self, ent, arbol, ventana):
if (ent.existe(self.id)):
error = Error(
"SEMANTICO",
"Error semantico, ya se encuentra definido un parametro con el nombre "
+ id, self.linea, self.columna)
ReporteErrores.func(error)
return None
else:
if (self.valor == None):
temporal = temp.parametro()
simbolo = Simbolo(self.id, temporal, self.tipo, self.linea,
self.columna)
ent.agregar(simbolo)
return temporal
else:
simbolo = Simbolo(self.id, self.temporal, self.tipo,
self.linea, self.columna)
ent.agregar(simbolo)
ref = ""
if (self.referencia): ref = "&"
asignacion = Asignacion(self.id, self.valor, self.linea,
self.columna, ref)
asignacion.traducir(ent, arbol, ventana)
def debugger(self):
self.tableWidget.setRowCount(0)
self.tableWidget.setRowCount(100)
self.tableWidget.setItem(0, 0, QTableWidgetItem("No."))
self.tableWidget.setItem(0, 1, QTableWidgetItem("Simbolo"))
self.tableWidget.setItem(0, 2, QTableWidgetItem("Valor"))
if (self.hilo_terminado):
sys.setrecursionlimit(2147483644)
self.consola.clear()
ReporteErrores.func(None, True)
g.func(0, None)
texto = analizar(self.editor.text())
self.gramatica = getGrammar()
self.simbolos = getSimbols()
g.textoEntrada = texto
instrucciones = g.parse(texto)
self.instrucciones = instrucciones
ts_global = TS.Entorno(None)
ast = AST.AST(instrucciones)
declaracion1 = Declaracion.Declaracion('$ra', 0, 0, 0, "",
"GLOBAL")
declaracion2 = Declaracion.Declaracion('$sp', 0, 0, 0, "",
"GLOBAL")
declaracion1.ejecutar(ts_global, ast, self, True)
declaracion2.ejecutar(ts_global, ast, self, True)
bandera = False
if (instrucciones != None):
for ins in instrucciones:
try:
if (bandera == False and ins.id != "main"):
error = Error.Error(
"SEMANTICO",
"Error semantico, La primera etiqueta debe ser la etiqueta main:",
ins.linea, ins.columna)
ReporteErrores.func(error)
break
else:
bandera = True
if (ast.existeEtiqueta(ins)):
error = Error.Error(
"SEMANTICO",
"Error semantico, Ya existe la etiqueta " +
ins.id, ins.linea, ins.columna)
ReporteErrores.func(error)
else:
ast.agregarEtiqueta(ins)
except:
pass
self.ts_global = ts_global
self.ast = ast
self.listado_gramatical = g.func(1, None).copy()
self.debug()
def asignarValorEnArray(self, ent, diccionario, valorAgregar, pos):
temporal = diccionario
if ((isinstance(temporal, int) or isinstance(temporal, float))
and pos > 1):
error = Error(
"SEMANTICO",
"Error semantico, Ya se encuentra ocupado el indice.",
self.linea, self.columna)
ReporteErrores.func(error)
return None
if (len(self.llaves) < pos): return None
llave = self.llaves[pos - 1]
valor = llave.getValorImplicito(ent, None)
if (valor == None): return None
if (isinstance(valor, float)): valor = int(valor)
if (len(self.llaves) == pos):
if (isinstance(temporal, dict)):
if (self.defArray):
temporal[valor] = {}
else:
temporal[valor] = valorAgregar
elif isinstance(temporal, str):
if (self.defArray):
error = Error(
"SEMANTICO",
"Error semantico, solo pueden inicializarse array dento de arrays",
self.linea, self.columna)
ReporteErrores.func(error)
return None
else:
if (isinstance(valor, int)):
if (valor <= (len(temporal) - 1)):
valorAgregar = str(valorAgregar)[0]
temporal = temporal[
0:valor] + valorAgregar + temporal[
valor + 1:len(temporal)]
else:
while (len(temporal) - 1) != valor - 1:
temporal = temporal + ' '
valorAgregar = str(valorAgregar)[0]
temporal = temporal + valorAgregar
return temporal
else:
error = Error(
"SEMANTICO",
"Error semantico, Llave no valida para asingar caracteres de una cadena",
self.linea, self.columna)
ReporteErrores.func(error)
return None
return temporal
else:
if (isinstance(temporal, dict)):
if valor not in temporal.keys():
temporal[valor] = {}
else:
error = Error(
"SEMANTICO",
"Error semantico, Asignación incorrecta a un valor que no es un Array",
self.linea, self.columna)
ReporteErrores.func(error)
return None
resultado = self.asignarValorEnArray(ent, temporal[valor],
valorAgregar, pos + 1)
if (resultado == None and isinstance(temporal[valor], dict)):
return diccionario
if (resultado == None and not isinstance(temporal[valor], dict)):
return None
diccionario[valor] = resultado
return diccionario
def ascendente(self):
sys.setrecursionlimit(2147483644)
self.consola.clear()
global codigoAug
ReporteErrores.func(None,True)
g.textoEntrada = codigoAug
g.func(0,None)
instrucciones = g.parse(codigoAug)
self.instrucciones = instrucciones
ts_global = TS.Entorno(None)
ts_global.asignarConsola(self.consola)
ast = AST.AST(instrucciones)
declaracion1 = Declaracion.Declaracion('$ra',0,0,0,"","GLOBAL")
declaracion2 = Declaracion.Declaracion('$sp',0,0,0,"","GLOBAL")
declaracion1.ejecutar(ts_global,ast,self,False)
declaracion2.ejecutar(ts_global,ast,self,False)
#PRIMERA PASADA PARA GUARDAR TODAS LAS ETIQUETAS
bandera = False
if(instrucciones != None):
for ins in instrucciones:
try:
if(bandera == False and ins.id != "main"):
error = Error.Error("SEMANTICO","Error semantico, La primera etiqueta debe ser la etiqueta main:",ins.linea,ins.columna)
ReporteErrores.func(error)
break
else:
bandera = True
if(ast.existeEtiqueta(ins)):
error = Error.Error("SEMANTICO","Error semantico, Ya existe la etiqueta "+ins.id,ins.linea,ins.columna)
ReporteErrores.func(error)
else:
ast.agregarEtiqueta(ins)
except:
pass
main = ast.obtenerEtiqueta("main")
if(main != None):
salir = False
for ins in main.instrucciones:
try:
if(isinstance(ins,Asignacion.Asignacion) or isinstance(ins,Conversion.Conversion)):
ins.setAmbito("main")
if(ins.ejecutar(ts_global,ast,self,False) == True):
salir = True
break
except:
pass
if(not salir):
siguiente = ast.obtenerSiguienteEtiqueta("main")
if(siguiente!=None):
siguiente.ejecutar(ts_global,ast,self,False)
else:
error = Error.Error("SEMANTICO","Error semantico, No puede iniciarse el programa ya que no existe la etiqueta main:",0,0)
ReporteErrores.func(error)
listado = ReporteErrores.func(None)
if(len(listado)>0):
QMessageBox.critical(self.centralwidget, "Errores en Ejecución", "Se obtuvieron errores en la ejecución del Código Ingresado, verifique reporte de Errores")
self.ts_global = ts_global
self.ast = ast
self.listado_gramatical = g.func(1,None).copy()
def generarRErrores(self):
reporteErrores = ReporteErrores.ReporteErrores()
reporteErrores.generarReporte()
def getValorImplicito(self, ent, arbol):
#PRIMITIVOS
if (self.tipo == TIPO_OPERACION.PRIMITIVO):
return self.valor.getValorImplicito(ent, arbol)
#ACCESOS LISTAS
elif (self.tipo == TIPO_OPERACION.ACCESO):
return self.operadorIzq.getValorImplicito(ent, arbol)
#IDENTIFICADORES
elif (self.tipo == TIPO_OPERACION.ID):
simbolo = ent.obtener(str(self.valor))
if (simbolo == None):
error = Error(
"SEMANTICO", "Error semantico, No es existe la variable " +
str(self.valor), self.linea, self.columna)
ReporteErrores.func(error)
return None
valorRetorno = simbolo.getValorImplicito(ent, arbol)
if (type(valorRetorno) is Operacion):
return valorRetorno.getValorImplicito(ent, arbol)
return valorRetorno
#SUMA
elif (self.tipo == TIPO_OPERACION.SUMA):
valor1 = self.operadorIzq.getValorImplicito(ent, arbol)
valor2 = self.operadorDer.getValorImplicito(ent, arbol)
#concatenación de strings
if (isinstance(valor1, str) and isinstance(valor2, str)):
return valor1 + valor2
if (isinstance(valor1, str)):
valor1 = self.obtenerValorNumerico(valor1)
if (isinstance(valor2, str)):
valor2 = self.obtenerValorNumerico(valor2)
#OPERACION DE ENTEROS
if isinstance(valor1, int) and isinstance(valor2, int):
return int(valor1) + int(valor2)
elif isinstance(valor1, int) and isinstance(
valor2, float): # ENTERO - FLOAT
return round(float(float(valor1) + float(valor2)), 2)
elif isinstance(valor1, float) and isinstance(
valor2, int): # FLOAT - ENTERO
return round(float(float(valor1) + float(valor2)), 2)
elif isinstance(valor1, float) and isinstance(
valor2, float): # FLOAT - FLOAT
return round(float(float(valor1) + float(valor2)), 2)
else:
#ERROR DE TIPOS DE DATOS PERMITIDOS PARA LA OPERACION
error = Error(
"SEMANTICO",
"Error semantico, Error en tipos de datos permitidos para una SUMA",
self.linea, self.columna)
ReporteErrores.func(error)
return None
#RESTA
elif (self.tipo == TIPO_OPERACION.RESTA):
valor1 = self.operadorIzq.getValorImplicito(ent, arbol)
valor2 = self.operadorDer.getValorImplicito(ent, arbol)
if (isinstance(valor1, str)):
valor1 = self.obtenerValorNumerico(valor1)
if (isinstance(valor2, str)):
valor2 = self.obtenerValorNumerico(valor2)
#OPERACION DE ENTEROS
if isinstance(valor1, int) and isinstance(valor2, int):
return int(valor1) - int(valor2)
elif isinstance(valor1, int) and isinstance(
valor2, float): # ENTERO - FLOAT
return round(float(float(valor1) - float(valor2)), 2)
elif isinstance(valor1, float) and isinstance(
valor2, int): # FLOAT - ENTERO
return round(float(float(valor1) - float(valor2)), 2)
elif isinstance(valor1, float) and isinstance(
valor2, float): # FLOAT - FLOAT
return round(float(float(valor1) - float(valor2)), 2)
else:
#ERROR DE TIPOS DE DATOS PERMITIDOS PARA LA OPERACION
error = Error(
"SEMANTICO",
"Error semantico, Error en tipos de datos permitidos para una RESTA",
self.linea, self.columna)
ReporteErrores.func(error)
return None
#MULTIPLICACIÓN
elif (self.tipo == TIPO_OPERACION.MULTIPLICACION):
valor1 = self.operadorIzq.getValorImplicito(ent, arbol)
valor2 = self.operadorDer.getValorImplicito(ent, arbol)
if (isinstance(valor1, str)):
valor1 = self.obtenerValorNumerico(valor1)
if (isinstance(valor2, str)):
valor2 = self.obtenerValorNumerico(valor2)
#OPERACION DE ENTEROS
if isinstance(valor1, int) and isinstance(valor2, int):
return int(valor1) * int(valor2)
elif isinstance(valor1, int) and isinstance(
valor2, float): # ENTERO - FLOAT
return round(float(float(valor1) * float(valor2)), 2)
elif isinstance(valor1, float) and isinstance(
valor2, int): # FLOAT - ENTERO
return round(float(float(valor1) * float(valor2)), 2)
elif isinstance(valor1, float) and isinstance(
valor2, float): # FLOAT - FLOAT
return round(float(float(valor1) * float(valor2)), 2)
else:
#ERROR DE TIPOS DE DATOS PERMITIDOS PARA LA OPERACION
error = Error(
"SEMANTICO",
"Error semantico, Error en tipos de datos permitidos para una MULTIPLICACION",
self.linea, self.columna)
ReporteErrores.func(error)
return None
#DIVISION
elif (self.tipo == TIPO_OPERACION.DIVISION):
valor1 = self.operadorIzq.getValorImplicito(ent, arbol)
valor2 = self.operadorDer.getValorImplicito(ent, arbol)
if (isinstance(valor1, str)):
valor1 = self.obtenerValorNumerico(valor1)
if (isinstance(valor2, str)):
valor2 = self.obtenerValorNumerico(valor2)
if (isinstance(valor2, int) or isinstance(valor2, float)):
temp = int(valor2)
if (temp == 0):
error = Error(
"SEMANTICO",
"Error semantico, No es posible una división sobre CERO!",
self.linea, self.columna)
ReporteErrores.func(error)
return None
#OPERACION DE ENTEROS
if isinstance(valor1, int) and isinstance(valor2, int):
return int(valor1) / int(valor2)
elif isinstance(valor1, int) and isinstance(
valor2, float): # ENTERO - FLOAT
return round(float(float(valor1) / float(valor2)), 2)
elif isinstance(valor1, float) and isinstance(
valor2, int): # FLOAT - ENTERO
return round(float(float(valor1) / float(valor2)), 2)
elif isinstance(valor1, float) and isinstance(
valor2, float): # FLOAT - FLOAT
return round(float(float(valor1) / float(valor2)), 2)
else:
#ERROR DE TIPOS DE DATOS PERMITIDOS PARA LA OPERACION
error = Error(
"SEMANTICO",
"Error semantico, Error en tipos de datos permitidos para una DIVISION",
self.linea, self.columna)
ReporteErrores.func(error)
return None
#MODULO
elif (self.tipo == TIPO_OPERACION.MODULO):
valor1 = self.operadorIzq.getValorImplicito(ent, arbol)
valor2 = self.operadorDer.getValorImplicito(ent, arbol)
if (isinstance(valor1, str)):
valor1 = self.obtenerValorNumerico(valor1)
if (isinstance(valor2, str)):
valor2 = self.obtenerValorNumerico(valor2)
if (isinstance(valor2, int) or isinstance(valor2, float)):
temp = int(valor2)
if (temp == 0):
error = Error(
"SEMANTICO",
"Error semantico, No es posible una modulo sobre CERO!",
self.linea, self.columna)
ReporteErrores.func(error)
return None
#OPERACION DE ENTEROS
if isinstance(valor1, int) and isinstance(valor2, int):
return int(valor1) % int(valor2)
elif isinstance(valor1, int) and isinstance(
valor2, float): # ENTERO - FLOAT
return round(float(float(valor1) % float(valor2)), 2)
elif isinstance(valor1, float) and isinstance(
valor2, int): # FLOAT - ENTERO
return round(float(float(valor1) % float(valor2)), 2)
elif isinstance(valor1, float) and isinstance(
valor2, float): # FLOAT - FLOAT
return round(float(float(valor1) % float(valor2)), 2)
else:
#ERROR DE TIPOS DE DATOS PERMITIDOS PARA LA OPERACION
error = Error(
"SEMANTICO",
"Error semantico, Error en tipos de datos permitidos para una MODULO",
self.linea, self.columna)
ReporteErrores.func(error)
return None
#UNARIA
elif (self.tipo == TIPO_OPERACION.MENOS_UNARIO):
valor1 = self.operadorIzq.getValorImplicito(ent, arbol)
if (isinstance(valor1, str)):
valor1 = self.obtenerValorNumerico(valor1)
#OPERACION DE ENTEROS
if isinstance(valor1, int):
return int(valor1) * -1
elif isinstance(valor1, float): # FLOAT
return round(float(float(valor1) * -1), 2)
else:
#ERROR DE TIPOS DE DATOS PERMITIDOS PARA LA OPERACION
error = Error(
"SEMANTICO",
"Error semantico, Error en tipo de dato permitido para un UNARIO",
self.linea, self.columna)
ReporteErrores.func(error)
return None
#ABSOLUTO
elif (self.tipo == TIPO_OPERACION.ABSOLUTO):
valor1 = self.operadorIzq.getValorImplicito(ent, arbol)
if (isinstance(valor1, str)):
valor1 = self.obtenerValorNumerico(valor1)
#OPERACION DE ENTEROS
if isinstance(valor1, int):
return abs(int(valor1))
elif isinstance(valor1, float): # FLOAT
return round(abs(float(float(valor1))), 2)
else:
#ERROR DE TIPOS DE DATOS PERMITIDOS PARA LA OPERACION
error = Error(
"SEMANTICO",
"Error semantico, Error en tipo de dato permitido para un VALOR ABSOLUTO",
self.linea, self.columna)
ReporteErrores.func(error)
return None
#MAYOR
elif (self.tipo == TIPO_OPERACION.MAYOR_QUE):
valor1 = self.operadorIzq.getValorImplicito(ent, arbol)
valor2 = self.operadorDer.getValorImplicito(ent, arbol)
#OPERACION DE ENTEROS
if isinstance(valor1, int) and isinstance(valor2, int):
return int(int(valor1) > int(valor2))
elif isinstance(valor1, int) and isinstance(
valor2, float): # ENTERO - FLOAT
return int(float(valor1) > float(valor2))
elif isinstance(valor1, float) and isinstance(
valor2, int): # FLOAT - ENTERO
return int(float(valor1) > float(valor2))
elif isinstance(valor1, float) and isinstance(
valor2, float): # FLOAT - FLOAT
return int(float(valor1) > float(valor2))
elif isinstance(valor1, str) or isinstance(
valor2, str): # CONCATENACIÓN STRINGS
if valor1 == None: valor1 = ""
if valor2 == None: valor2 = ""
if isinstance(valor1, str) and not isinstance(valor2, str):
return int(len(str(valor1)) > valor2)
elif isinstance(valor2, str) and not isinstance(valor1, str):
return int(valor1 > len(str(valor2)))
return int(len(str(valor1)) > len(str(valor2)))
else:
#ERROR DE TIPOS DE DATOS PERMITIDOS PARA LA OPERACION
error = Error(
"SEMANTICO",
"Error semantico, Error en tipos de datos permitidos para una expresion relacional '>' ",
self.linea, self.columna)
ReporteErrores.func(error)
return None
#MAYOR IGUAL
elif (self.tipo == TIPO_OPERACION.MAYOR_IGUA_QUE):
valor1 = self.operadorIzq.getValorImplicito(ent, arbol)
valor2 = self.operadorDer.getValorImplicito(ent, arbol)
#OPERACION DE ENTEROS
if isinstance(valor1, int) and isinstance(valor2, int):
return int(int(valor1) >= int(valor2))
elif isinstance(valor1, int) and isinstance(
valor2, float): # ENTERO - FLOAT
return int(float(valor1) >= float(valor2))
elif isinstance(valor1, float) and isinstance(
valor2, int): # FLOAT - ENTERO
return int(float(valor1) >= float(valor2))
elif isinstance(valor1, float) and isinstance(
valor2, float): # FLOAT - FLOAT
return int(float(valor1) >= float(valor2))
elif isinstance(valor1, str) or isinstance(
valor2, str): # CONCATENACIÓN STRINGS
if valor1 == None: valor1 = ""
if valor2 == None: valor2 = ""
if isinstance(valor1, str) and not isinstance(valor2, str):
return int(len(str(valor1)) >= valor2)
elif isinstance(valor2, str) and not isinstance(valor1, str):
return int(valor1 >= len(str(valor2)))
return int(len(str(valor1)) >= len(str(valor2)))
else:
#ERROR DE TIPOS DE DATOS PERMITIDOS PARA LA OPERACION
error = Error(
"SEMANTICO",
"Error semantico, Error en tipos de datos permitidos para una expresion relacional '>=' ",
self.linea, self.columna)
ReporteErrores.func(error)
return None
#MENOR
elif (self.tipo == TIPO_OPERACION.MENOR_QUE):
valor1 = self.operadorIzq.getValorImplicito(ent, arbol)
valor2 = self.operadorDer.getValorImplicito(ent, arbol)
#OPERACION DE ENTEROS
if isinstance(valor1, int) and isinstance(valor2, int):
return int(int(valor1) < int(valor2))
elif isinstance(valor1, int) and isinstance(
valor2, float): # ENTERO - FLOAT
return int((float(valor1) < float(valor2)))
elif isinstance(valor1, float) and isinstance(
valor2, int): # FLOAT - ENTERO
return int((float(valor1) < float(valor2)))
elif isinstance(valor1, float) and isinstance(
valor2, float): # FLOAT - FLOAT
return int((float(valor1) < float(valor2)))
elif isinstance(valor1, str) or isinstance(
valor2, str): # CONCATENACIÓN STRINGS
if valor1 == None: valor1 = ""
if valor2 == None: valor2 = ""
if isinstance(valor1, str) and not isinstance(valor2, str):
return int(len(str(valor1)) < valor2)
elif isinstance(valor2, str) and not isinstance(valor1, str):
return int(valor1 < len(str(valor2)))
return int(len(str(valor1)) < len(str(valor2)))
else:
#ERROR DE TIPOS DE DATOS PERMITIDOS PARA LA OPERACION
error = Error(
"SEMANTICO",
"Error semantico, Error en tipos de datos permitidos para una expresion relacional '<' ",
self.linea, self.columna)
ReporteErrores.func(error)
return None
#MENOR IGUAL
elif (self.tipo == TIPO_OPERACION.MENOR_IGUA_QUE):
valor1 = self.operadorIzq.getValorImplicito(ent, arbol)
valor2 = self.operadorDer.getValorImplicito(ent, arbol)
#OPERACION DE ENTEROS
if isinstance(valor1, int) and isinstance(valor2, int):
return int(int(valor1) <= int(valor2))
elif isinstance(valor1, int) and isinstance(
valor2, float): # ENTERO - FLOAT
return int((float(valor1) <= float(valor2)))
elif isinstance(valor1, float) and isinstance(
valor2, int): # FLOAT - ENTERO
return int((float(valor1) <= float(valor2)))
elif isinstance(valor1, float) and isinstance(
valor2, float): # FLOAT - FLOAT
return int((float(valor1) <= float(valor2)))
elif isinstance(valor1, str) or isinstance(
valor2, str): # CONCATENACIÓN STRINGS
if valor1 == None: valor1 = ""
if valor2 == None: valor2 = ""
if isinstance(valor1, str) and not isinstance(valor2, str):
return int(len(str(valor1)) <= valor2)
elif isinstance(valor2, str) and not isinstance(valor1, str):
return int(valor1 <= len(str(valor2)))
return int(len(str(valor1)) <= len(str(valor2)))
else:
#ERROR DE TIPOS DE DATOS PERMITIDOS PARA LA OPERACION
error = Error(
"SEMANTICO",
"Error semantico, Error en tipos de datos permitidos para una expresion relacional '<=' ",
self.linea, self.columna)
ReporteErrores.func(error)
return None
#IGUAL
elif (self.tipo == TIPO_OPERACION.IGUAL_IGUAL):
valor1 = self.operadorIzq.getValorImplicito(ent, arbol)
valor2 = self.operadorDer.getValorImplicito(ent, arbol)
#OPERACION DE ENTEROS
if isinstance(valor1, int) and isinstance(valor2, int):
return int(int(valor1) == int(valor2))
elif isinstance(valor1, int) and isinstance(
valor2, float): # ENTERO - FLOAT
return int((float(valor1) == float(valor2)))
elif isinstance(valor1, float) and isinstance(
valor2, int): # FLOAT - ENTERO
return int((float(valor1) == float(valor2)))
elif isinstance(valor1, float) and isinstance(
valor2, float): # FLOAT - FLOAT
return int((float(valor1) == float(valor2)))
elif isinstance(valor1, str) or isinstance(
valor2, str): # CONCATENACIÓN STRINGS
if valor1 == None: valor1 = ""
if valor2 == None: valor2 = ""
return int(str(valor1) == str(valor2))
else:
#ERROR DE TIPOS DE DATOS PERMITIDOS PARA LA OPERACION
error = Error(
"SEMANTICO",
"Error semantico, Error en tipos de datos permitidos para una expresion relacional '==' ",
self.linea, self.columna)
ReporteErrores.func(error)
return None
#DIFERENTE
elif (self.tipo == TIPO_OPERACION.DIFERENTE_QUE):
valor1 = self.operadorIzq.getValorImplicito(ent, arbol)
valor2 = self.operadorDer.getValorImplicito(ent, arbol)
#OPERACION DE ENTEROS
if isinstance(valor1, int) and isinstance(valor2, int):
return int(int(valor1) != int(valor2))
elif isinstance(valor1, int) and isinstance(
valor2, float): # ENTERO - FLOAT
return int((float(valor1) != float(valor2)))
elif isinstance(valor1, float) and isinstance(
valor2, int): # FLOAT - ENTERO
return int((float(valor1) != float(valor2)))
elif isinstance(valor1, float) and isinstance(
valor2, float): # FLOAT - FLOAT
return int((float(valor1) != float(valor2)))
elif isinstance(valor1, str) or isinstance(
valor2, str): # CONCATENACIÓN STRINGS
if valor1 == None: valor1 = ""
if valor2 == None: valor2 = ""
return int(str(valor1) != str(valor2))
else:
#ERROR DE TIPOS DE DATOS PERMITIDOS PARA LA OPERACION
error = Error(
"SEMANTICO",
"Error semantico, Error en tipos de datos permitidos para una expresion relacional '!=' ",
self.linea, self.columna)
ReporteErrores.func(error)
return None
#AND
elif (self.tipo == TIPO_OPERACION.AND):
valor1 = self.operadorIzq.getValorImplicito(ent, arbol)
if (valor1 == 0 or valor1 == 0.0): valor1 = False
if (valor1 == 1 or valor1 == 1.0): valor1 = True
valor2 = self.operadorDer.getValorImplicito(ent, arbol)
if (valor2 == 0 or valor2 == 0.0): valor2 = False
if (valor2 == 1 or valor2 == 1.0): valor2 = True
if isinstance(valor1, bool) and isinstance(valor2, bool):
return int(bool(valor1) and bool(valor2))
else:
#ERROR DE TIPOS DE DATOS PERMITIDOS PARA LA OPERACION
error = Error(
"SEMANTICO",
"Error semantico, Error en tipos de datos permitidos para una expresion logica AND ",
self.linea, self.columna)
ReporteErrores.func(error)
return None
#OR
elif (self.tipo == TIPO_OPERACION.OR):
valor1 = self.operadorIzq.getValorImplicito(ent, arbol)
if (valor1 == 0 or valor1 == 0.0): valor1 = False
if (valor1 == 1 or valor1 == 1.0): valor1 = True
valor2 = self.operadorDer.getValorImplicito(ent, arbol)
if (valor2 == 0 or valor2 == 0.0): valor2 = False
if (valor2 == 1 or valor2 == 1.0): valor2 = True
if isinstance(valor1, bool) and isinstance(valor2, bool):
return int(bool(valor1) or bool(valor2))
else:
#ERROR DE TIPOS DE DATOS PERMITIDOS PARA LA OPERACION
error = Error(
"SEMANTICO",
"Error semantico, Error en tipos de datos permitidos para una expresion logica OR ",
self.linea, self.columna)
ReporteErrores.func(error)
return None
#XOR
elif (self.tipo == TIPO_OPERACION.XOR):
valor1 = self.operadorIzq.getValorImplicito(ent, arbol)
if (valor1 == 0 or valor1 == 0.0): valor1 = False
if (valor1 == 1 or valor1 == 1.0): valor1 = True
valor2 = self.operadorDer.getValorImplicito(ent, arbol)
if (valor2 == 0 or valor2 == 0.0): valor2 = False
if (valor2 == 1 or valor2 == 1.0): valor2 = True
if isinstance(valor1, bool) and isinstance(valor2, bool):
return int(bool(valor1) ^ bool(valor2))
else:
#ERROR DE TIPOS DE DATOS PERMITIDOS PARA LA OPERACION
error = Error(
"SEMANTICO",
"Error semantico, Error en tipos de datos permitidos para una expresion logica XOR ",
self.linea, self.columna)
ReporteErrores.func(error)
return None
#NOT
elif (self.tipo == TIPO_OPERACION.NOT):
valor1 = self.operadorIzq.getValorImplicito(ent, arbol)
if (valor1 == 0 or valor1 == 0.0): valor1 = False
if (valor1 == 1 or valor1 == 1.0): valor1 = True
if isinstance(valor1, bool):
return int(not bool(valor1))
else:
#ERROR DE TIPOS DE DATOS PERMITIDOS PARA LA OPERACION
error = Error(
"SEMANTICO",
"Error semantico, Error en tipo de dato permitido para una expresion logica NOT ",
self.linea, self.columna)
ReporteErrores.func(error)
return
#PAND
elif (self.tipo == TIPO_OPERACION.PAND):
valor1 = self.operadorIzq.getValorImplicito(ent, arbol)
valor2 = self.operadorDer.getValorImplicito(ent, arbol)
if (isinstance(valor1, str)):
valor1 = self.obtenerValorNumerico(valor1)
if (isinstance(valor2, str)):
valor2 = self.obtenerValorNumerico(valor2)
valor1 = int(valor1)
valor2 = int(valor2)
return valor1 & valor2
#BOR
elif (self.tipo == TIPO_OPERACION.BOR):
valor1 = self.operadorIzq.getValorImplicito(ent, arbol)
valor2 = self.operadorDer.getValorImplicito(ent, arbol)
if (isinstance(valor1, str)):
valor1 = self.obtenerValorNumerico(valor1)
if (isinstance(valor2, str)):
valor2 = self.obtenerValorNumerico(valor2)
valor1 = int(valor1)
valor2 = int(valor2)
return valor1 | valor2
#XORR
elif (self.tipo == TIPO_OPERACION.XORR):
valor1 = self.operadorIzq.getValorImplicito(ent, arbol)
valor2 = self.operadorDer.getValorImplicito(ent, arbol)
if (isinstance(valor1, str)):
valor1 = self.obtenerValorNumerico(valor1)
if (isinstance(valor2, str)):
valor2 = self.obtenerValorNumerico(valor2)
valor1 = int(valor1)
valor2 = int(valor2)
return valor1 ^ valor2
#SHIFI
elif (self.tipo == TIPO_OPERACION.SHIFTI):
valor1 = self.operadorIzq.getValorImplicito(ent, arbol)
valor2 = self.operadorDer.getValorImplicito(ent, arbol)
if (isinstance(valor1, str)):
valor1 = self.obtenerValorNumerico(valor1)
if (isinstance(valor2, str)):
valor2 = self.obtenerValorNumerico(valor2)
valor1 = int(valor1)
valor2 = int(valor2)
return valor1 << valor2
#SHIFD
elif (self.tipo == TIPO_OPERACION.SHIFTD):
valor1 = self.operadorIzq.getValorImplicito(ent, arbol)
valor2 = self.operadorDer.getValorImplicito(ent, arbol)
if (isinstance(valor1, str)):
valor1 = self.obtenerValorNumerico(valor1)
if (isinstance(valor2, str)):
valor2 = self.obtenerValorNumerico(valor2)
valor1 = int(valor1)
valor2 = int(valor2)
return valor1 >> valor2
#NOTR
elif (self.tipo == TIPO_OPERACION.NOTR):
valor1 = self.operadorIzq.getValorImplicito(ent, arbol)
if (isinstance(valor1, str)):
valor1 = self.obtenerValorNumerico(valor1)
valor1 = int(valor1)
return ~valor1
def traducir(self, ent, arbol, ventana, recursivo=0):
#PRIMITIVOS
if (self.tipo == TIPO_OPERACION.PRIMITIVO):
return self.valor.traducir(ent, arbol)
#ACCESOS LISTAS
elif (self.tipo == TIPO_OPERACION.ACCESO):
valor = self.operadorIzq.traducir(ent, arbol, ventana)
if (valor == None): return None
return valor
elif (self.tipo == TIPO_OPERACION.ACCESO_STRUCT):
valor = self.operadorIzq.traducir(ent, arbol, ventana)
if (valor == None): return None
valor.codigo3D = valor.temporal.utilizar(
) + "=" + valor.codigo3D + ";"
return valor
elif (self.tipo == TIPO_OPERACION.LLAMADA):
#etiquetaSalida = Temp.etiqueta()
#Temp.listaReturn(0,etiquetaSalida)
self.operadorIzq.traducir(ent, arbol, ventana)
#ventana.editor.append("\n"+etiquetaSalida+":")
result = Resultado3D()
result.codigo3D = ""
result.temporal = Temp.Temporal("$v0")
result.tipo = Tipo.FLOAT
return result
#IDENTIFICADORES
elif (self.tipo == TIPO_OPERACION.ID):
simbolo = ent.obtener(str(self.valor))
if (simbolo == None):
error = Error(
"SEMANTICO", "Error semantico, No es existe la variable " +
str(self.valor), self.linea, self.columna)
ReporteErrores.func(error)
return None
return simbolo.traducir(ent, arbol)
#SUMA
elif (self.tipo == TIPO_OPERACION.SUMA):
return self.generarOperacionBinaria("+", ent, arbol, ventana,
recursivo)
#RESTA
elif (self.tipo == TIPO_OPERACION.RESTA):
return self.generarOperacionBinaria("-", ent, arbol, ventana,
recursivo)
#MULTIPLICACIÓN
elif (self.tipo == TIPO_OPERACION.MULTIPLICACION):
return self.generarOperacionBinaria("*", ent, arbol, ventana,
recursivo)
#DIVISION
elif (self.tipo == TIPO_OPERACION.DIVISION):
return self.generarOperacionBinaria("/", ent, arbol, ventana,
recursivo)
#MODULO
elif (self.tipo == TIPO_OPERACION.MODULO):
return self.generarOperacionBinaria("%", ent, arbol, ventana,
recursivo)
#UNARIA
elif (self.tipo == TIPO_OPERACION.MENOS_UNARIO):
valor1 = self.operadorIzq.traducir(ent, arbol, ventana,
recursivo + 1)
if (valor1 == None): return None
temporal = Temp.nuevoTemporal()
op = temporal.obtener() + '=-' + valor1.temporal.utilizar() + ";"
resultado = valor1.codigo3D
if (resultado != ""):
resultado = resultado + "\n" + op
else:
resultado += op
result = Resultado3D()
result.codigo3D = resultado
result.temporal = temporal
result.tipo = Tipo.FLOAT
return result
#MAYOR
elif (self.tipo == TIPO_OPERACION.MAYOR_QUE):
return self.generarOperacionBinaria(">", ent, arbol, ventana,
recursivo)
#MAYOR IGUAL
elif (self.tipo == TIPO_OPERACION.MAYOR_IGUA_QUE):
return self.generarOperacionBinaria(">=", ent, arbol, ventana,
recursivo)
#MENOR
elif (self.tipo == TIPO_OPERACION.MENOR_QUE):
return self.generarOperacionBinaria("<", ent, arbol, ventana,
recursivo)
#MENOR IGUAL
elif (self.tipo == TIPO_OPERACION.MENOR_IGUA_QUE):
return self.generarOperacionBinaria("<=", ent, arbol, ventana,
recursivo)
#IGUAL
elif (self.tipo == TIPO_OPERACION.IGUAL_IGUAL):
return self.generarOperacionBinaria("==", ent, arbol, ventana,
recursivo)
#DIFERENTE
elif (self.tipo == TIPO_OPERACION.DIFERENTE_QUE):
return self.generarOperacionBinaria("!=", ent, arbol, ventana,
recursivo)
#AND
elif (self.tipo == TIPO_OPERACION.AND):
return self.generarOperacionBinaria("&&", ent, arbol, ventana,
recursivo)
#OR
elif (self.tipo == TIPO_OPERACION.OR):
return self.generarOperacionBinaria("||", ent, arbol, ventana,
recursivo)
#XOR
elif (self.tipo == TIPO_OPERACION.XOR):
return self.generarOperacionBinaria("xor", ent, arbol, ventana,
recursivo)
#NOT
elif (self.tipo == TIPO_OPERACION.NOT):
valor1 = self.operadorIzq.traducir(ent, arbol, ventana,
recursivo + 1)
if (valor1 == None): return None
temporal = Temp.nuevoTemporal()
op = temporal.obtener() + '=!' + valor1.temporal.utilizar() + ";"
resultado = valor1.codigo3D
if (resultado != ""):
resultado = resultado + "\n" + op
else:
resultado += op
result = Resultado3D()
result.codigo3D = resultado
result.temporal = temporal
result.tipo = Tipo.FLOAT
return result
#PAND
elif (self.tipo == TIPO_OPERACION.PAND):
return self.generarOperacionBinaria("&", ent, arbol, ventana,
recursivo)
#BOR
elif (self.tipo == TIPO_OPERACION.BOR):
return self.generarOperacionBinaria("|", ent, arbol, ventana,
recursivo)
#XORR
elif (self.tipo == TIPO_OPERACION.XORR):
return self.generarOperacionBinaria("^", ent, arbol, ventana,
recursivo)
#SHIFI
elif (self.tipo == TIPO_OPERACION.SHIFTI):
return self.generarOperacionBinaria("<<", ent, arbol, ventana,
recursivo)
#SHIFD
elif (self.tipo == TIPO_OPERACION.SHIFTD):
return self.generarOperacionBinaria(">>", ent, arbol, ventana,
recursivo)
#NOTR
elif (self.tipo == TIPO_OPERACION.NOTR):
valor1 = self.operadorIzq.traducir(ent, arbol, ventana,
recursivo + 1)
if (valor1 == None): return None
temporal = Temp.nuevoTemporal()
op = temporal.obtener() + '=~' + valor1.temporal.utilizar() + ";"
resultado = valor1.codigo3D
if (resultado != ""):
resultado = resultado + "\n" + op
else:
resultado += op
result = Resultado3D()
result.codigo3D = resultado
result.temporal = temporal
result.tipo = Tipo.FLOAT
return result
def traducir(self, ent, arbol, ventana):
accesoLista = None
if (isinstance(self.id, AccesoLista)):
accesoLista = self.id
self.id = self.id.id
simbolo = ent.obtener(str(self.id))
if (simbolo == None):
error = Error(
"SEMANTICO",
"Error semantico, No es existe la variable " + str(self.id),
self.linea, self.columna)
ReporteErrores.func(error)
return None
if (simbolo.tipo == Tipo.DOOBLE or simbolo.tipo == Tipo.ENTERO
or simbolo.tipo == Tipo.FLOAT or simbolo.tipo == Tipo.CHAR):
error = Error(
"SEMANTICO", "Error semantico, La variable " + str(self.id) +
" no es un Struct.", self.linea, self.columna)
ReporteErrores.func(error)
return None
struct = arbol.obtenerStruct(simbolo.tipo)
if (struct == None):
error = Error(
"SEMANTICO", "Error semantico, El struct " +
str(simbolo.tipo) + " no se encuentra definido.", self.linea,
self.columna)
ReporteErrores.func(error)
return None
bandera = False
for declaracion in struct.declaraciones:
#if(simbolo.tipo == Tipo.DOOBLE or simbolo.tipo == Tipo.ENTERO or simbolo.tipo == Tipo.FLOAT or simbolo.tipo == Tipo.CHAR): #primitivos basicos
for x in declaracion.lista:
if (isinstance(x, AccesoLista)):
x = x.id
key = self.llave
if (isinstance(key, AccesoLista)): key = key.id
if (x == key):
bandera = True
break
if (not bandera):
error = Error(
"SEMANTICO",
"Error semantico, El struct " + str(simbolo.tipo) +
" no tiene definido el atributo " + self.llave, self.linea,
self.columna)
ReporteErrores.func(error)
return None
temporal = temp.nuevoTemporal()
temporalSimbolo = simbolo.temporal
if (accesoLista != None):
traduccionAccesoLista = accesoLista.traducir(ent, arbol, ventana)
temporalSimbolo = traduccionAccesoLista.temporal.utilizar()
if isinstance(self.llave, AccesoLista):
resultado3D = Resultado3D()
strAccesos = ""
for llave in self.llave.llaves:
expresion = llave.traducir(ent, arbol, ventana)
if (expresion == None): return None
if (expresion.codigo3D != ""):
ventana.editor.append("\n" + expresion.codigo3D)
strAccesos += "[" + expresion.temporal.utilizar() + "]"
resultado3D.codigo3D = temporalSimbolo + "[\"" + self.llave.id + "\"]" + strAccesos
resultado3D.tipo = simbolo.tipo
resultado3D.temporal = temporal
return resultado3D
else:
resultado3D = Resultado3D()
resultado3D.codigo3D = temporalSimbolo + "[\"" + self.llave + "\"]"
resultado3D.tipo = simbolo.tipo
resultado3D.temporal = temporal
return resultado3D
def traducir(self, ent, arbol, ventana):
#acceso a struct
if (isinstance(self.id, AccesoStruct)
or isinstance(self.id, AccesoLista)):
traduccionExpresion = self.valor.traducir(ent, arbol, ventana)
if (traduccionExpresion == None): return None
acceso = self.id.traducir(ent, arbol, ventana)
if (acceso == None): return None
if (traduccionExpresion.codigo3D != ""):
ventana.editor.append("\n" + traduccionExpresion.codigo3D)
if (isinstance(self.id, AccesoStruct)):
ventana.editor.append("\n" + acceso.codigo3D + "=" +
self.tipo +
traduccionExpresion.temporal.utilizar() +
"; ")
else:
ventana.editor.append("\n" + acceso.temporal.utilizar() + "=" +
self.tipo +
traduccionExpresion.temporal.utilizar() +
"; ")
return None
simbolo = ent.obtener(str(self.id))
if (simbolo == None):
error = Error(
"SEMANTICO",
"Error semantico, no se encuentra declarado un identificador con el nombre "
+ self.id, self.linea, self.columna)
ReporteErrores.func(error)
return None
if (simbolo.llaves != None): #array
if (isinstance(self.valor, list)):
self.operacionesArray(ent, arbol, ventana, self.valor,
simbolo.temporal, "")
else:
traduccionExpresion = self.valor.traducir(ent, arbol, ventana)
if (traduccionExpresion == None): return None
if (simbolo.tipo == Tipo.CHAR
and traduccionExpresion.tipo == Tipo.CHAR):
if (traduccionExpresion.codigo3D != ""):
ventana.editor.append("\n" +
traduccionExpresion.codigo3D)
traduccion = simbolo.temporal + "=" + self.tipo + traduccionExpresion.temporal.utilizar(
) + "; "
ventana.editor.append("\n" + traduccion)
else:
error = Error(
"SEMANTICO",
"Error semantico, expresión incorrecta al asignar el Arrray "
+ self.id, self.linea, self.columna)
ReporteErrores.func(error)
return None
else:
if (isinstance(self.valor, list)):
error = Error(
"SEMANTICO",
"Error semantico, expresión incorrecta para asignar el identificador "
+ self.id, self.linea, self.columna)
ReporteErrores.func(error)
return None
traduccionExpresion = self.valor.traducir(ent, arbol, ventana)
if (traduccionExpresion == None): return None
if (traduccionExpresion.codigo3D != ""):
ventana.editor.append("\n" + traduccionExpresion.codigo3D)
traduccion = simbolo.temporal + "=" + self.tipo + traduccionExpresion.temporal.utilizar(
) + "; "
try:
ventana.editor.append("\n" + traduccion)
except:
pass
def ejecutar(self, ent, arbol, ventana, isDebug):
simbolo = ent.obtener(str(self.id))
if (simbolo == None):
error = Error(
"SEMANTICO",
"Error semantico, No existe la variable con identificador " +
self.id, self.linea, self.columna)
ReporteErrores.func(error)
return False
valorIdentificador = simbolo.valor
valorAgregar = None
if not self.defArray:
valorAgregar = self.asignacion.getValorImplicito(ent, arbol)
if (valorAgregar == None and not self.defArray): return False
for llave in self.llaves:
valor = llave.getValorImplicito(ent, arbol)
if (valor == None): return False
if (isinstance(valor, float)): valor = int(valor)
if (not isinstance(valorIdentificador, dict) and self.defArray):
error = Error(
"SEMANTICO",
"Error semantico, Solo pueden inicializarse array dento de arrays",
self.linea, self.columna)
ReporteErrores.func(error)
return False
if (isinstance(valorIdentificador, str)): #cadenas
if len(self.llaves) > 1:
error = Error(
"SEMANTICO",
"Error semantico, No puede usarse acceso [..][..]... para asignación de Cadenas",
self.linea, self.columna)
ReporteErrores.func(error)
return False
if (isinstance(valorAgregar, float)):
valorAgregar = int(valorAgregar)
if (isinstance(valorAgregar, dict)):
error = Error(
"SEMANTICO",
"Error semantico, Valor no valido para asignar caracteres de una cadena",
self.linea, self.columna)
ReporteErrores.func(error)
return False
if (isinstance(valor, int)):
if (valor <= (len(valorIdentificador) - 1)):
valorAgregar = str(valorAgregar)[0]
valorIdentificador = valorIdentificador[
0:valor] + valorAgregar + valorIdentificador[
valor + 1:len(valorIdentificador)]
else:
while (len(valorIdentificador) - 1) != valor - 1:
valorIdentificador = valorIdentificador + ' '
valorAgregar = str(valorAgregar)[0]
valorIdentificador = valorIdentificador + valorAgregar
asignar = Asignacion(self.id,
Primitivo(valorIdentificador, 0, 0),
self.linea, self.columna, False)
asignar.ejecutar(ent, arbol, ventana, isDebug)
else:
error = Error(
"SEMANTICO",
"Error semantico, Llave no valida para asingar caracteres de una cadena",
self.linea, self.columna)
ReporteErrores.func(error)
return False
elif (isinstance(valorIdentificador, dict)): #diccionarios
valorFinal = self.asignarValorEnArray(ent, valorIdentificador,
valorAgregar, 1)
if (valorFinal == None): return False
asignar = Asignacion(self.id,
Primitivo(valorIdentificador, 0, 0),
self.linea, self.columna, False)
asignar.ejecutar(ent, arbol, ventana, isDebug)
else:
error = Error(
"SEMANTICO",
"Error semantico, el valor del acceso no es de tipo CADENA O ARRAY",
self.linea, self.columna)
ReporteErrores.func(error)
return False
def getValorImplicito(self, ent, arbol):
simbolo = ent.obtener(str(self.id))
if (simbolo == None):
error = Error(
"SEMANTICO",
"Error semantico, No existe la variable con identificador " +
self.id, self.linea, self.columna)
ReporteErrores.func(error)
return None
valorIdentificador = simbolo.valor
for llave in self.llaves:
valor = llave.getValorImplicito(ent, arbol)
if (isinstance(valor, float)): valor = int(valor)
if (isinstance(valorIdentificador, str)): #cadenas
if (isinstance(valor, int)):
if (valor >= len(valorIdentificador)):
error = Error(
"SEMANTICO",
"Error semantico, El indice excede el tamaño de la cadena",
self.linea, self.columna)
ReporteErrores.func(error)
return None
valorIdentificador = valorIdentificador[valor]
else:
error = Error(
"SEMANTICO",
"Error semantico, Llave no valida para obtener caracteres de una cadena",
self.linea, self.columna)
ReporteErrores.func(error)
return None
elif (isinstance(valorIdentificador, dict)): #diccionarios
if (isinstance(valor, dict)):
error = Error(
"SEMANTICO",
"Error semantico, Llave no valida para obtener valor del Array",
self.linea, self.columna)
ReporteErrores.func(error)
return None
if valor not in valorIdentificador.keys():
error = Error(
"SEMANTICO", "Error semantico, Llave " + str(valor) +
" no existente en el Array", self.linea, self.columna)
ReporteErrores.func(error)
return None
else:
valorIdentificador = valorIdentificador[valor]
else:
error = Error(
"SEMANTICO",
"Error semantico, el valor del acceso no es de tipo CADENA O ARRAY",
self.linea, self.columna)
ReporteErrores.func(error)
return None
return valorIdentificador
def traduccion(self):
if self.codigo.text() == "":
return
self.editor.setText("")
sys.setrecursionlimit(2147483644)
self.consola.clear()
ReporteErrores.func(None,True)
g.textoEntrada = self.codigo.text()
g.func(0,None)
instrucciones = g.parse(self.codigo.text())
self.instrucciones = instrucciones
ts_global = TS.Entorno(None)
ast = AST.AST(instrucciones)
temp.temporal(True)
temp.parametro(True)
temp.etiqueta(True)
temp.listaContinue(-1,None)
temp.listaBreak(-1,None)
temp.listaReturn(-1,None)
temp.listaLLamada(-1,None)
temp.listaRecusion(-1,None)
#PRIMERA PASADA PARA GUARDAR TODAS LAS FUNCIONES Y STRUCTS
if(instrucciones != None):
for ins in instrucciones:
try:
if(isinstance(ins,Funcion)):
if(ast.existeEtiqueta(ins)):
error = Error.Error("SEMANTICO","Error semantico, Ya existe la funcion "+ins.id,ins.linea,ins.columna)
ReporteErrores.func(error)
else:
if(ins.id != "main"):
ins.inicializar(ts_global,ast,self)
ast.agregarEtiqueta(ins)
elif(isinstance(ins,Struct)):
if(ast.existeStruct(ins)):
error = Error.Error("SEMANTICO","Error semantico, Ya existe el Struct "+ins.id,ins.linea,ins.columna)
ReporteErrores.func(error)
else:
ast.agregarStruct(ins)
except:
pass
#SE TRADUCE EL METODO MAIN
main = ast.obtenerEtiqueta("main")
if(main != None):
self.editor.append("main:")
#se corren las instrucciones globales
for ins in instrucciones:
try:
if(not isinstance(ins,Funcion)):
try:
ins.traducir(ts_global,ast,self)
except:
pass
except:
pass
entMain = TS.Entorno(ts_global)
for ins in main.instrucciones:
try:
ins.traducir(entMain,ast,self)
except:
pass
ast.entornoGlobal.tabla = {**entMain.tabla,**ast.entornoGlobal.tabla}
ast.entornoGlobal.tabla = {**ts_global.tabla,**ast.entornoGlobal.tabla}
else:
error = Error.Error("SEMANTICO","Error semantico, No puede iniciarse el programa ya que no existe el metodo main()",0,0)
ReporteErrores.func(error)
listado = ReporteErrores.func(None)
if(len(listado)>0):
QMessageBox.critical(self.centralwidget, "Errores en Traducción", "Se obtuvieron errores en la traducción del Código Ingresado, verifique reporte de Errores de Traducción")
self.ts_global = ts_global
self.ast = ast
self.listado_gramatical = g.func(1,None).copy()
def traducir(self, ent, arbol, ventana):
funcion = arbol.obtenerEtiqueta(self.id)
if (funcion == None):
error = Error(
"SEMANTICO",
"Error semantico, no se encuentra definida una Función con el nombre "
+ self.id, self.linea, self.columna)
ReporteErrores.func(error)
return None
if (len(funcion.parametros) != len(funcion.temporales)):
error = Error(
"SEMANTICO",
"Error semantico, no se encuentra definida una Función con el nombre "
+ self.id, self.linea, self.columna)
ReporteErrores.func(error)
return None
if (len(funcion.parametros) != len(self.expresiones)):
error = Error(
"SEMANTICO",
"Error semantico, El número de parametros no son iguales a los definidos en la función "
+ self.id, self.linea, self.columna)
ReporteErrores.func(error)
return None
enLlamada = TS.Entorno(ent)
contador = 0
#funcion.calcularNiveles(funcion.instrucciones)
#cantidad = temp.listaRecusion(None,None).count(self.id)
for parametro in funcion.parametros:
parametro.valor = self.expresiones[contador]
parametro.temporal = funcion.temporales[contador]
parametro.traducir(enLlamada, arbol, ventana)
contador = contador + 1
#llamadaAnterior = temp.listaLLamada(1,None)
#recursionAnterior = temp.listaRecusion(1,None)
#llamadaPrevia = temp.listaLLamada(1,None)
#if(recursionAnterior==self.id):
llamadaAnterior = temp.listaLLamada(1, None) #
recursionAnterior = temp.listaRecusion(1, None) #
# if(cantidad<funcion.nivelesRecursiva):
# etiquetaFuncion = temp.etiqueta()
# etiquetaSalida = temp.etiqueta()
# temp.listaLLamada(0,etiquetaFuncion)
# temp.listaRecusion(0,self.id)
# funcion.entorno = enLlamada
# funcion.etiqueta = etiquetaFuncion
# ventana.editor.append("\n"+"goto "+etiquetaFuncion+";")
# funcion.traducir(ent,arbol,ventana)
# ventana.editor.append("\n"+etiquetaSalida+":")
# temp.listaLLamada(2,etiquetaFuncion)
# temp.listaRecusion(2,self.id)
# #else:
# if(llamadaPrevia!=None):
# if(llamadaAnterior!=llamadaPrevia):
# ventana.editor.append("\n"+"goto "+llamadaPrevia+";")
# #else:
# #ventana.editor.append("\n"+"goto "+llamadaAnterior+";")
#else:
if (not recursionAnterior == self.id):
etiquetaFuncion = temp.etiqueta()
etiquetaSalida = temp.etiqueta()
temp.listaLLamada(0, etiquetaFuncion)
temp.listaRecusion(0, self.id)
funcion.entorno = enLlamada
funcion.etiqueta = etiquetaFuncion
ventana.editor.append("\n" + "goto " + etiquetaFuncion + ";")
funcion.traducir(ent, arbol, ventana)
ventana.editor.append("\n" + etiquetaSalida + ":")
temp.listaLLamada(2, etiquetaFuncion)
temp.listaRecusion(2, self.id)
else: #
ventana.editor.append("\n" + "goto " + llamadaAnterior + ";") #
arbol.entornoGlobal.tabla = {
**enLlamada.tabla,
**arbol.entornoGlobal.tabla
}
def traducir(self, ent, arbol, ventana):
contador = 0
for id in self.lista:
llaves = None
if (isinstance(id, AccesoLista)):
llaves = id.llaves
id = id.id
#validar si existe el simbolo dentro de la tabla
if (ent.existeLocal(id)):
error = Error(
"SEMANTICO",
"Error semantico, ya se encuentra declarado un identificador con el nombre "
+ id, self.linea, self.columna)
ReporteErrores.func(error)
return None
else:
traduccion = ""
temporal = temp.temporal()
simbolo = Simbolo(id, temporal, self.tipo, self.linea,
self.columna)
simbolo.llaves = llaves
if (llaves != None):
traduccion = temporal + "=array();"
ent.agregar(simbolo)
ventana.editor.append("\n" + traduccion)
if (self.valor != None and contador
== (len(self.lista) - 1)): #asignacion de array
asignacion = Asignacion(id, self.valor, self.linea,
self.columna)
asignacion.traducir(ent, arbol, ventana)
else: #identificadores y structs
if (self.valor == None
or (self.valor != None and contador <
(len(self.lista) - 1))):
if (self.adicional != ""):
traduccion = temporal + "=" + self.adicional + ";"
elif (self.tipo == Tipo.ENTERO):
traduccion = temporal + "=0;"
elif (self.tipo == Tipo.FLOAT):
traduccion = temporal + "=0.0;"
elif (self.tipo == Tipo.CHAR):
traduccion = temporal + "='';"
else:
struct = arbol.obtenerStruct(self.tipo)
if (struct == None):
error = Error(
"SEMANTICO",
"Error semantico, no se encuentra declarado un struct con el nombre "
+ self.tipo, self.linea, self.columna)
ReporteErrores.func(error)
return None
traduccion = temporal + "=array();"
ent.agregar(simbolo)
ventana.editor.append("\n" + traduccion)
else:
ent.agregar(simbolo)
asignacion = Asignacion(id, self.valor, self.linea,
self.columna, self.adicional)
asignacion.traducir(ent, arbol, ventana)
contador = contador + 1