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 ejecutar3D():
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_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 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 funcionintermedia():
global P
global Pila
t0 = P+0
t1 = t0+1
t2 = Pila[t1]
print(t2)
sql = Pila[t1]
inst = ejecutar_analisis(sql)
arbol = Arbol(inst)
for instruccion in arbol.instrucciones:
instruccion.ejecutar(tablaGlobal,arbol)
for msj in arbol.consola:
print(f"{msj}")
def btnanalizar3D_click(self):
global arbol
input = self.txtentrada[self.tab.index("current")].get(1.0, END)
inst = sintactico3D.ejecutar_analisis(input)
if len(sintactico3D.lista_lexicos) > 0:
messagebox.showerror('Tabla de Errores',
'La Entrada Contiene Errores!')
reportes.RealizarReportes.RealizarReportes.generar_reporte_lexicos(
sintactico3D.lista_lexicos)
arbol = Arbol(inst)
ast = Ast(inst, arbol)
mensaje = ast.optimizar()
file = open("optimizado.py", "w")
file.write(mensaje)
file.close()
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 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)
import sintactico
import reportes.RealizarReportes
import reportes.reportesimbolos as rs
import reportes.RealizarGramatica
from Instrucciones.TablaSimbolos.Tabla import Tabla
from Instrucciones.TablaSimbolos.Arbol import Arbol
from Instrucciones.Excepcion import Excepcion
from Instrucciones.Sql_create.CreateDatabase import CreateDatabase
from Instrucciones.Tablas.BaseDeDatos import BaseDeDatos
global arbol
arbol = Arbol(None)
global tablaGlobal
tablaGlobal = Tabla(None)
global valores
valores = []
class FuncionesPara3D():
def GenerarArchivo(codigo):
nombre_archivo = "Codigo_3D/Codigo3D.py"
#Se borra el contenido del archivo
f = open(nombre_archivo, "w")
f.write("")
f.close()
f = open(nombre_archivo, "a+")
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 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()
from Instrucciones.TablaSimbolos.Instruccion import Instruccion
from Instrucciones.TablaSimbolos.Arbol import Arbol
from Instrucciones.Tablas.BaseDeDatos import BaseDeDatos
from Instrucciones.Tablas.Tablas import Tablas
from Instrucciones.TablaSimbolos.Tipo import *
from storageManager.jsonMode import *
a = Arbol([])
#create base
nueva = BaseDeDatos("Shingeki")
a.setListaBd(nueva)
nueva2 = BaseDeDatos("Shokugeki")
a.setListaBd(nueva2)
#use
a.setBaseDatos("Shingeki")
#create tabla
tablaNueva = Tablas("temporada 1", None)
tablaNueva2 = Tablas("temporada 2", None)
tablaNueva3 = Tablas("temporada 3", None)
a.agregarTablaABd(tablaNueva)
a.agregarTablaABd(tablaNueva2)
a.agregarTablaABd(tablaNueva3)
tablaNueva.agregarColumna("capitulo1", Tipo("", Tipo_Dato.INTEGER), None)
tablaNueva.agregarColumna("capitulo2", Tipo("", Tipo_Dato.INTEGER), None)
tablaNueva.agregarColumna("capitulo3", Tipo("", Tipo_Dato.INTEGER), None)
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)
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)