def traducir(self, tabla, arbol):
super().traducir(tabla,arbol)
tablaLocal = Tabla(None)
arbol.addc3d('\r@with_goto # Decorador necesario.')
arbol.addc3d(f"\rdef {self.id}():")
arbol.addc3d("global P")
arbol.addc3d("global Pila")
if self.tipo.tipo != Tipo_Dato.VOID:
variable = Simbolo("return", self.tipo, None, self.linea, self.columna)
variable.rol = "Variable Local"
variable.posicion = tablaLocal.stack
variable.tamanio = 1
tabla.agregarSimbolo(variable)
tablaLocal.stack += 1
for i in self.parametros:
i.traducir(tablaLocal, arbol)
tablaLocal.anterior = tabla
for i in self.instrucciones:
i.traducir(tablaLocal, arbol)
# Se llena el reporte de la tabla de símbolo
for i in tablaLocal.variables:
i.ambito = self.id
tabla.agregarReporteSimbolo(i)
arbol.addc3d(f"\n\treturn\n")
return
def traducir(self, tabla: Tabla, arbol: Arbol):
super().traducir(tabla, arbol)
retorno = Nodo3D()
arbol.addc3d("# Inicia Elsif")
condicion = self.condicion.traducir(tabla, arbol)
if condicion.temporalAnterior == "0":
etiqueta1 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta1}")
condicion.etiquetaTrue = ""
condicion.etiquetaFalse = etiqueta1
elif condicion.temporalAnterior == "1":
etiqueta1 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta1}")
condicion.etiquetaTrue = etiqueta1
condicion.etiquetaFalse = ""
etiquetaFin = tabla.getEtiqueta()
condicion.imprimirEtiquetDestino(arbol, condicion.etiquetaTrue)
# Se traducen todas las funciones dentro del if
for i in self.instrucciones:
i.traducir(tabla, arbol)
arbol.addc3d(f"goto .{etiquetaFin}")
condicion.imprimirEtiquetDestino(arbol, condicion.etiquetaFalse)
retorno.temporalAnterior = f"label .{etiquetaFin}"
return retorno
def analizar(self, tabla, arbol):
super().analizar(tabla,arbol)
tablaLocal = Tabla(None)
for i in self.parametros:
i.analizar(tablaLocal, arbol)
tablaLocal.anterior = tabla
esFuncion = False
if self.tipo.tipo != Tipo_Dato.VOID:
esFuncion = True
hayReturn = False
for i in self.instrucciones:
resultado = i.analizar(tablaLocal, arbol)
if isinstance(i, Return):
if isinstance(resultado, Excepcion):
return resultado
hayReturn = True
if esFuncion and not hayReturn:
error = Excepcion("42723", "Semantico", f"La función {self.id} requiere un valor de retorno", self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
if not esFuncion and hayReturn:
error = Excepcion("42723", "Semantico", f"El método {self.id} no requiere un valor de retorno", self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
def traducirc3d_click(self):
global arbol
arbol = None
global tablaSym
dropAll()
os.system("cls")
#Elimina el Contenido de txtsalida
self.txtsalida[self.tab.index("current")].delete(1.0, END)
input = self.txtentrada[self.tab.index("current")].get(1.0, END)
tablaGlobal = Tabla(None)
inst = sintactico.ejecutar_analisis(input)
arbol = Arbol(inst)
resultado = ""
for i in arbol.instrucciones:
res = i.traducir(tablaGlobal, arbol, "")
if isinstance(res, Simbolo3d):
resultado += res.codigo
else:
resultado += res
FuncionesPara3D.FuncionesPara3D.GenerarArchivo(resultado)
tablaSym = tablaGlobal
print("Archivo Traducido")
pass
def btnanalizar_click(self):
global arbol
arbol = None
dropAll()
os.system ("cls")
#Elimina el Contenido de txtsalida
self.txtsalida[self.tab.index("current")].delete(1.0,END)
#Inserta "Archivo Analizado" en txtsalida
#self.txtsalida[self.tab.index("current")].insert(INSERT,"Archivo Analizado")
#Selecciona el contenido de txt entrada
#print(self.txtentrada[self.tab.index("current")].get(1.0,END))
input=self.txtentrada[self.tab.index("current")].get(1.0,END)
tablaGlobal = Tabla(None)
inst = sintactico.ejecutar_analisis(input)
arbol = Arbol(inst)
if len(sintactico.lista_lexicos)>0:
messagebox.showerror('Tabla de Errores','La Entrada Contiene Errores!')
reportes.RealizarReportes.RealizarReportes.generar_reporte_lexicos(sintactico.lista_lexicos)
# Ciclo que recorrerá todas las instrucciones almacenadas por la gramática.
arbol.lRepDin.append("<init> ::= <instrucciones>")
arbol.lRepDin.append("<instrucciones> ::= <instrucciones> <instruccion>")
arbol.lRepDin.append("<instrucciones> ::= <instruccion>")
for i in arbol.instrucciones:
# La variable resultado nos permitirá saber si viene un return, break o continue fuera de sus entornos.
resultado = i.ejecutar(tablaGlobal,arbol)
# Después de haber ejecutado todas las instrucciones se verifica que no hayan errores semánticos.
if len(arbol.excepciones) != 0:
reportes.RealizarReportes.RealizarReportes.generar_reporte_lexicos(arbol.excepciones)
# Ciclo que imprimirá todos los mensajes guardados en la variable consola.
mensaje = ''
for m in arbol.consola:
mensaje += m + '\n'
self.txtsalida[self.tab.index("current")].insert(INSERT,mensaje)
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
# Ambito para la tabla
tablaLocal = Tabla(tabla)
if arbol.bdUsar != None:
objetoTabla = arbol.devolviendoTablaDeBase(self.tabla)
if objetoTabla != 0:
for columnas in objetoTabla.lista_de_campos:
arbol.comprobacionCreate = True
objeto = Declaracion(columnas.nombre, columnas.tipo, None)
objeto.ejecutar(tablaLocal, arbol)
resultado = self.condicion.ejecutar(tablaLocal, arbol)
if isinstance(resultado, Excepcion):
return resultado
# Buscamos el nombre del constraint
col = None
for columnas in objetoTabla.lista_de_campos:
if columnas.nombre == arbol.columnaCheck:
col = columnas
break
nombre = ''
if col.constraint != None:
for const in columnas.constraint:
if const.tipo == Tipo_Dato_Constraint.CHECK:
nombre = const.id
last_char = nombre[-1]
sinNumero = nombre[:-1]
nuevo = sinNumero + str(int(last_char) + 1)
col.constraint.append(
Tipo_Constraint(nuevo, Tipo_Dato_Constraint.CHECK,
self.condicion))
else:
col.constraint = []
col.constraint.append(
Tipo_Constraint(
self.tabla + "_" + arbol.columnaCheck + "_check1",
Tipo_Dato_Constraint.CHECK, self.condicion))
arbol.comprobacionCreate = False
arbol.columnaCheck = None
arbol.consola.append("Consulta devuelta correctamente.")
print("Constulta ALTER CHECK devuelta correctamente")
else:
error = Excepcion('42P01', "Semántico",
"No existe la relación " + self.tabla,
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
else:
error = Excepcion("100", "Semantico",
"No ha seleccionado ninguna Base de Datos.",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
def primerapasada(self):
global arbol
arbol = None
dropAll()
os.system("cls")
#Elimina el Contenido de txtsalida
self.txtsalida[self.tab.index("current")].delete(1.0, END)
#Inserta "Archivo Analizado" en txtsalida
#self.txtsalida[self.tab.index("current")].insert(INSERT,"Archivo Analizado")
#Selecciona el contenido de txt entrada
#print(self.txtentrada[self.tab.index("current")].get(1.0,END))
input = self.txtentrada[self.tab.index("current")].get(1.0, END)
tablaGlobal = Tabla(None)
inst = sintactico.ejecutar_analisis(input)
arbol = Arbol(inst)
if len(sintactico.lista_lexicos) > 0:
messagebox.showerror('Tabla de Errores',
'La Entrada Contiene Errores!')
reportes.RealizarReportes.RealizarReportes.generar_reporte_lexicos(
sintactico.lista_lexicos)
# Ciclo que recorrerá todas las instrucciones almacenadas por la gramática.
arbol.lRepDin.append("<init> ::= <instrucciones>")
arbol.lRepDin.append(
"<instrucciones> ::= <instrucciones> <instruccion>")
arbol.lRepDin.append("<instrucciones> ::= <instruccion>")
j = 0
h = 0
for i in arbol.instrucciones:
# La variable resultado nos permitirá saber si viene un return, break o continue fuera de sus entornos.
print("analizara")
print(i)
try:
print("al")
if isinstance(i, Execute.Execute):
print("es execute con j= " + str(j))
i.generar(j, tablaGlobal, arbol)
j = j + 1
if isinstance(i, insertTable.insertTable):
j = i.validar(j, tablaGlobal, arbol)
print("es insertTable con j= " + str(j))
print("NOes execute")
except:
print("ara")
pass
def funcionintermedia(): global P global Pila t0 = P+0 t1 = t0+1 t2 = Pila[t1] print(t2) tablaGlobal = Tabla(None) inst = sintactico.ejecutar_analisis(t2) arbol = Arbol(inst) arbol.instrucciones[0].ejecutar(tablaGlobal,arbol)
def btnoptimizar_click(self):
import optimizacion.sintacticoC3D
os.system("cls")
#Elimina el Contenido de txtsalida
self.txtoptimizacion[self.tab.index("current")].delete(1.0, END)
#aqui vamos a leer el archivo
input = self.txtsalida[self.tab.index("current")].get(1.0, END)
tablaGlobal = Tabla(None)
inst = optimizacion.sintacticoC3D.ejecutar_analisis2(input)
arbol = Arbol(inst)
instru = arbol.instrucciones
if (instru):
m = Mirillas(instru)
m.optimizarCodigo()
val = m.getItemReporte()
ro.crear_tabla(val)
resultado = ""
tabulador = ""
for i in arbol.instrucciones:
# La variable resultado nos permitirá saber si viene un return, break o continue fuera de sus entornos.
if i:
if (isinstance(i, MetodoC3D)):
tabulador = True
if (tabulador == True and not (isinstance(i, MetodoC3D))):
resultado += "\t"
if (isinstance(i, Arroba)):
resultado += "\r\r"
resultado += i.ejecutar(tablaGlobal, arbol)
resultado += "\n"
if (isinstance(i, SentenciaIf)):
resultado += "\t"
# Después de haber ejecutado todas las instrucciones se verifica que no hayan errores semánticos.
if len(arbol.excepciones) != 0:
reportes.RealizarReportes.RealizarReportes.generar_reporte_lexicos(
arbol.excepciones)
# Ciclo que imprimirá todos los mensajes guardados en la variable consola.
mensaje = ''
for m in arbol.consola:
mensaje += m + '\n'
archivo = open("pruebaOpti.py", "w", encoding='utf-8')
archivo.write(resultado)
archivo.close()
self.txtoptimizacion[self.tab.index("current")].insert(
INSERT, resultado)
def traducir(self, tabla, arbol):
super().traducir(tabla, arbol)
tablaLocal = Tabla(None)
arbol.addc3d('\r@with_goto # Decorador necesario.')
arbol.addc3d(f"\rdef {self.id}():")
arbol.addc3d("global P")
arbol.addc3d("global Pila")
arbol.tamanio_actual = self.size
arbol.etiqueta_fin = tablaLocal.getEtiqueta()
if self.tipo.tipo != Tipo_Dato.VOID:
variable = Simbolo("return", self.tipo, None, self.linea,
self.columna)
variable.rol = "Variable Local"
variable.posicion = tablaLocal.stack
variable.tamanio = 1
tabla.agregarSimbolo(variable)
tablaLocal.stack += 1
for i in self.parametros:
i.traducir(tablaLocal, arbol)
tablaLocal.anterior = tabla
for i in self.declaraciones:
i.traducir(tablaLocal, arbol)
for i in self.instrucciones:
i.traducir(tablaLocal, arbol)
# Se llena el reporte de la tabla de símbolo
for i in tablaLocal.variables:
i.ambito = self.id
tabla.agregarReporteSimbolo(i)
arbol.addComen("Etiqueta de salida función")
arbol.addc3d(f"label .{arbol.etiqueta_fin}\n")
arbol.tamanio_actual = None
return
def btnanalizar_click(self):
global arbol
arbol = None
dropAll()
os.system ("cls")
#Elimina el Contenido de txtsalida
self.txtsalida[self.tab.index("current")].delete(1.0,END)
#Inserta "Archivo Analizado" en txtsalida
#self.txtsalida[self.tab.index("current")].insert(INSERT,"Archivo Analizado")
#Selecciona el contenido de txt entrada
#print(self.txtentrada[self.tab.index("current")].get(1.0,END))
input=self.txtentrada[self.tab.index("current")].get(1.0,END)
tablaGlobal = Tabla(None)
# solo para probar el C3D
inst = sintacticoC3D.ejecutar_analisis(input)
'''inst = sintactico.ejecutar_analisis(input)
def btnanalizar_click(self):
os.system ("cls")
#Elimina el Contenido de txtsalida
self.txtsalida[self.tab.index("current")].delete(1.0,END)
#Inserta "Archivo Analizado" en txtsalida
#self.txtsalida[self.tab.index("current")].insert(INSERT,"Archivo Analizado")
#Selecciona el contenido de txt entrada
#print(self.txtentrada[self.tab.index("current")].get(1.0,END))
input=self.txtentrada[self.tab.index("current")].get(1.0,END)
tablaGlobal = Tabla(None)
inst = sintactico.ejecutar_analisis(input)
arbol = Arbol(inst)
# Ciclo que recorrerá todas las instrucciones almacenadas por la gramática.
for i in arbol.instrucciones:
# La variable resultado nos permitirá saber si viene un return, break o continue fuera de sus entornos.
resultado = i.ejecutar(tablaGlobal,arbol)
# Después de haber ejecutado todas las instrucciones se verifica que no hayan errores semánticos.
if len(arbol.excepciones) != 0:
reportes.RealizarReportes.RealizarReportes.generar_reporte_lexicos(arbol.excepciones)
# Ciclo que imprimirá todos los mensajes guardados en la variable consola.
for m in arbol.consola:
print(m)
self.txtsalida[self.tab.index("current")].insert(INSERT,"Archivo Analizado")
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
# Ambito para la tabla
tablaLocal = Tabla(tabla)
compuesta = True
#SE VALIDA QUE SE HAYA SELECCIONADO UN BD
if arbol.bdUsar != None:
for camp in self.campos:
if isinstance(camp, Tipo_Constraint):
tc = self.campos.pop(int(self.campos.index(camp)))
if tc.tipo == Tipo_Dato_Constraint.UNIQUE or tc.tipo == Tipo_Dato_Constraint.PRIMARY_KEY or tc.tipo == Tipo_Dato_Constraint.FOREIGN_KEY:
for id in tc.expresion:
bid = False
for ct in self.campos:
if ct.nombre == id:
if self.campos[self.campos.index(
ct)].constraint == None:
self.campos[self.campos.index(
ct)].constraint = []
if tc.tipo == Tipo_Dato_Constraint.UNIQUE:
self.campos[self.campos.index(
ct)].constraint.append(
Tipo_Constraint(
self.tabla + "_" +
ct.nombre + "_pkey",
Tipo_Dato_Constraint.
UNIQUE, None))
if tc.tipo == Tipo_Dato_Constraint.PRIMARY_KEY:
compuesta = False
self.campos[self.campos.index(
ct)].constraint.append(
Tipo_Constraint(
self.tabla + "_pkey",
Tipo_Dato_Constraint.
PRIMARY_KEY, None))
#if tc.tipo == Tipo_Dato_Constraint.FOREIGN_KEY:
#self.campos[self.campos.index(ct)].constraint.append(Tipo_Constraint(None, Tipo_Dato_Constraint.UNIQUE, None))
bid = True
if not bid:
error = Excepcion(
"42P10", "Semantico",
f"La columna <<{id}>> no existe, Error en el Constraint",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return
#SE VALIDA SI LA TABLA VA HEREDAR
if self.herencia != None:
#SE BUSCA LA SI LA TABLA HEREDADA EXISTE
htabla = arbol.devolverBaseDeDatos().getTabla(self.herencia)
if htabla != None:
tabla_temp = []
#SE RECORRE TODOS LAS COLUMNAS DE LA TABLA PARA UNIR CAMPOS REPETIDOS
for campo_her in htabla.lista_de_campos:
indice = 0
bandera_campo = True
for campo_nuevo in self.campos:
if campo_her.nombre == campo_nuevo.nombre:
tabla_temp.append(campo_nuevo)
arbol.consola.append(
f"NOTICE: mezclando la columna <<{campo_nuevo.nombre}>> con la definición heredada."
)
self.campos.pop(indice)
indice += 1
bandera_campo = False
break
if bandera_campo:
tabla_temp.append(campo_her)
tabla_temp = tabla_temp + self.campos
self.campos = tabla_temp
else:
error = Excepcion(
f"42P01", "Semantico",
"No existe la relación <<{self.herencia}>>.",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return
# VERIFICACIÓN LLAVES PRIMARIAS
listaPrimarias = []
for camp in self.campos:
if isinstance(camp.tipo, Tipo):
if camp.constraint != None:
for s in camp.constraint:
if s.tipo == Tipo_Dato_Constraint.PRIMARY_KEY:
listaPrimarias.append(camp)
if len(listaPrimarias) > 1 and compuesta:
error = Excepcion(
"42P16", "Semantico",
"No se permiten múltiples llaves primarias para la tabla «"
+ self.tabla + "»", self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
#SE CREA UN AMBITO PARA LA TABLA
tablaNueva = Tablas(self.tabla, None)
#SE LLENA LA TABLA EN MEMORIA
for camp in self.campos:
if isinstance(camp.tipo, Tipo):
if camp.tipo.tipo == Tipo_Dato.TIPOENUM:
existe = arbol.getEnum(camp.tipo.nombre)
if existe == None:
error = Excepcion(
'42P00', "Semántico",
"El tipo " + camp.tipo.nombre + " no existe",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
if camp.constraint != None:
for s in camp.constraint:
if s.tipo == Tipo_Dato_Constraint.CHECK:
arbol.comprobacionCreate = True
objeto = Declaracion(camp.nombre, camp.tipo,
s.expresion)
checkBueno = objeto.ejecutar(tablaLocal, arbol)
if not isinstance(checkBueno, Excepcion):
if s.id == None:
s.id = self.tabla + "_" + camp.nombre + "_" + "check1"
#tablaNueva.agregarColumna(camp.nombre,camp.tipo.toString(),None, camp.constraint)
#continue
pass
else:
#arbol.consola.append(checkBueno.toString())
return
elif s.tipo == Tipo_Dato_Constraint.PRIMARY_KEY:
if s.id == None:
s.id = self.tabla + "_pkey"
elif s.tipo == Tipo_Dato_Constraint.UNIQUE:
if s.id == None:
s.id = self.tabla + "_" + camp.nombre + "_pkey"
tablaNueva.agregarColumna(camp.nombre, camp.tipo, None,
camp.constraint)
#tablaNueva.lista_constraint.append(camp.constraint)
else:
tablaNueva.agregarColumna(camp.nombre, camp.tipo, None,
camp.constraint)
#tablaNueva.lista_constraint.append(camp.constraint)
arbol.comprobacionCreate = False
#SE CREA LA TABLA EN DISCO
ctable = createTable(arbol.bdUsar, self.tabla, len(self.campos))
if ctable == 0: #CUANDO LA TABLA SE CREA CORRECTAMENTE
arbol.consola.append(
f"La Tabla: <<{self.tabla}>> se creo correctamente.")
arbol.agregarTablaABd(tablaNueva)
elif ctable == 3: #CUANDO LA TABLA YA EXISTE
error = Excepcion("100", "Semantico", "La Tabla ya Existe.",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
elif ctable == 2: #CUANDO POR ALGUN ERROR NO SE CREA LA TABLA.
error = Excepcion("100", "Semantico", "Error Interno.",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
# SE AGREGAN LAS LLAVES PRIMARIAS A LA TABLA
listaIndices = []
resultado = 0
for i in listaPrimarias:
listaIndices.append(tablaNueva.devolverColumna(i.nombre))
if len(listaIndices) > 0:
#print("SE AGREGO UN INDICE")
resultado = alterAddPK(arbol.getBaseDatos(), self.tabla,
listaIndices)
if resultado == 1:
error = Excepcion('XX000', "Semántico", "Error interno",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif resultado == 2:
error = Excepcion(
'42P00', "Semántico", "La base de datos " +
str(arbol.getBaseDatos()) + " no existe", self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif resultado == 3:
error = Excepcion('42P01', "Semántico",
"No existe la relación " + self.tabla,
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif resultado == 4:
error = Excepcion(
'42P16', "Semántico",
"No se permiten múltiples llaves primarias para la tabla «"
+ self.tabla + "»", self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif resultado == 5:
error = Excepcion('XX002', "Semántico",
"Columna fuera de limites." + self.tabla,
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
else:
error = Excepcion("100", "Semantico",
"No ha seleccionado ninguna Base de Datos.",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
if arbol.bdUsar != None:
objetoTabla = arbol.devolviendoTablaDeBase(self.valor)
if objetoTabla != 0:
#print('Ok!')
lista = []
# Si el insert tiene la lista de columnas
if (self.lcol != None):
tablaLocal = Tabla(tabla)
# Se valia que la lista de columnas este bien.
listaNombreColumnas = []
listaColumnas = []
indices = []
for c in self.lcol:
for col in objetoTabla.lista_de_campos:
if col.nombre == c:
listaNombreColumnas.append(col.nombre)
listaColumnas.append(col)
indices.append(col.orden)
listaNoEncontrados = list(
set(self.lcol) - set(listaNombreColumnas))
if len(listaNoEncontrados) > 0:
for c in listaNoEncontrados:
error = Excepcion(
'42703', "Semántico",
"No existe la columna «" + c +
"» en la relación «" + self.valor + "»",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return
# Se valida que la lista de expresiones sea igual a la lista de columnas
if len(self.lexpre) != len(self.lcol):
error = Excepcion(
'23505', "Semántico",
"INSERT tiene más o menos expresiones que columnas de destino",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
# Recorrido para insertar
for c in range(0, len(listaColumnas)):
res = self.lexpre[c].ejecutar(tabla, arbol)
if isinstance(res, Excepcion):
return res
if listaColumnas[c].constraint != None:
for constraint in listaColumnas[c].constraint:
if constraint.tipo == Tipo_Dato_Constraint.PRIMARY_KEY:
valida = self.validacionesPrimary(
listaColumnas[c].nombre, res, arbol)
if not valida:
error = Excepcion(
'23505', "Semántico",
"Llave duplicada viola restricción de unicidad «"
+ constraint.id + "»", self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
if constraint.tipo == Tipo_Dato_Constraint.UNIQUE:
valida = self.validacionesPrimary(
listaColumnas[c].nombre, res, arbol)
if not valida:
error = Excepcion(
'23505', "Semántico",
"Llave duplicada viola restricción de unicidad «"
+ constraint.id + "»", self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif constraint.tipo == Tipo_Dato_Constraint.NOT_NULL:
pass
elif constraint.tipo == Tipo_Dato_Constraint.FOREIGN_KEY:
valida = self.validacionesForeign(
constraint.referencia,
constraint.expresion.nombre, res,
arbol)
if not valida:
error = Excepcion(
'23505', "Semántico",
"Inserción o actualización en la tabla «"
+ self.valor +
"» viola la llave foránea " +
constraint.id, self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
# Comprobación de que el tipo sea el mismo
comprobar = self.comprobarTipo(listaColumnas[c].tipo,
self.lexpre[c].tipo,
res, arbol)
if isinstance(comprobar, Excepcion):
return comprobar
if comprobar:
if listaColumnas[c].constraint != None:
for constraint in listaColumnas[c].constraint:
if constraint.tipo == Tipo_Dato_Constraint.CHECK:
arbol.comprobacionCreate = True
resultado = self.validacionesCheck(
listaColumnas[c].nombre,
listaColumnas[c].tipo, res,
constraint.expresion, tablaLocal,
arbol)
if isinstance(resultado, Excepcion):
return resultado
if not resultado:
error = Excepcion(
'23505', "Semántico",
"El nuevo registro para la relación «"
+ self.valor +
"» viola la restricción «check» «"
+ constraint.id + "»",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(
error.toString())
return error
arbol.comprobacionCreate = False
lista.append(res)
else:
error = Excepcion(
'42804', "Semántico", "La columna «" +
listaColumnas[c].nombre + "» es de tipo " +
listaColumnas[c].tipo.toString() +
" pero la expresión es de tipo " +
self.lexpre[c].tipo.toString(), self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
columnasNulas = list(
set(objetoTabla.lista_de_campos) - set(listaColumnas))
for c in range(0, len(columnasNulas)):
if columnasNulas[c].constraint != None:
for constraint in columnasNulas[c].constraint:
if constraint.tipo == Tipo_Dato_Constraint.PRIMARY_KEY:
error = Excepcion(
'23505', "Semántico",
"El valor nulo en la columna «" +
columnasNulas[c].nombre +
"» de la relación «" + self.valor +
"» viola la restricción de no nulo",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
if constraint.tipo == Tipo_Dato_Constraint.UNIQUE:
error = Excepcion(
'23505', "Semántico",
"El valor nulo en la columna «" +
columnasNulas[c].nombre +
"» de la relación «" + self.valor +
"» viola la restricción de no nulo",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif constraint.tipo == Tipo_Dato_Constraint.NOT_NULL:
error = Excepcion(
'23505', "Semántico",
"El valor nulo en la columna «" +
columnasNulas[c].nombre +
"» de la relación «" + self.valor +
"» viola la restricción de no nulo",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif constraint.tipo == Tipo_Dato_Constraint.FOREIGN_KEY:
error = Excepcion(
'23505', "Semántico",
"El valor nulo en la columna «" +
columnasNulas[c].nombre +
"» de la relación «" + self.valor +
"» viola la restricción de no nulo",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
lista.append("Null")
indices.append(columnasNulas[c].orden)
listaOrden = []
for i in range(0, len(indices)):
objeto = [indices[i], lista[i]]
listaOrden.append(objeto)
ordenados = sorted(listaOrden)
listaFinal = [item[1] for item in ordenados]
if len(lista) != len(objetoTabla.lista_de_campos):
return
resultado = insert(arbol.getBaseDatos(), self.valor,
listaFinal)
if resultado == 1:
error = Excepcion('XX000', "Semántico",
"Error interno", self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif resultado == 2:
error = Excepcion(
'42P00', "Semántico", "La base de datos " +
str(arbol.getBaseDatos()) + " no existe",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif resultado == 3:
error = Excepcion(
'42P01', "Semántico",
"No existe la relación " + self.valor, self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif resultado == 4:
error = Excepcion(
'2BP01', "Semántico",
"Llave duplicada viola restricción de unicidad «" +
self.valor + "_pkey»", self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif resultado == 5:
error = Excepcion(
'XX002', "Semántico",
"Columna fuera de limites." + self.valor,
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
arbol.consola.append(
f"el registro se inserto correctamente.")
print(
"EL REGISTRO SE INSERTO CORRECTAMENTE [InsertTable ejecutado correctamente]"
)
# El insert no tiene una lista de columnas
else:
if len(self.lexpre) != len(objetoTabla.lista_de_campos):
error = Excepcion(
'23505', "Semántico",
"INSERT tiene más o menos expresiones que columnas de destino",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
tablaLocal = Tabla(tabla)
for c in range(0, len(objetoTabla.lista_de_campos)):
res = self.lexpre[c].ejecutar(tabla, arbol)
if isinstance(res, Excepcion):
return res
if objetoTabla.lista_de_campos[c].constraint != None:
for constraint in objetoTabla.lista_de_campos[
c].constraint:
if constraint.tipo == Tipo_Dato_Constraint.PRIMARY_KEY:
valida = self.validacionesPrimary(
objetoTabla.lista_de_campos[c].nombre,
res, arbol)
if not valida:
error = Excepcion(
'23505', "Semántico",
"Llave duplicada viola restricción de unicidad «"
+ constraint.id + "»", self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
if constraint.tipo == Tipo_Dato_Constraint.UNIQUE:
valida = self.validacionesPrimary(
objetoTabla.lista_de_campos[c].nombre,
res, arbol)
if not valida:
error = Excepcion(
'23505', "Semántico",
"Llave duplicada viola restricción de unicidad «"
+ constraint.id + "»", self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif constraint.tipo == Tipo_Dato_Constraint.NOT_NULL:
pass
elif constraint.tipo == Tipo_Dato_Constraint.FOREIGN_KEY:
valida = self.validacionesForeign(
constraint.referencia,
constraint.expresion.nombre, res,
arbol)
if not valida:
error = Excepcion(
'23505', "Semántico",
"Inserción o actualización en la tabla «"
+ self.valor +
"» viola la llave foránea " +
constraint.id, self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
# Comprobación de que el tipo sea el mismo
comprobar = self.comprobarTipo(
objetoTabla.lista_de_campos[c].tipo,
self.lexpre[c].tipo, res, arbol)
if isinstance(comprobar, Excepcion):
return comprobar
if comprobar:
if objetoTabla.lista_de_campos[
c].constraint != None:
for constraint in objetoTabla.lista_de_campos[
c].constraint:
if constraint.tipo == Tipo_Dato_Constraint.CHECK:
arbol.comprobacionCreate = True
resultado = self.validacionesCheck(
objetoTabla.lista_de_campos[c].
nombre, objetoTabla.
lista_de_campos[c].tipo, res,
constraint.expresion, tablaLocal,
arbol)
if isinstance(resultado, Excepcion):
return resultado
if not resultado:
error = Excepcion(
'23505', "Semántico",
"El nuevo registro para la relación «"
+ self.valor +
"» viola la restricción «check» «"
+ constraint.id + "»",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(
error.toString())
return error
arbol.comprobacionCreate = False
lista.append(res)
else:
error = Excepcion(
'42804', "Semántico", "La columna «" +
objetoTabla.lista_de_campos[c].nombre +
"» es de tipo " +
objetoTabla.lista_de_campos[c].tipo.toString()
+ " pero la expresión es de tipo " +
self.lexpre[c].tipo.toString(), self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
if len(lista) != len(self.lexpre):
return
#print("esta es la insercion de lista, ya inserto estaticamente")
resultado = insert(arbol.getBaseDatos(), self.valor, lista)
if resultado == 1:
error = Excepcion('XX000', "Semántico",
"Error interno", self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif resultado == 2:
error = Excepcion(
'42P00', "Semántico", "La base de datos " +
str(arbol.getBaseDatos()) + " no existe",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif resultado == 3:
error = Excepcion(
'42P01', "Semántico",
"No existe la relación " + self.valor, self.linea,
self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif resultado == 4:
error = Excepcion(
'2BP01', "Semántico",
"Llave duplicada viola restricción de unicidad «" +
self.valor + "_pkey»", self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
elif resultado == 5:
error = Excepcion(
'XX002', "Semántico",
"Columna fuera de limites." + self.valor,
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
arbol.consola.append(
f"el registro se inserto correctamente.")
print(
"EL REGISTRO SE INSERTO CORRECTAMENTE [InserTable ejecutado correctamente]"
)
else:
error = Excepcion('42P01', "Semántico",
"No existe la relación " + self.valor,
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
else:
error = Excepcion("100", "Semantico",
"No ha seleccionado ninguna Base de Datos.",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
def traducir(self, tabla: Tabla, arbol: Arbol):
super().traducir(tabla, arbol)
retorno = Nodo3D()
arbol.addc3d("# Inicia If")
condicion = self.condicion.traducir(tabla, arbol)
# If
if len(self.l_if) == 0 and len(self.instrucciones_else) == 0:
if condicion.temporalAnterior == "0":
etiqueta1 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta1}")
condicion.etiquetaTrue = ""
condicion.etiquetaFalse = etiqueta1
elif condicion.temporalAnterior == "1":
etiqueta1 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta1}")
condicion.etiquetaTrue = etiqueta1
condicion.etiquetaFalse = ""
etiquetaFin = tabla.getEtiqueta()
condicion.imprimirEtiquetDestino(arbol, condicion.etiquetaTrue)
# Se traducen todas las funciones dentro del if
for i in self.instrucciones:
i.traducir(tabla, arbol)
arbol.addc3d(f"goto .{etiquetaFin}")
condicion.imprimirEtiquetDestino(arbol, condicion.etiquetaFalse)
arbol.addc3d(f"label .{etiquetaFin}")
# If - Else
elif len(self.l_if) == 0 and len(self.instrucciones_else) != 0:
if condicion.temporalAnterior == "0":
etiqueta1 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta1}")
condicion.etiquetaTrue = ""
condicion.etiquetaFalse = etiqueta1
elif condicion.temporalAnterior == "1":
etiqueta1 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta1}")
condicion.etiquetaTrue = etiqueta1
condicion.etiquetaFalse = ""
etiquetaFin = tabla.getEtiqueta()
condicion.imprimirEtiquetDestino(arbol, condicion.etiquetaTrue)
# Se traducen todas las instrucciones dentro del if
for i in self.instrucciones:
i.traducir(tabla, arbol)
arbol.addc3d(f"goto .{etiquetaFin}")
condicion.imprimirEtiquetDestino(arbol, condicion.etiquetaFalse)
# Else
# Se traducen todas las instrucciones dentro del else
for i in self.instrucciones_else:
i.traducir(tabla, arbol)
arbol.addc3d(f"label .{etiquetaFin}")
# If ... Elsif
elif len(self.l_if) > 0 and len(self.instrucciones_else) == 0:
if condicion.temporalAnterior == "0":
etiqueta1 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta1}")
condicion.etiquetaTrue = ""
condicion.etiquetaFalse = etiqueta1
elif condicion.temporalAnterior == "1":
etiqueta1 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta1}")
condicion.etiquetaTrue = etiqueta1
condicion.etiquetaFalse = ""
etiquetaFin = tabla.getEtiqueta()
condicion.imprimirEtiquetDestino(arbol, condicion.etiquetaTrue)
# Se traducen todas las instrucciones dentro del if
for i in self.instrucciones:
i.traducir(tabla, arbol)
arbol.addc3d(f"goto .{etiquetaFin}")
condicion.imprimirEtiquetDestino(arbol, condicion.etiquetaFalse)
# Elsif
# Se traducen todas las instrucciones dentro del elsif
etiquetasSalida = []
for elseif in self.l_if:
resultado = elseif.traducir(tabla, arbol)
etiquetasSalida.append(resultado.temporalAnterior)
arbol.addc3d(f"label .{etiquetaFin}")
# Se agregan las etiquetas de salida de los elsif
for etiqueta in etiquetasSalida:
arbol.addc3d(etiqueta)
# If ... Elsif ... Else
elif len(self.l_if) > 0 and len(self.instrucciones_else) > 0:
if condicion.temporalAnterior == "0":
etiqueta1 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta1}")
condicion.etiquetaTrue = ""
condicion.etiquetaFalse = etiqueta1
elif condicion.temporalAnterior == "1":
etiqueta1 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta1}")
condicion.etiquetaTrue = etiqueta1
condicion.etiquetaFalse = ""
etiquetaFin = tabla.getEtiqueta()
condicion.imprimirEtiquetDestino(arbol, condicion.etiquetaTrue)
# Se traducen todas las instrucciones dentro del if
for i in self.instrucciones:
i.traducir(tabla, arbol)
arbol.addc3d(f"goto .{etiquetaFin}")
condicion.imprimirEtiquetDestino(arbol, condicion.etiquetaFalse)
# Elsif
# Se traducen todas las instrucciones dentro del elsif
etiquetasSalida = []
for elseif in self.l_if:
resultado = elseif.traducir(tabla, arbol)
etiquetasSalida.append(resultado.temporalAnterior)
# Else
# Se traducen todas las instrucciones dentro del else
for i in self.instrucciones_else:
i.traducir(tabla, arbol)
arbol.addc3d(f"label .{etiquetaFin}")
# Se agregan las etiquetas de salida de los elsif
for etiqueta in etiquetasSalida:
arbol.addc3d(etiqueta)
return retorno
def analizar(self, tabla, arbol):
super().analizar(tabla, arbol)
retorno = None
resultado = self.condicion.analizar(tabla, arbol)
if not isinstance(resultado, Excepcion):
self.tipo = resultado
tablaLocal = Tabla(tabla)
# If
if len(self.l_if) == 0 and len(self.instrucciones_else) == 0:
for i in self.instrucciones:
r = i.analizar(tablaLocal, arbol)
if isinstance(r, Excepcion):
return None
if isinstance(r, Return):
retorno = r
# If - Else
elif len(self.l_if) == 0 and len(self.instrucciones_else) != 0:
for i in self.instrucciones:
r = i.analizar(tablaLocal, arbol)
if isinstance(r, Excepcion):
return None
if isinstance(r, Return):
retorno = r
for i in self.instrucciones_else:
r = i.analizar(tablaLocal, arbol)
if isinstance(r, Excepcion):
return None
if isinstance(r, Return):
retorno = r
# If ... Elsif
elif len(self.l_if) > 0 and len(self.instrucciones_else) == 0:
for i in self.instrucciones:
r = i.analizar(tablaLocal, arbol)
if isinstance(r, Excepcion):
return None
if isinstance(r, Return):
retorno = r
for elseif in self.l_if:
r = elseif.analizar(tablaLocal, arbol)
if isinstance(r, Excepcion):
return None
if isinstance(r, Return):
retorno = r
# If ... Elsif ... Else
elif len(self.l_if) > 0 and len(self.instrucciones_else) > 0:
for i in self.instrucciones:
r = i.analizar(tablaLocal, arbol)
if isinstance(r, Excepcion):
return None
if isinstance(r, Return):
retorno = r
for elseif in self.l_if:
r = elseif.analizar(tablaLocal, arbol)
if isinstance(r, Excepcion):
return None
if isinstance(r, Return):
retorno = r
for i in self.instrucciones_else:
r = i.analizar(tablaLocal, arbol)
if isinstance(r, Excepcion):
return None
if isinstance(r, Return):
retorno = r
if resultado.tipo != Tipo_Dato.BOOLEAN:
error = Excepcion(
"22023", "Semantico",
"Tipo de datos incorrecto, se esperaba un valor de tipo boolean para la condición.",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return error
return retorno
def traducir(self, tabla:Tabla, arbol:Arbol):
super().traducir(tabla,arbol)
arbol.addc3d("# Inicia Case")
etiquetasSalida = []
for caso in self.lista_case:
if len(caso.expresion2) == 1:
relacional = Relacional(self.expresion1, caso.expresion2[0], "=", "", self.linea, self.columna)
condicion = relacional.traducir(tabla, arbol)
if condicion.temporalAnterior == "0":
etiqueta1 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta1}")
condicion.etiquetaTrue = ""
condicion.etiquetaFalse = etiqueta1
elif condicion.temporalAnterior == "1":
etiqueta1 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta1}")
condicion.etiquetaTrue = etiqueta1
condicion.etiquetaFalse = ""
etiquetaFin = tabla.getEtiqueta()
condicion.imprimirEtiquetDestino(arbol, condicion.etiquetaTrue)
# Se traducen todas las funciones dentro del case
caso.traducir(tabla, arbol)
arbol.addc3d(f"goto .{etiquetaFin}")
condicion.imprimirEtiquetDestino(arbol, condicion.etiquetaFalse)
etiquetasSalida.append(f"label .{etiquetaFin}")
else:
for expre in caso.expresion2:
relacional = Relacional(self.expresion1, expre, "=", "", self.linea, self.columna)
condicion = relacional.traducir(tabla, arbol)
if condicion.temporalAnterior == "0":
etiqueta1 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta1}")
condicion.etiquetaTrue = ""
condicion.etiquetaFalse = etiqueta1
elif condicion.temporalAnterior == "1":
etiqueta1 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta1}")
condicion.etiquetaTrue = etiqueta1
condicion.etiquetaFalse = ""
etiquetaFin = tabla.getEtiqueta()
condicion.imprimirEtiquetDestino(arbol, condicion.etiquetaTrue)
# Se traducen todas las funciones dentro del case
caso.traducir(tabla, arbol)
arbol.addc3d(f"goto .{etiquetaFin}")
condicion.imprimirEtiquetDestino(arbol, condicion.etiquetaFalse)
etiquetasSalida.append(f"label .{etiquetaFin}")
if len(self.instrucciones_else) != 0:
# Se traducen todas las instrucciones dentro del else
for i in self.instrucciones_else:
i.traducir(tabla, arbol)
# Se agregan las etiquetas de salida de los elsif
for etiqueta in etiquetasSalida:
arbol.addc3d(etiqueta)
from goto import with_goto
from Instrucciones.TablaSimbolos.Tabla import Tabla
from Instrucciones.Sql_insert import insertTable
from Instrucciones.TablaSimbolos.Arbol import Arbol
from storageManager.jsonMode import *
import sintactico
tablaGlobal = Tabla(None)
arbol = Arbol()
def call_funcion_intermedia():
dropAll()
input = ""
for i in stack:
input += stack[i] + "\n"
print(input)
inst = sintactico.ejecutar_analisis(input)
arbol = Arbol(inst)
for i in arbol.instrucciones:
resultado = i.ejecutar(tablaGlobal, arbol)
def call_insert_table():
arbolAux = arbol
arbolAux.bdUsar = heap[p - 3]
tabla = insertTable.insertTable(heap[p - 2], None, heap[p - 1], heap[p],
'', 0, 0)
tabla.ejecutar(tablaGlobal, arbolAux)
def btnanalizar_click(self):
global arbol
arbol = None
dropAll()
os.system("cls")
#Elimina el Contenido de txtsalida
self.txtsalida[self.tab.index("current")].delete(1.0, END)
#Inserta "Archivo Analizado" en txtsalida
#self.txtsalida[self.tab.index("current")].insert(INSERT,"Archivo Analizado")
#Selecciona el contenido de txt entrada
#print(self.txtentrada[self.tab.index("current")].get(1.0,END))
input = self.txtentrada[self.tab.index("current")].get(1.0, END)
tablaGlobal = Tabla(None)
inst = sintactico.ejecutar_analisis(input)
arbol = Arbol(inst)
if len(sintactico.lista_lexicos) > 0:
messagebox.showerror('Tabla de Errores',
'La Entrada Contiene Errores!')
reportes.RealizarReportes.RealizarReportes.generar_reporte_lexicos(
sintactico.lista_lexicos)
# Ciclo que recorrerá todas las instrucciones almacenadas por la gramática.
arbol.lRepDin.append("<init> ::= <instrucciones>")
arbol.lRepDin.append(
"<instrucciones> ::= <instrucciones> <instruccion>")
arbol.lRepDin.append("<instrucciones> ::= <instruccion>")
'''
for i in arbol.instrucciones:
# La variable resultado nos permitirá saber si viene un return, break o continue fuera de sus entornos.
resultado = i.ejecutar(tablaGlobal,arbol)
# Después de haber ejecutado todas las instrucciones se verifica que no hayan errores semánticos.
if len(arbol.excepciones) != 0:
reportes.RealizarReportes.RealizarReportes.generar_reporte_lexicos(arbol.excepciones)
# Ciclo que imprimirá todos los mensajes guardados en la variable consola.
mensaje = ''
for m in arbol.consola:
mensaje += m + '\n'
self.txtsalida[self.tab.index("current")].insert(INSERT,mensaje)
'''
# Buscar funciones
for i in arbol.instrucciones:
if isinstance(i, Func):
i.llenarTS(tablaGlobal, arbol)
for i in arbol.instrucciones:
# La variable resultado nos permitirá saber si viene un return, break o continue fuera de sus entornos.
resultado = i.analizar(tablaGlobal, arbol)
# Ciclo que imprimirá todos los mensajes guardados en la variable consola.
mensaje = ''
for m in arbol.consola:
mensaje += m + '\n'
self.txtsalida[self.tab.index("current")].insert(INSERT, mensaje)
# Después de haber ejecutado todas las instrucciones se verifica que no hayan errores semánticos.
if len(arbol.excepciones) != 0:
reportes.RealizarReportes.RealizarReportes.generar_reporte_lexicos(
arbol.excepciones)
else:
c3d = 'from goto import with_goto\n'
c3d += 'from sintactico import *\n'
c3d += 'from Instrucciones.TablaSimbolos.Tabla import Tabla\n'
c3d += 'from Instrucciones.TablaSimbolos.Arbol import Arbol\n'
c3d += 'import sys\n'
c3d += 'global P\n'
c3d += 'global Pila\n'
c3d += 'P = 0\n'
c3d += 'Pila = [None] * 1000\n'
c3d += 'tablaGlobal = Tabla(None)\n'
c3d += 'global sql\n'
c3d += 'global inst\n'
c3d += 'global arbol\n'
c3d += self.funcionintermedia()
c3d += '@with_goto # Decorador necesario.\n'
# Agregamos las funciones al reporte
for i in tablaGlobal.variables:
tablaGlobal.agregarReporteSimbolo(i)
# Se traducen las funciones
for i in arbol.instrucciones:
if isinstance(i, Func):
i.traducir(tablaGlobal, arbol)
c3d += arbol.cadena
c3d += 'def main():\n'
c3d += '\tglobal P\n'
c3d += '\tglobal Pila\n'
# Se traducen el resto de las demás sentencias
arbol.cadena = ""
for i in arbol.instrucciones:
if not isinstance(i, Func):
i.traducir(tablaGlobal, arbol)
c3d += arbol.cadena
c3d += 'if __name__ == \"__main__\":\n'
c3d += '\tmain()'
archivo = open("prueba.py", "w", encoding='utf-8')
archivo.write(c3d)
archivo.close()
self.txtsalida[self.tab.index("current")].insert(INSERT, c3d)
def btngetCodigo_click(self):
global arbol
arbol = None
dropAll()
os.system ("cls")
self.txtsalida[self.tab.index("current")].delete(1.0,END)
input=self.txtentrada[self.tab.index("current")].get(1.0,END)
tablaGlobal = Tabla(None)
inst = sintactico.ejecutar_analisis(input)
arbol = Arbol(inst)
if len(sintactico.lista_lexicos)>0:
messagebox.showerror('Tabla de Errores','La Entrada Contiene Errores!')
reportes.RealizarReportes.RealizarReportes.generar_reporte_lexicos(sintactico.lista_lexicos)
#PRIMERA PASADA: Para almacenar las funciones, procedimientos y variables
for i in arbol.instrucciones:
scope = 'Global'
if isinstance(i, Proc):
rol = 'Función' if i.ret else 'Procedimiento'
symbol = {'name': i.name, 'type': '--', 'scope': scope, 'rol': rol, 'pointer': '--'}
arbol.addSymbol(i.name, symbol)
scope = i.name
pointer = 0
if i.ret:
symbol = {'name': 'return', 'type': '--', 'scope': scope, 'rol': 'Variable Local', 'pointer': str(pointer)}
arbol.addSymbol('return', symbol)
pointer += 1
for param in i.params:
symbol = {'name': param[0], 'type': param[1].toString(), 'scope': scope, 'rol': 'Variable Local', 'pointer': str(pointer)}
arbol.addSymbol(param[0], symbol)
pointer += 1
for inst in i.block.instructions:
if isinstance(inst, Statement):
dec = inst.dec
symbol = {'name': dec[0], 'type': dec[1].toString(), 'scope': scope, 'rol': 'Variable Local', 'pointer': str(pointer)}
arbol.addSymbol(dec[0], symbol)
pointer += 1
# Después de haber ejecutado todas las instrucciones se verifica que no hayan errores semáretunticos.
if len(arbol.excepciones) != 0:
reportes.RealizarReportes.RealizarReportes.generar_reporte_lexicos(arbol.excepciones)
else:
mensaje = f"from goto import with_goto\n\n"
mensaje += f"from Instrucciones.TablaSimbolos.Tabla import Tabla\n"
mensaje += f"from Instrucciones.TablaSimbolos.Arbol import Arbol\n"
mensaje += f"\n"
mensaje += f"import sintactico\n"
mensaje += f"from Instrucciones.Sql_create.CreateDatabase import CreateDatabase\n"
mensaje += f"from Instrucciones.Sql_create.ShowDatabases import ShowDatabases\n"
mensaje += f"from Instrucciones.Sql_create.Use import Use\n"
mensaje += f"from Instrucciones.Sql_create.CreateTable import CreateTable\n"
mensaje += f"from Instrucciones.Sql_alter.AlterDatabase import AlterDatabase\n"
mensaje += f"from Instrucciones.Sql_alter.AlterDBOwner import AlterDBOwner\n"
mensaje += f"from Instrucciones.Sql_drop.DropDatabase import DropDatabase\n"
mensaje += f"from Instrucciones.Sql_drop.DropTable import DropTable\n"
mensaje += f"from Instrucciones.Sql_select.Select import Select\n"
mensaje += f"from Instrucciones.Sql_insert import insertTable\n"
mensaje += f"from Instrucciones.Expresiones.Primitivo import Primitivo\n"
mensaje += f"from Instrucciones.TablaSimbolos.Tipo import Tipo\n"
mensaje += f"from Instrucciones.TablaSimbolos.Tipo import Tipo_Dato\n"
mensaje += f"from Instrucciones.FunctionMathematical.Trunc import Trunc\n"
mensaje += f"from Instrucciones.FunctionMathematical.Abs import Abs\n"
mensaje += f"from Instrucciones.FunctionMathematical.Sqrt import Sqrt\n"
mensaje += f"from Instrucciones.FunctionTrigonometric.Sin import Sin\n"
mensaje += f"from Instrucciones.FunctionTrigonometric.Sinh import Sinh\n"
mensaje += f"from Instrucciones.FunctionTrigonometric.Acosd import Acosd\n"
mensaje += f"from Instrucciones.FunctionBinaryString.Length import Length\n"
mensaje += f"from Instrucciones.FunctionBinaryString.Substring import Substring\n"
mensaje += f"\n"
mensaje += f"global pointer\n"
mensaje += f"global stack\n"
mensaje += f"global table\n"
mensaje += f"global tree\n"
mensaje += f"\n"
mensaje += f"pointer = 0\n"
mensaje += f"stack = [None] * 10000\n"
mensaje += f"table = Tabla(None)\n"
mensaje += f"tree = Arbol(None)\n\n"
for i in arbol.instrucciones:
if isinstance(i, Proc):
mensaje += i.getCodigo(tablaGlobal,arbol)
mensaje += self.getFuncionIntermedia(arbol)
mensaje += f"@with_goto\n"
mensaje += f"def main():\n"
mensaje += f"\tglobal pointer\n"
mensaje += f"\tglobal stack\n"
for i in arbol.instrucciones:
if not isinstance(i, Proc):
if isinstance(i, Call):
result = i.getCodigo(tablaGlobal,arbol)
mensaje += result['codigo']
else:
mensaje += i.getCodigo(tablaGlobal,arbol)
mensaje += f"\n"
mensaje += f"\n"
mensaje += f"main()\n"
self.txtsalida[self.tab.index("current")].insert(INSERT,mensaje)
file = open("traducido.py", "w")
file.write(mensaje)
file.close()
def btngetCodigo_click(self):
global arbol
arbol = None
dropAll()
os.system ("cls")
self.txtsalida[self.tab.index("current")].delete(1.0,END)
input=self.txtentrada[self.tab.index("current")].get(1.0,END)
tablaGlobal = Tabla(None)
inst = sintactico.ejecutar_analisis(input)
arbol = Arbol(inst)
if len(sintactico.lista_lexicos)>0:
messagebox.showerror('Tabla de Errores','La Entrada Contiene Errores!')
reportes.RealizarReportes.RealizarReportes.generar_reporte_lexicos(sintactico.lista_lexicos)
for i in arbol.instrucciones:
resultado = i.getCodigo(tablaGlobal,arbol)
# Después de haber ejecutado todas las instrucciones se verifica que no hayan errores semáretunticos.
if len(arbol.excepciones) != 0:
reportes.RealizarReportes.RealizarReportes.generar_reporte_lexicos(arbol.excepciones)
else:
mensaje = f"from goto import with_goto\n\n"
mensaje += f"from Instrucciones.TablaSimbolos.Tabla import Tabla\n"
mensaje += f"from Instrucciones.TablaSimbolos.Arbol import Arbol\n"
mensaje += f"\n"
mensaje += f"import sintactico\n"
mensaje += f"from Instrucciones.Sql_create.CreateDatabase import CreateDatabase\n"
mensaje += f"from Instrucciones.Sql_create.ShowDatabases import ShowDatabases\n"
mensaje += f"from Instrucciones.Sql_create.Use import Use\n"
mensaje += f"from Instrucciones.Sql_create.CreateTable import CreateTable\n"
mensaje += f"from Instrucciones.Sql_alter.AlterDatabase import AlterDatabase\n"
mensaje += f"from Instrucciones.Sql_alter.AlterDBOwner import AlterDBOwner\n"
mensaje += f"from Instrucciones.Sql_drop.DropDatabase import DropDatabase\n"
mensaje += f"from Instrucciones.Sql_drop.DropTable import DropTable\n"
mensaje += f"from Instrucciones.Sql_select.Select import Select\n"
mensaje += f"from Instrucciones.Sql_insert import insertTable\n"
mensaje += f"\n"
mensaje += f"global pointer\n"
mensaje += f"global stack\n"
mensaje += f"global table\n"
mensaje += f"global tree\n"
mensaje += f"\n"
mensaje += f"pointer = 0\n"
mensaje += f"stack = [None] * 10000\n"
mensaje += f"table = Tabla(None)\n"
mensaje += f"tree = Arbol(None)\n\n"
mensaje += self.getFuncionIntermedia(arbol)
mensaje += f"@with_goto\n"
mensaje += f"def main():\n"
mensaje += f"\tglobal pointer\n"
mensaje += f"\tglobal stack\n"
for m in arbol.consola:
mensaje += m + '\n'
self.txtsalida[self.tab.index("current")].insert(INSERT,mensaje)
mensaje += f"if __name__ == \"__main__\":\n"
mensaje += f"\tmain()\n"
file = open("traducido.py", "w")
file.write(mensaje)
file.close()
def traducir(self, tabla: Tabla, arbol: Arbol):
super().traducir(tabla,arbol)
retorno = Nodo3D()
resultadoIzq = self.opIzq.traducir(tabla,arbol)
if self.operador == 'AND':
if isinstance(resultadoIzq, str):
cadena = f"{resultadoIzq} AND "
if isinstance(self.opDer, str):
cadena += self.opDer + " "
else:
cadena += self.opDer.traducir(tabla,arbol)
return cadena
if resultadoIzq.temporalAnterior == "0":
etiqueta1 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta1}")
resultadoDer = self.opDer.traducir(tabla,arbol)
if resultadoDer.temporalAnterior == "0":
# False and False
etiqueta2 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta2}")
retorno.etiquetaTrue = ''
retorno.etiquetaFalse = f"{etiqueta1},{etiqueta2}"
elif resultadoDer.temporalAnterior == "1":
# False and True
etiqueta2 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta2}")
arbol.addc3d(f"label .{etiqueta2}")
retorno.etiquetaTrue = ""
retorno.etiquetaFalse = f"{etiqueta1}"
else:
# False and Operación Relacional
retorno.etiquetaTrue = resultadoDer.etiquetaTrue
retorno.etiquetaFalse = f"{etiqueta1},{resultadoDer.etiquetaFalse}"
return retorno
elif resultadoIzq.temporalAnterior == "1":
etiqueta1 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta1}")
arbol.addc3d(f"label .{etiqueta1}")
resultadoDer = self.opDer.traducir(tabla,arbol)
if resultadoDer.temporalAnterior == "0":
# True and False
etiqueta2 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta2}")
retorno.etiquetaTrue = ''
retorno.etiquetaFalse = f"{etiqueta2}"
elif resultadoDer.temporalAnterior == "1":
# True and True
etiqueta2 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta2}")
retorno.etiquetaTrue = f"{etiqueta2}"
retorno.etiquetaFalse = ""
else:
# True and Operación Relacional
retorno.etiquetaTrue = resultadoDer.etiquetaTrue
retorno.etiquetaFalse = resultadoDer.etiquetaFalse
return retorno
retorno.imprimirEtiquetDestino(arbol, resultadoIzq.etiquetaTrue)
resultadoDer = self.opDer.traducir(tabla, arbol)
if resultadoDer.temporalAnterior == "0":
# Operación Relacional and False
etiqueta1 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta1}")
retorno.etiquetaTrue = ''
retorno.etiquetaFalse = f"{resultadoIzq.etiquetaFalse},{etiqueta1}"
return retorno
elif resultadoDer.temporalAnterior == "1":
# Operación Relacional and True
etiqueta1 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta1}")
retorno.etiquetaTrue = f"{etiqueta1}"
retorno.etiquetaFalse = f"{resultadoIzq.etiquetaFalse}"
return retorno
# Operación Relacional and Operación Relacional
retorno.etiquetaTrue = resultadoDer.etiquetaTrue
retorno.etiquetaFalse = f"{resultadoIzq.etiquetaFalse},{resultadoDer.etiquetaFalse}"
return retorno
elif self.operador == 'OR':
if resultadoIzq.temporalAnterior == "0":
etiqueta1 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta1}")
arbol.addc3d(f"label .{etiqueta1}")
resultadoDer = self.opDer.traducir(tabla,arbol)
if resultadoDer.temporalAnterior == "0":
# False or False
etiqueta2 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta2}")
retorno.etiquetaTrue = ""
retorno.etiquetaFalse = etiqueta2
elif resultadoDer.temporalAnterior == "1":
# False or True
etiqueta2 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta2}")
retorno.etiquetaTrue = etiqueta2
retorno.etiquetaFalse = ""
else:
# False or Operación Relacional
retorno.etiquetaTrue = resultadoDer.etiquetaTrue
retorno.etiquetaFalse = resultadoDer.etiquetaFalse
return retorno
elif resultadoIzq.temporalAnterior == "1":
etiqueta1 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta1}")
resultadoDer = self.opDer.traducir(tabla, arbol)
if resultadoDer.temporalAnterior == "0":
# True or False
etiqueta2 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta2}")
retorno.etiquetaTrue = etiqueta1
retorno.etiquetaFalse = etiqueta2
elif resultadoDer.temporalAnterior == "1":
# True or True
etiqueta2 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta2}")
retorno.etiquetaTrue = f"{etiqueta1},{etiqueta2}"
retorno.etiquetaFalse = ""
else:
# True or Operación Relacional
retorno.etiquetaTrue = f"{etiqueta1},{resultadoDer.etiquetaTrue}"
retorno.etiquetaFalse = resultadoDer.etiquetaFalse
return retorno
retorno.imprimirEtiquetDestino(arbol, resultadoIzq.etiquetaFalse)
resultadoDer = self.opDer.traducir(tabla, arbol)
if resultadoDer.temporalAnterior == "0":
# Operación Relacional or False
etiqueta1 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta1}")
retorno.etiquetaTrue = resultadoIzq.etiquetaTrue
retorno.etiquetaFalse = etiqueta1
return retorno
elif resultadoDer.temporalAnterior == "1":
# Operación Relacional or True
etiqueta1 = tabla.getEtiqueta()
arbol.addc3d(f"goto .{etiqueta1}")
retorno.etiquetaTrue = f"{resultadoIzq.etiquetaTrue},{etiqueta1}"
retorno.etiquetaFalse = ""
return retorno
# Operación Relacional or Operación Relacional
retorno.etiquetaTrue = f"{resultadoIzq.etiquetaTrue},{resultadoDer.etiquetaTrue}"
retorno.etiquetaFalse = resultadoDer.etiquetaFalse
return retorno
elif self.operador == 'NOT':
if resultadoIzq.temporalAnterior == "0":
# False
retorno.temporalAnterior = "1"
elif resultadoIzq.temporalAnterior == "1":
# True
retorno.temporalAnterior = "0"
else:
# Operación Relacional
retorno.etiquetaTrue = resultadoIzq.etiquetaFalse
retorno.etiquetaFalse = resultadoIzq.etiquetaTrue
return retorno
def btnanalizar_click(self):
self.start()
self.primerapasada()
# if(1==1):
#return
global arbol
arbol = None
dropAll()
os.system("cls")
#Elimina el Contenido de txtsalida
self.txtsalida[self.tab.index("current")].delete(1.0, END)
#Inserta "Archivo Analizado" en txtsalida
#self.txtsalida[self.tab.index("current")].insert(INSERT,"Archivo Analizado")
#Selecciona el contenido de txt entrada
#print(self.txtentrada[self.tab.index("current")].get(1.0,END))
input = self.txtentrada[self.tab.index("current")].get(1.0, END)
tablaGlobal = Tabla(None)
inst = sintactico.ejecutar_analisis(input)
arbol = Arbol(inst)
if len(sintactico.lista_lexicos) > 0:
messagebox.showerror('Tabla de Errores',
'La Entrada Contiene Errores!')
reportes.RealizarReportes.RealizarReportes.generar_reporte_lexicos(
sintactico.lista_lexicos)
# Ciclo que recorrerá todas las instrucciones almacenadas por la gramática.
arbol.lRepDin.append("<init> ::= <instrucciones>")
arbol.lRepDin.append(
"<instrucciones> ::= <instrucciones> <instruccion>")
arbol.lRepDin.append("<instrucciones> ::= <instruccion>")
for i in arbol.instrucciones:
# La variable resultado nos permitirá saber si viene un return, break o continue fuera de sus entornos.
print("analizara")
print(i)
try:
print("al")
resultado = i.analizar(tablaGlobal, arbol)
print("alj")
except:
print("ara")
pass
self.tablageneral = tablaGlobal
# Ciclo que imprimirá todos los mensajes guardados en la variable consola.
mensaje = ''
for m in arbol.consola:
mensaje += m + '\n'
self.txtsalida[self.tab.index("current")].insert(INSERT, mensaje)
# Después de haber ejecutado todas las instrucciones se verifica que no hayan errores semánticos.
if len(arbol.excepciones) != 0:
reportes.RealizarReportes.RealizarReportes.generar_reporte_lexicos(
arbol.excepciones)
else:
for i in arbol.instrucciones:
try:
i.traducir(tablaGlobal, arbol)
except:
pass
# c3d = 'from goto import with_goto\n'
c3d = 'import sys\n'
# c3d = 'from goto import with_goto\n'
c3d += 'global P\n'
c3d += 'global Pila\n'
c3d += 'P = 0\n'
c3d += 'Pila = [None] * 1000\n'
c3d += self.funcionintermedia()
# c3d += '@with_goto \n'
c3d += arbol.cadenaf
c3d += 'def main():\n'
c3d += '\tglobal P\n'
c3d += '\tglobal Pila\n'
c3d += arbol.cadena
print("arbol.cadena es " + arbol.cadena)
c3d += 'if __name__ == \"__main__\":\n'
c3d += '\tstart()\n'
c3d += '\tmain()\n'
archivo = open("codigo3d.py", "w")
archivo.write(c3d)
archivo.close()
self.txtsalida[self.tab.index("current")].insert(INSERT, c3d)
def ejecutar(self, tabla, arbol):
super().ejecutar(tabla, arbol)
# Ambito para la tabla
tablaLocal = Tabla(tabla)
#SE VALIDA QUE SE HAYA SELECCIONADO UN BD
if arbol.bdUsar != None:
#SE VALIDA SI LA TABLA VA HEREDAR
if self.herencia != None:
#SE BUSCA LA SI LA TABLA HEREDADA EXISTE
htabla = arbol.devolverBaseDeDatos().getTabla(self.herencia)
if htabla != None:
tabla_temp = []
#SE RECORRE TODOS LAS COLUMNAS DE LA TABLA PARA UNIR CAMPOS REPETIDOS
for campo_her in htabla.lista_de_campos:
indice = 0
bandera_campo = True
for campo_nuevo in self.campos:
if campo_her.nombre == campo_nuevo.nombre:
tabla_temp.append(campo_nuevo)
arbol.consola.append(
f"NOTICE: mezclando la columna <<{campo_nuevo.nombre}>> con la definición heredada."
)
self.campos.pop(indice)
indice += 1
bandera_campo = False
break
if bandera_campo:
tabla_temp.append(campo_her)
tabla_temp = tabla_temp + self.campos
self.campos = tabla_temp
else:
error = Excepcion(
f"42P01", "Semantico",
"No existe la relación <<{self.herencia}>>.",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
return
#SE CREA UN AMBITO PARA LA TABLA
tablaNueva = Tablas(self.tabla, None)
#SE LLENA LA TABLA EN MEMORIA
for camp in self.campos:
if isinstance(camp.tipo, Tipo):
if camp.constraint != None:
for s in camp.constraint:
if s.tipo == Tipo_Dato_Constraint.CHECK:
objeto = Declaracion(camp.nombre, camp.tipo,
s.expresion)
checkBueno = objeto.ejecutar(tablaLocal, arbol)
if not isinstance(checkBueno, Excepcion):
#tablaNueva.agregarColumna(camp.nombre,camp.tipo.toString(),None, camp.constraint)
#continue
pass
else:
#arbol.consola.append(checkBueno.toString())
return
tablaNueva.agregarColumna(camp.nombre,
camp.tipo.toString(), None,
camp.constraint)
else:
tablaNueva.agregarColumna(camp.nombre, camp.tipo, None,
camp.constraint)
#SE CREA LA TABLA EN DISCO
ctable = createTable(arbol.bdUsar, self.tabla, len(self.campos))
if ctable == 0: #CUANDO LA TABLA SE CREA CORRECTAMENTE
arbol.consola.append(
f"La Tabla: <<{self.tabla}>> se creo correctamente.")
arbol.agregarTablaABd(tablaNueva)
elif ctable == 3: #CUANDO LA TABLA YA EXISTE
error = Excepcion("100", "Semantico", "La Tabla ya Existe.",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
elif ctable == 2: #CUANDO POR ALGUN ERROR NO SE CREA LA TABLA.
error = Excepcion("100", "Semantico", "Error Interno.",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
else:
error = Excepcion("100", "Semantico",
"No ha seleccionado ninguna Base de Datos.",
self.linea, self.columna)
arbol.excepciones.append(error)
arbol.consola.append(error.toString())
