def CrearTablaSimbolos(ListaIdentificadores,tipoRobot,instrucciones):
'''
* Descripción de la función: Dada una lista de identificadores y un
tipo crea una tabla de símbolos y a su vez va chequeando si
existe una redeclaración.
* Variables de entrada:
- ListaIdentificadores: Lista enlazada de identificadores.
- tipoRobot: Tipo de los valores que almacenarán los
identificadores.
* Variables de salida:
- Ninguno.
'''
global Ultimo
aux = ListaIdentificadores
Tabla = TablaSimbolos(Ultimo)
Tabla.instrucciones = instrucciones
Ultimo = Tabla
while (aux != None) :
redeclaracion, tablaEncontrada = Tabla.buscar(aux.value)
if (redeclaracion != None):
print("Error en la línea",aux.numeroLinea,
": Redeclaración de la variable","\'"+str(aux.value)+"\'.")
sys.exit()
else:
Tabla.insertar(aux.value,tipoRobot,"robot")
aux = aux.sig
# Se inserta 'me' en la tabla:
Tabla.insertar("me",tipoRobot)
def do_create_database(self, p_inst, p_st, p_es):
key = 'CBD_' + p_inst.idData
simbolo = st.Symbol(key, p_inst.idData, 'create', '', '', '')
existe = p_st.get(key)
if existe and p_inst.Replace:
p_st.add(simbolo)
elif existe and p_inst.IfNot:
p_st.add(simbolo)
elif not existe:
p_st.add(simbolo)
def EjecutarASC(input):
instrucciones = g.parse(input)
global ts_global
ts_global = TS.TablaDeSimbolos()
if instrucciones is None:
print('Unnable to Compile. Please Check the Code')
else:
grafo = Graficadora()
grafo.Recorrer_Instrucciones_Inicio(instrucciones)
Recorrer_Instrucciones(instrucciones, ts_global)
def do_use(self, p_inst, p_st, p_es):
sKey = 'CBD_' + p_inst.nombre
existe = p_st.get(sKey)
if existe:
simbolo = st.Symbol('UDB_' + p_inst.nombre, p_inst.nombre, 'use', '','')
p_st.add(simbolo)
self.new_output("SE USARÁ LA BASE DE DATOS \'" + p_inst.nombre + "\'")
self.use_db = p_inst.nombre
else:
error = es.errorSemantico('UDB_' + p_inst.nombre, 'La base de datos ' + p_inst.nombre + ' no existe')
p_es.agregar(error)
self.new_output(error.tipo)
def DebuggerIniciar(input):
global Terminar
Terminar = False
global instrdebug
instrdebug = g.parse(input)
global ts_global
Globales.debug = 0
ts_global = TS.TablaDeSimbolos()
if instrdebug is None:
print('Unnable to Compile. Please Check the Code')
else:
accion_LlenarTsEtiquetas(
instrdebug, ts_global) # tengo que llenar al iniciar mis etiquetas
def do_use(self, p_inst, p_st, p_es):
print('USAR BASE DE DATOS')
sKey = 'CBD_' + p_inst.nombre
existe = p_st.get(sKey)
if existe:
simbolo = st.Symbol('UDB_' + p_inst.nombre, p_inst.nombre, 'use',
'')
p_st.add(simbolo)
else:
error = es.errorSemantico(
'UDB_' + p_inst.nombre,
'La base de datos ' + p_inst.nombre + ' no existe')
p_es.agregar(error)
def do_drop_db(self, p_inst, p_st, p_es):
sKey = 'CBD_' + p_inst.nombre
existe = p_st.get(sKey)
if existe:
simbolo = st.Symbol('DDB_' + p_inst.nombre, p_inst.nombre, 'drop',
'')
p_st.add(simbolo)
dropDatabase(p_inst.nombre)
elif not existe and not p_inst.exist:
error = es.errorSemantico(
'DDB_' + p_inst.nombre,
'La base de datos ' + p_inst.nombre + ' no existe')
p_es.agregar(error)
def AlterTableUnique(nodo, tablaSimbolos):
global consola
global useActual
base = tablaSimbolos.get(useActual)
tabla = base.getTabla(nodo.idtabla)
if tabla.modificarUnique(nodo.idcolumna, True, nodo.idconstraint):
listaConstraint.append(
TS.Constraints(useActual, nodo.idtabla, nodo.idconstraint,
nodo.idcolumna, "unique"))
consola += "Se agrego el unique a la columna " + nodo.idcolumna + " exitosamente \n"
else:
listaSemanticos.append(
Error.ErrorS("Error Semantico",
"No se encontró la columna con id " + nodo.idcolumna))
def do_alter_db(self, p_inst, p_st, p_es):
key = 'CBD_' + p_inst.nombreDB
existe = p_st.get(key)
if existe:
newDB = p_inst.operacion.cadena
key = 'ADB_' + p_inst.nombreDB
simbolo = st.Symbol(key, p_inst.nombreDB, 'Alter database', newDB,'','')
p_st.add(simbolo)
alterDatabase(p_inst.nombreDB, newDB)
else:
error = es.errorSemantico('ADB_' + p_inst.nombreDB, 'La base de datos ' + p_inst.nombreDB + ' no existe')
p_es.agregar(error)
print('a')
def tytus_ejecutar(self):
global GC3D
# Getting widget
index = self.ta_input.index(self.ta_input.select())
ta_input = self.array_tabs[index]
# Delete old lexical report
if os.path.exists("reports/error_lexical.txt"):
os.remove("reports/error_lexical.txt")
# Delete old syntactic report
if os.path.exists("reports/error_syntactic.txt"):
os.remove("reports/error_syntactic.txt")
# Delete old semantic report
if os.path.exists("reports/error_semantic.txt"):
os.remove("reports/error_semantic.txt")
if ta_input.compare("end-1c", "!=", "1.0"):
# Gets new input
tytus = ta_input.get(1.0, END)
# Start parser
ins = g.parse(tytus)
#g.gramaticaBNF(tytus)
#Contador de temporales utilizados
temp = g.contador
gen = Generador(temp, 0, ins.getInstruccion())
gen.ejecutar()
GC3D = gen.codigo3d
#reporteOptimizacion(reglasOpt)
C3D = g.codigo_3D
crearArchivo(C3D, gen.codigo3d)
st_global = st.SymbolTable()
es_global = es.ListaErroresSemanticos()
ct_global = ct.crearTabla()
if not ins:
messagebox.showerror(
"ERROR", "Ha ocurrido un error. Verificar reportes.")
else:
self.do_body(ins.getInstruccion(), st_global, es_global,
ct_global)
self.raiz_ast = ins.getNodo()
self.new_output(
"--- SE HA GENERADO EL ARCHIVO ÉXITOSAMENTE ---")
else:
messagebox.showerror("INFO", "El campo de entrada esta vacío.")
def do_index(self, p_inst, p_st, p_es):
key = 'CI_' + p_inst.name
existe = p_st.get(key)
ckey = 'CTB_' + p_inst.table + '_'
existet = p_st.get(ckey)
if existe == False and existet != False:
if isinstance(p_inst, Index):
if p_inst.Unique == True:
simbolo = st.Symbol(
key, p_inst.name, 'INDEX', p_inst.Lindex,
'Se utiliza tabla: ' + p_inst.table + '<br>' +
'Index tipo: ' + 'Unique', '')
elif p_inst.Using == True:
simbolo = st.Symbol(
key, p_inst.name, 'INDEX', p_inst.Lindex,
'Se utiliza tabla: ' + p_inst.table + '<br>' +
'Metodo: ' + 'Using Hash', '')
else:
simbolo = st.Symbol(
key, p_inst.name, 'INDEX', p_inst.Lindex,
'Se utiliza tabla: ' + p_inst.table + '<br>', '')
elif isinstance(p_inst, IndexW):
simbolo = st.Symbol(
key, p_inst.name, 'INDEX', p_inst.Lindex,
'Se utiliza tabla: ' + p_inst.table + '<br>', '')
elif isinstance(p_inst, IndexMM):
simbolo = st.Symbol(
key, p_inst.name, 'INDEX',
str(p_inst.major) + ',' + str(p_inst.minor),
'Se utiliza tabla: ' + p_inst.table + '<br>', '')
elif isinstance(p_inst, IndexOrden):
if p_inst.Orden == 'ANF':
p_inst.Orden = 'ASC NULLS FIRST'
elif p_inst.Orden == 'ANL':
p_inst.Orden = 'ASC NULLS LAST'
elif p_inst.Orden == 'DNF':
p_inst.Orden = 'DESC NULLS FIRST'
elif p_inst.Orden == 'DNL':
p_inst.Orden = 'DESC NULLS LAST'
elif p_inst.Orden == 'NF':
p_inst.Orden = 'NULLS FIRST'
elif p_inst.Orden == 'NL':
p_inst.Orden = 'NULLS LAST'
simbolo = st.Symbol(
key, p_inst.name, 'INDEX', p_inst.valor,
'Se utiliza tabla: ' + p_inst.table + '<br>' + 'Orden: ' +
p_inst.Orden, '')
if existe == False:
p_st.add(simbolo)
self.new_output("SE CREO CON EXITO EL INDICE:" + p_inst.name)
else:
self.new_output("EL INDICE QUE SE DESEA AGREGAR YA EXISTE")
def do_drop_db(self, p_inst, p_st, p_es):
sKey = 'CBD_' + p_inst.nombre
existe = p_st.get(sKey)
if existe:
simbolo = st.Symbol('DDB_' + p_inst.nombre, p_inst.nombre, 'drop',
'')
p_st.add(simbolo)
dropDatabase(p_inst.nombre)
self.new_output("BASE DE DATOS \'" + p_inst.nombre +
"\' HA SIDO ELIMINADA EXITOSAMENTE.")
elif not existe and not p_inst.exist:
error = es.errorSemantico(
'DDB_' + p_inst.nombre,
'La base de datos ' + p_inst.nombre + ' no existe')
p_es.agregar(error)
self.new_output(error.tipo)
def __funcion_analizar():
g.errores_lexicos.clear()
g.errores_sintacticos.clear()
tablaSimbolos = TS.Entorno(None)
entrada = my_editor.text.get('1.0', END)
arbol = g.parse(entrada)
if len(g.errores_lexicos) == 0:
if len(g.errores_sintacticos) == 0:
# raiz = graficando.analizador(entrada)
data=principal.interpretar_sentencias(arbol,tablaSimbolos)
tablaSimbolos.mostrar()
imprimir_consola(data)
# GraficarAST(raiz)
else:
imprimir_consola('Se detectaron algunos errores sintácticos')
append_consola('')
append_consola('No. \t Lexema \t Tipo \t\t Fila \t Columna \t Descripción ')
i = 0
while i < len(g.errores_sintacticos):
append_consola( str(i) + ' \t ' + str(g.errores_sintacticos[i].lexema) + ' \t ' + str(g.errores_sintacticos[i].tipo) + ' \t ' + str(g.errores_sintacticos[i].fila) + ' \t ' + str(g.errores_sintacticos[i].columna) + ' \t ' + str(g.errores_sintacticos[i].descripcion) + ' ')
i += 1
else:
imprimir_consola('Se detectaron algunos errores léxicos')
append_consola('')
append_consola('No. \t Lexema \t Tipo \t\t Fila \t Columna \t Descripción ')
i = 0
while i < len(g.errores_lexicos):
append_consola( str(i) + ' \t ' + str(g.errores_lexicos[i].lexema) + ' \t ' + str(g.errores_lexicos[i].tipo) + ' \t ' + str(g.errores_lexicos[i].fila) + ' \t ' + str(g.errores_lexicos[i].columna) + ' \t ' + str(g.errores_lexicos[i].descripcion) + ' ')
i += 1
def do_create_database(self, p_inst, p_st, p_es):
print('CREAR BASE DE DATOS')
key = 'CBD_' + p_inst.idData
simbolo = st.Symbol(key, p_inst.idData, 'create', '')
existe = p_st.get(key)
if existe and p_inst.Replace:
p_st.add(simbolo)
createDatabase(p_inst.idData)
elif existe and p_inst.IfNot:
p_st.add(simbolo)
createDatabase(p_inst.idData)
elif not existe:
p_st.add(simbolo)
createDatabase(p_inst.idData)
else:
error = es.errorSemantico(
key, 'La base de datos ' + p_inst.idData + ' ya existe')
p_es.agregar(error)
print('hola')
def tytus_ejecutar(self):
# Getting widget
index = self.ta_input.index(self.ta_input.select())
ta_input = self.array_tabs[index]
# Delete old lexical report
if os.path.exists("reports/error_lexical.txt"):
os.remove("reports/error_lexical.txt")
# Delete old syntactic report
if os.path.exists("reports/error_syntactic.txt"):
os.remove("reports/error_syntactic.txt")
# Delete old semantic report
if os.path.exists("reports/error_semantic.txt"):
os.remove("reports/error_semantic.txt")
if ta_input.compare("end-1c", "!=", "1.0"):
# Gets new input
tytus = ta_input.get(1.0, END)
# Start parser
ins = g.parse(tytus)
temp = g.contador
gen = Generador(temp, 0, ins.getInstruccion())
gen.ejecutar()
C3D = g.codigo_3D
crearArchivo(C3D)
##g.analizar(tytus)
st_global = st.SymbolTable()
es_global = es.ListaErroresSemanticos()
ct_global = ct.crearTabla()
if not ins:
messagebox.showerror(
"ERROR", "Ha ocurrido un error. Verificar reportes.")
else:
#self.do_body(ins.getInstruccion(), st_global, es_global, ct_global)
self.raiz_ast = ins.getNodo()
else:
messagebox.showerror("INFO", "El campo de entrada esta vacío.")
def tytus_ejecutar(self):
# Getting widget
index = self.ta_input.index(self.ta_input.select())
ta_input = self.array_tabs[index]
# Delete old lexical report
if os.path.exists("reports/error_lexical.txt"):
os.remove("reports/error_lexical.txt")
# Delete old syntactic report
if os.path.exists("reports/error_syntactic.txt"):
os.remove("reports/error_syntactic.txt")
# Delete old semantic report
if os.path.exists("reports/error_semantic.txt"):
os.remove("reports/error_semantic.txt")
# Delete old output
self.ta_output.delete('1.0', END)
if ta_input.compare("end-1c", "!=", "1.0"):
# Gets new input
tytus = ta_input.get(1.0, END)
# Start parser
ins = g.parse(tytus)
st_global = st.SymbolTable()
es_global = es.ListaErroresSemanticos()
ct_global = ct.crearTabla()
if not ins:
messagebox.showerror(
"ERROR", "Ha ocurrido un error. Verificar reportes.")
else:
self.do_body(ins.getInstruccion(), st_global, es_global,
ct_global)
print('HOLA')
##self.graficar(ins.getNodo())
else:
messagebox.showerror("INFO", "El campo de entrada esta vacío.")
def do_insert_tb(self, p_inst, p_st, p_es):
valor2 = 0
list = []
listI = []
for keys, value in p_st.symbols.items():
if value.id == p_inst.tabla:
BDD = value.value
for keys, value in p_st.symbols.items():
if value.type == 'use':
valor2 = 1
list.append(value.id)
if valor2 == 0:
error = es.errorSemantico(
'ITB_' + p_inst.tabla,
'No se ha seleccionado ninguna base de datos para crear la tabla '
+ p_inst.tabla)
p_es.agregar(error)
else:
BDDU = list.pop()
if BDDU == BDD:
key = 'ITB_' + p_inst.tabla
simbolo = st.Symbol(key, p_inst.tabla, 'insert table', BDD)
p_st.add(simbolo)
for val in p_inst.valores:
if isinstance(val, Numero) or isinstance(
val, Decimal) or isinstance(
val, bool) or isinstance(val, Cadena):
listI.append(val.valor)
insert(BDD, p_inst.tabla, listI)
else:
error = es.errorSemantico(
'ITB_' + p_inst.tabla,
'La tabla ' + p_inst.tabla + ' no existe')
p_es.agregar(error)
def do_create_database(self, p_inst, p_st, p_es):
key = 'CBD_' + p_inst.idData
simbolo = st.Symbol(key, p_inst.idData, 'create', '')
existe = p_st.get(key)
if existe and p_inst.Replace:
p_st.add(simbolo)
createDatabase(p_inst.idData)
self.new_output("BASE DE DATOS \'" + p_inst.idData +
"\' HA SIDO CREADA EXITOSAMENTE.")
elif existe and p_inst.IfNot:
p_st.add(simbolo)
createDatabase(p_inst.idData)
self.new_output("BASE DE DATOS \'" + p_inst.idData +
"\' HA SIDO CREADA EXITOSAMENTE.")
elif not existe:
p_st.add(simbolo)
createDatabase(p_inst.idData)
self.new_output("BASE DE DATOS \'" + p_inst.idData +
"\' HA SIDO CREADA EXITOSAMENTE.")
else:
error = es.errorSemantico(
key, 'La base de datos ' + p_inst.idData + ' ya existe')
p_es.agregar(error)
self.new_output(error.tipo)
def do_index(self, p_inst, p_st, p_es):
key = 'CI_' + p_inst.name
if isinstance(p_inst, Index):
if p_inst.Unique == True:
simbolo = st.Symbol(key, p_inst.name, 'INDEX', p_inst.Lindex,
'Index tipo: ' + 'Unique', '')
elif p_inst.Using == True:
simbolo = st.Symbol(key, p_inst.name, 'INDEX', p_inst.Lindex,
'Metodo: ' + 'Using Hash', '')
else:
simbolo = st.Symbol(key, p_inst.name, 'INDEX', p_inst.Lindex,
'', '')
elif isinstance(p_inst, IndexW):
simbolo = st.Symbol(key, p_inst.name, 'INDEX', p_inst.Lindex, '',
'')
elif isinstance(p_inst, IndexMM):
simbolo = st.Symbol(key, p_inst.name, 'INDEX',
str(p_inst.major) + ',' + str(p_inst.minor),
'', '')
elif isinstance(p_inst, IndexOrden):
if p_inst.Orden == 'ANF':
p_inst.Orden = 'ASC NULLS FIRST'
elif p_inst.Orden == 'ANL':
p_inst.Orden = 'ASC NULLS LAST'
elif p_inst.Orden == 'DNF':
p_inst.Orden = 'DESC NULLS FIRST'
elif p_inst.Orden == 'DNL':
p_inst.Orden = 'DESC NULLS LAST'
elif p_inst.Orden == 'NF':
p_inst.Orden = 'NULLS FIRST'
elif p_inst.Orden == 'NL':
p_inst.Orden = 'NULLS LAST'
simbolo = st.Symbol(key, p_inst.name, 'INDEX', p_inst.valor,
'Orden: ' + p_inst.Orden, '')
existe = p_st.get(key)
if not existe:
p_st.add(simbolo)
def accion_asignar(instr, ts):
if isinstance(instr.valor, ExpresionReferencia):
simboloref = ts.ObtenerTabla()[
instr.valor.registro.
registro] # obtengo el dic de la referencia que estoy haciendo
ts.agregar(simboloref, instr.variable.registro
) # creo una nueva variable pero con el mismo simbolo
elif isinstance(instr.variable, ExpresionArreglo):
diccionario = Comprobar_Crear_Arreglo(instr.variable.id, ts)
llaveconcatenada = ""
result = ""
indexlast = []
lastflag = False
for lista in instr.variable.dimension: # voy obteniendo las dimensiones de los registros
if lastflag is False:
valor = resolver_Expresion(lista.registro, ts)
llaveconcatenada += '$' + str(valor)
result = diccionario.get(llaveconcatenada, None)
if result is not None:
lastflag = True
else:
indexlast.append(
resolver_Expresion(lista.registro, ts)
) # agregando las dimensiones luego del valor en caso existan
# Procedo a hacer la insercion o modiicacion
if len(indexlast) > 0: # cambiar caracter, modifcar val o error
if len(indexlast) == 1:
valor = diccionario.get(llaveconcatenada)
nuevocaracter = resolver_Expresion(instr.valor, ts)
# llamada a metodo exterior
if type(valor) is int:
print('Acceso Denegado')
else:
nuevacadena = replace_str_index(valor, int(indexlast[0]),
nuevocaracter[0])
diccionario[llaveconcatenada] = nuevacadena
nuevo = TS.Simbolo(TS.TIPO_DATO.ARRAY, diccionario)
ts.actualizar(nuevo, instr.variable.id)
else:
print('Dimensiones Incorrectas')
else: # tengo que crear una nueva llave
valor = resolver_Expresion(instr.valor, ts)
diccionario[llaveconcatenada] = valor
nuevo = TS.Simbolo(TS.TIPO_DATO.ARRAY, diccionario)
ts.actualizar(nuevo, instr.variable.id)
else:
valor = resolver_Expresion(instr.valor,
ts) # Obtenie la operacion de la expresion
id = Obtener_o_Crear_Id(instr.variable.registro, ts)
# una vez comprobada ya esta creada la var o verificada
if type(valor) is str:
simbolo = ts.obtener(
id) # obtengo el simbolo para no perder referencia
simbolo.tipo = TS.TIPO_DATO.CADENA
simbolo.valor = valor
ts.actualizar(simbolo, id)
elif type(valor) is int:
simbolo = ts.obtener(
id) # obtengo el simbolo para no perder referencia
simbolo.tipo = TS.TIPO_DATO.NUMERO
simbolo.valor = valor
ts.actualizar(simbolo, id)
elif type(valor) is float:
simbolo = ts.obtener(
id) # Obtengo el simbolo para no perder referencia
simbolo.tipo = TS.TIPO_DATO.FLOAT
simbolo.valor = valor
ts.actualizar(simbolo, id)
elif type(valor) is dict:
simbolo = ts.obtener(
id) # Obtengo el simbolo para no perder referencia
simbolo.tipo = TS.TIPO_DATO.ARRAY
simbolo.valor = valor # el nuevo array
ts.actualizar(simbolo, id)
def report_st(self):
tSimbolo = st.SymbolTable()
generarTablaSimbolos(tSimbolo)
def interpretar(AST, consola, salidaSimbolos):
global ts
ts = None
ts = TablaSimbolos()
global errores
errores = consola.toPlainText()
if AST.main != None:
ts.agregar(AST.main.name, AST.main.name, TIPO_RELATIVO.LABEL, TIPO_ESPECIFICO.MAIN, AST.main.instructions)
for label in AST.labels:
ts.agregar(label.name, label.name, TIPO_RELATIVO.LABEL, None, label.instructions)
flag1 = False
flag2 = False
labeles = [AST.main] + AST.labels
for label in labeles:
for instruction in label.instructions:
if isinstance(instruction, Set):
if instruction.register.type_ == REGISTER.PARAM:
flag1 = True
elif isinstance(instruction, Goto):
goto = ts.obtener(instruction.label)
if goto != None:
if goto.tipo_especifico == None:
for instr in goto.valor:
if isinstance(instr, Set):
if instr.register.type_ == REGISTER.DEVUELTO:
flag2 = True
if flag2:
ts.asignarLabelType(instruction.label, TIPO_ESPECIFICO.FUNCION)
elif flag1:
ts.asignarLabelType(instruction.label, TIPO_ESPECIFICO.PROCEDIMIENTO)
else:
ts.asignarLabelType(instruction.label, TIPO_ESPECIFICO.CONTROL)
flag1 = False
flag2 = False
elif isinstance(instruction, If):
gotoIf = instruction.goto
goto = ts.obtener(gotoIf.label)
if goto != None:
if goto.tipo_especifico == None:
for instr in goto.valor:
if isinstance(instr, Set):
if instr.register.type_ == REGISTER.DEVUELTO:
flag2 = True
if flag2:
ts.asignarLabelType(gotoIf.label, TIPO_ESPECIFICO.FUNCION)
elif flag1:
ts.asignarLabelType(gotoIf.label, TIPO_ESPECIFICO.PROCEDIMIENTO)
else:
ts.asignarLabelType(gotoIf.label, TIPO_ESPECIFICO.CONTROL)
flag1 = False
flag2 = False
i_main(AST.main, consola)
ts.graph(salidaSimbolos)
from PyQt5 import QtWidgets
from PyQt5 import QtCore
from Instructions import *
from TablaSimbolos import *
ts = TablaSimbolos()
flag = True
errores = ''
def parar():
global flag
flag = False
def continuar():
global flag
flag = True
def addError(texto, consola):
global errores
prints = consola.toPlainText()[len(errores):]
errores += texto
consola.setText(errores + prints)
def interpretar(AST, consola, salidaSimbolos):
global ts
ts = None
ts = TablaSimbolos()
global errores
errores = consola.toPlainText()
def do_insert_tb(self, p_inst, p_st, p_es):
key = 'ITB_'+p_inst.tabla
simbolo = st.Symbol(key, p_inst.tabla, 'insert table', str(p_inst.valores).replace('\'',' '),'','')
p_st.add(simbolo)
def do_create_type(self, p_inst, p_st):
key = 'CTP_' + p_inst.idtype
simbolo = st.Symbol(key, p_inst.idtype, 'Type', p_inst.valores,'','')
existe = p_st.get(key)
if not existe:
p_st.add(simbolo)
def crearBase(nodo, tablaSimbolos):
val = nodo.id.valor
global consola
if nodo.replace == False and nodo.exists == False:
if nodo.owner == False and nodo.mode == False:
if jBase.createDatabase(val) == 0:
bd = TS.SimboloBase(val, None, None)
tablaSimbolos.put(val, bd)
consola += "Base de datos " + val + " creada. \n"
else:
consola += "Error al crear la base de datos \n"
elif nodo.owner == False and nodo.mode != False:
if jBase.createDatabase(val) == 0:
bd = TS.SimboloBase(val, None, nodo.mode)
tablaSimbolos.put(val, bd)
consola += "Base de datos " + val + " creada. \n"
else:
consola += "Error al crear la base de datos \n"
elif nodo.owner != False and nodo.mode == False:
if jBase.createDatabase(val) == 0:
bd = TS.SimboloBase(val, nodo.owner, None)
tablaSimbolos.put(val, bd)
consola += "Base de datos " + val + " creada. \n"
else:
consola += "Error al crear la base de datos \n"
elif nodo.owner != False and nodo.mode != False:
if jBase.createDatabase(val) == 0:
bd = TS.SimboloBase(val, nodo.owner, nodo.mode)
tablaSimbolos.put(val, bd)
consola += "Base de datos " + val + " creada. \n"
else:
consola += "Error al crear la base de datos \n"
elif nodo.replace != False and nodo.exists == False:
jBase.dropDatabase(val)
if nodo.owner == False and nodo.mode == False:
if jBase.createDatabase(val) == 0:
bd = TS.SimboloBase(val, None, None)
tablaSimbolos.put(val, bd)
consola += "Base de datos " + val + " creada. \n"
else:
consola += "Error al crear la base de datos \n"
elif nodo.owner == False and nodo.mode != False:
if jBase.createDatabase(val) == 0:
bd = TS.SimboloBase(val, None, nodo.mode)
tablaSimbolos.put(val, bd)
consola += "Base de datos " + val + " creada. \n"
else:
consola += "Error al crear la base de datos \n"
elif nodo.owner != False and nodo.mode == False:
if jBase.createDatabase(val) == 0:
bd = TS.SimboloBase(val, nodo.owner, None)
tablaSimbolos.put(val, bd)
consola += "Base de datos " + val + " creada. \n"
else:
consola += "Error al crear la base de datos \n"
elif nodo.owner != False and nodo.mode != False:
if jBase.createDatabase(val) == 0:
bd = TS.SimboloBase(val, nodo.owner, nodo.mode)
tablaSimbolos.put(val, bd)
consola += "Base de datos " + val + " creada. \n"
else:
consola += "Error al crear la base de datos \n"
elif nodo.replace == False and nodo.exists != False:
if nodo.owner == False and nodo.mode == False:
if jBase.createDatabase(val) == 0:
bd = TS.SimboloBase(val, None, None)
tablaSimbolos.put(val, bd)
consola += "Base de datos " + val + " creada. \n"
elif jBase.createDatabase(val) == 2:
consola += "La base de datos " + val + " ya existe. \n"
else:
consola += "Error al crear la base de datos \n"
elif nodo.owner == False and nodo.mode != False:
if jBase.createDatabase(val) == 0:
bd = TS.SimboloBase(val, None, nodo.mode)
tablaSimbolos.put(val, bd)
consola += "Base de datos " + val + " creada. \n"
elif jBase.createDatabase(val) == 2:
consola += "La base de datos " + val + " ya existe. \n"
else:
consola += "Error al crear la base de datos \n"
elif nodo.owner != False and nodo.mode == False:
if jBase.createDatabase(val) == 0:
bd = TS.SimboloBase(val, nodo.owner, None)
tablaSimbolos.put(val, bd)
consola += "Base de datos " + val + " creada. \n"
elif jBase.createDatabase(val) == 2:
consola += "La base de datos " + val + " ya existe. \n"
else:
consola += "Error al crear la base de datos \n"
elif nodo.owner != False and nodo.mode != False:
if jBase.createDatabase(val) == 0:
bd = TS.SimboloBase(val, nodo.owner, nodo.mode)
tablaSimbolos.put(val, bd)
consola += "Base de datos " + val + " creada. \n"
elif jBase.createDatabase(val) == 2:
consola += "La base de datos " + val + " ya existe. \n"
else:
consola += "Error al crear la base de datos \n"
def crearTabla(nodo, tablaSimbolos):
val = nodo.id
global consola
if nodo.herencia == False:
contador = 0
nueva = TS.SimboloTabla(val, None)
for col in nodo.columnas:
pk = False
default_ = None
check = None
null = True
unique = False
if isinstance(col, SColumna):
if col.opcionales != None:
for opc in col.opcionales:
if isinstance(opc, SOpcionales):
if opc.tipo == TipoOpcionales.PRIMARYKEY:
pk = True
elif opc.tipo == TipoOpcionales.DEFAULT:
default_ = opc.valor
elif opc.tipo == TipoOpcionales.CHECK:
if opc.id == None:
check = {
"id": col.id + "_check",
"condicion": opc.valor
}
listaConstraint.append(
TS.Constraints(useActual, val,
col.id + "_check",
col.id, "check"))
else:
check = {
"id": opc.id,
"condicion": opc.valor
}
listaConstraint.append(
TS.Constraints(useActual, val, opc.id,
col.id, "check"))
elif opc.tipo == TipoOpcionales.NULL:
null = True
elif opc.tipo == TipoOpcionales.NOTNULL:
null = False
elif opc.tipo == TipoOpcionales.UNIQUE:
if opc.id == None:
unique = col.id + "_unique"
listaConstraint.append(
TS.Constraints(useActual, val,
col.id + "_unique",
col.id, "unique"))
else:
unique = opc.id
listaConstraint.append(
TS.Constraints(useActual, val, opc.id,
col.id, "unique"))
colnueva = TS.SimboloColumna(
col.id, col.tipo, pk, None, unique, default_,
null, check)
nueva.crearColumna(col.id, colnueva)
if colnueva == None:
listaSemanticos.append(
Error.ErrorS(
"Error Semantico",
"Ya existe una columna con el nombre "
+ col.id))
else:
auxc = TS.SimboloColumna(col.id, col.tipo, False, False,
False, False, False, False)
nueva.crearColumna(col.id, auxc)
elif isinstance(col, SColumnaUnique):
for id in col.id:
if nueva.modificarUnique(id.valor, True,
id.valor + "_unique") == None:
listaSemanticos.append(
Error.ErrorS(
"Error Semantico",
"No se encontró la columna con id " +
id.valor))
else:
listaConstraint.append(
TS.Constraints(useActual, val,
id.valor + "_unique", id.valor,
"unique"))
elif isinstance(col, SColumnaCheck):
condicion = col.condicion
opIzq = condicion.opIzq
idcol = opIzq.valor
result = False
if col.id == None:
result = nueva.modificarCheck(idcol, col.condicion,
idcol + "_check")
listaConstraint.append(
TS.Constraints(useActual, val, idcol + "_check", idcol,
"check"))
else:
result = nueva.modificarCheck(idcol, condicion, col.id)
listaConstraint.append(
TS.Constraints(useActual, val, col.id, idcol, "check"))
if result != True:
listaSemanticos.append(
Error.ErrorS(
"Error Semantico",
"No se encontró la columna con id " + idcol))
elif isinstance(col, SColumnaFk):
for i in range(len(col.idlocal)):
idlocal = col.idlocal[i].valor
idfk = col.idfk[i].valor
columnafk = tablaSimbolos.getColumna(
useActual, col.id, idfk)
columnalocal = nueva.getColumna(idlocal)
if columnafk != None and columnalocal != None:
if columnafk.tipo.tipo == columnalocal.tipo.tipo:
nueva.modificarFk(idlocal, col.id, idfk)
listaFK.append(
TS.llaveForanea(useActual, val, col.id,
idlocal, idfk))
else:
listaSemanticos.append(
Error.ErrorS(
"Error Semantico",
"La columna %s y la columna %s no tienen el mismo tipo"
% (idlocal, idfk)))
else:
listaSemanticos.append(
Error.ErrorS("Error Semantico",
"No se encontró la columna"))
elif isinstance(col, SColumnaPk):
for id in col.id:
if nueva.modificarPk(id.valor) == None:
listaSemanticos.append(
Error.ErrorS(
"Error Semantico",
"No se encontró la columna " + id.valor))
contador += 1
base = tablaSimbolos.get(useActual)
base.crearTabla(val, nueva)
tt = jBase.createTable(useActual, nodo.id, contador)
if tt == 0:
consola += "La tabla " + nodo.id + " se creó con éxito. \n"
elif tt == 1:
consola += "Error en la operación al crear la tabla " + nodo.id + "\n"
elif tt == 2:
consola += "La base de datos " + useActual + " no existe. \n"
else:
consola += "La tabla " + nodo.id + " ya existe. \n"
def do_create_tb(self, p_inst, p_st, p_es, p_ct):
key = 'CTB_'+p_inst.nombreTabla+'_'
existe = p_st.get(key)
if not existe:
simbolo = st.Symbol(key, p_inst.nombreTabla, 'create table',p_inst.atributos,'','')
p_st.add(simbolo)
def accion_declaracion(inst, ts):
searched_var = ts.obtener(inst.variable.registro)
if searched_var is None:
simbolo = TS.Simbolo(TS.TIPO_DATO.NUMERO, 0) # lo inicializo en 0
ts.agregar(simbolo, inst.variable.registro
) # crea una nueva variable en la tabla de simbolos
def VerificarInstruccionesListaDeclaraciones(ArbolInstrucciones,tipoRobot):
'''
* Descripción de la función: Esta funcion dado un arbol de instrucciones,un
tipo y una tabla de simbolos verifica la
correctitud semantica de las instrucciones
de la lista de declaraciones del lenguaje
BOT.
* Variables de entrada:
- ArbolInstrucciones: Lista enlazada de instrucciones.
- tipoRobot: Tipo de variables (tipo del robot).
* Variables de salida:
- ListaTablas: Arreglo de tabla de simbolos.
'''
ListaTablas = []
aux = ArbolInstrucciones
while (aux!=None):
instrucciones = aux.instrucciones
TablaLocal = TablaSimbolos()
TablaLocal.insertar("me",tipoRobot)
while (instrucciones!=None):
# Se verifican las expresiones de las instrucciones STORE,DROP,
# RIGHT, LEFT, UP y DOWN
if (instrucciones.type in {"STORE","DROP","right","left","up","down"}):
Tipo = VerificarExpresionBinaria(instrucciones.expresiones,
TablaLocal)
if (instrucciones.type in {"right","left","up","down"}):
if (Tipo!=None):
VerificarTipoVariable(Tipo,"int",
instrucciones.numeroLinea)
# El tipo de expresion de la instruccion STORE debe ser
# igual al tipo del robot.
elif (instrucciones.type == "STORE"):
VerificarTipoVariable(Tipo,tipoRobot,
instrucciones.numeroLinea)
# Se verifican los identificadores de las instrucciones COLLECT
# y READ.
elif (instrucciones.type in {"COLLECT","READ"}):
identificador = instrucciones.identificador
if (identificador!=None):
resultado = TablaLocal.buscarLocal(identificador.value)
if(resultado!=None):
print("Error en linea",
identificador.numeroLinea ,": La variable \'"+
str(identificador.value)+"\' ha sido redeclarada.")
sys.exit()
else:
# Se almacenan las nuevas variables a la tabla.
TablaLocal.insertar(identificador.value,
tipoRobot,aux.condicion.type)
instrucciones = instrucciones.sig
ListaTablas += [TablaLocal]
aux = aux.sig
import tkinter as tk
import gramaticaASC as g
from tkinter import filedialog as FileDialog
from tkinter import colorchooser as ColorChooser
from tkinter import messagebox as MessageBox
import Graficar as graficando
import principal as principal
import os
from tkinter import filedialog
from tkinter import StringVar
from tkinter.constants import END, INSERT
import TablaSimbolos as TS
tablaSimbolos = TS.Entorno(None)
from tkinter import messagebox
import pickle
from graphviz import Digraph
pathFile = ''
#################################### CLASE TextLineNumbers ####################################
class TextLineNumbers(tk.Canvas):
def __init__(self, *args, **kwargs):
tk.Canvas.__init__(self, *args, **kwargs)
self.textwidget = None
def attach(self, text_widget):
self.textwidget = text_widget
