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 debug(self, ventana):
self.hilo_terminado = False
main = self.ast.obtenerEtiqueta("main")
if (main != None):
salir = False
ventana.editor.setCursorPosition(0, 0)
ventana.editor.setFocus()
time.sleep(2)
for ins in main.instrucciones:
QApplication.processEvents()
try:
ventana.editor.setCursorPosition(ins.linea - 1, 0)
ventana.editor.setFocus()
time.sleep(1)
if (isinstance(ins, Asignacion.Asignacion)
or isinstance(ins, Conversion.Conversion)):
ins.setAmbito("main")
if (ins.ejecutar(self.ts_global, self.ast, ventana,
True) == True):
salir = True
break
contador = 1
ventana.tableWidget.setRowCount(0)
ventana.tableWidget.setRowCount(100)
ventana.tableWidget.setItem(0, 0, QTableWidgetItem("No."))
ventana.tableWidget.setItem(0, 1,
QTableWidgetItem("Simbolo"))
ventana.tableWidget.setItem(0, 2,
QTableWidgetItem("Valor"))
for key in self.ts_global.tabla:
s = self.ts_global.tabla[key]
ventana.tableWidget.setItem(
contador, 0, QTableWidgetItem(str(contador)))
ventana.tableWidget.setItem(contador, 1,
QTableWidgetItem(s.id))
ventana.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, ventana, 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(
ventana.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 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 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 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 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 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 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 debugger(self, ventana):
ventana.tableWidget.setRowCount(0)
ventana.tableWidget.setRowCount(100)
ventana.tableWidget.setItem(0, 0, QTableWidgetItem("No."))
ventana.tableWidget.setItem(0, 1, QTableWidgetItem("Simbolo"))
ventana.tableWidget.setItem(0, 2, QTableWidgetItem("Valor"))
if (self.hilo_terminado):
sys.setrecursionlimit(2147483644)
ventana.consola.clear()
ReporteErrores.func(None, True)
g.func(0, None)
g.textoEntrada = ventana.editor.text()
instrucciones = g.parse(ventana.editor.text())
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, ventana, True)
declaracion2.ejecutar(ts_global, ast, ventana, 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(ventana)
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 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 generarRErrores(self):
reporteErrores = ReporteErrores.ReporteErrores()
reporteErrores.generarReporte()
def ascendente(self, ventana):
sys.setrecursionlimit(2147483644)
ventana.consola.clear()
ReporteErrores.func(None, True)
g.textoEntrada = ventana.editor.text()
g.func(0, None)
instrucciones = g.parse(ventana.editor.text())
self.instrucciones = instrucciones
ts_global = TS.Entorno(None)
ts_global.asignarConsola(ventana.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, ventana, False)
declaracion2.ejecutar(ts_global, ast, ventana, 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, ventana, False) == True):
salir = True
break
except:
pass
if (not salir):
siguiente = ast.obtenerSiguienteEtiqueta("main")
if (siguiente != None):
siguiente.ejecutar(ts_global, ast, ventana, 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(
ventana.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()