def procesar_definicion(instr, ts):
if instr.tipo == "rakin":
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.RAKIN,
0) #inicializamos con 0 como valor por defecto
if instr.tipo == "chillka":
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.CHILLKA, "")
ts.agregar(simbolo)
def procesar_createDatabase(instr,ts,tc) :
if instr.replace == 1:
result = j.dropDatabase(str(instr.nombre.id))
global salida
if result == 1 :
salida = "\nERROR: internal_error \nSQL state: XX000 "
result1 = j.createDatabase(str(instr.nombre.id))
if result1 == 0:
temp1 = TS.Simbolo(instr.nombre.id,'Database',0,"")
ts.agregar(temp1)
salida = "\nCREATE DATABASE"
elif result1 == 1 :
salida = "\nERROR: internal_error \nSQL state: XX000 "
else:
result1 = j.createDatabase(str(instr.nombre.id))
if result1 == 0:
salida = "\nCREATE DATABASE"
temp1 = TS.Simbolo(instr.nombre.id,'Database',0,"")
ts.agregar(temp1)
elif result1 == 1 :
salida = "\nERROR: internal_error \nSQL state: XX000 "
elif result1 == 2 :
salida = "\nERROR: database \"" + str(instr.nombre.id) +"\" already exists \nSQL state: 42P04 "
def procesar_asignacion(instr, ts):
if instr.n == 0:
val = resolver_expresion_aritmetica(instr.exp, ts)
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.RAKIN, val)
if instr.n == 1:
val = resolver_cadena(instr.exp, ts)
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.CHILLKA, val)
ts.actualizar(simbolo)
def procesar_definicion_array(instr, ts):
flag = ts.buscar(instr.id)
if flag == True:
diccionario = {}
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.ARRAY, diccionario,
instr.ambito)
ts.agregar(simbolo)
else:
diccionario = {}
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.ARRAY, diccionario,
instr.ambito)
ts.agregar(simbolo)
def procesar_constraint(instr,ts,tc,tabla):
if instr.tipo == 'UNIQUE':
if instr.opciones_constraint != []:
temp = TS.Simbolo(instr.id,'CONSTRAINT',0,tabla)
ts.agregar(temp)
for ids in instr.opciones_constraint:
buscar = tc.obtenerReturn(useCurrentDatabase,tabla,ids.id)
if buscar == False:
print('No Encontrado')
else:
tempA = buscar.listaCons
tempA.append(OPCIONES_CONSTRAINT.UNIQUE)
tipo = TC.Tipo(useCurrentDatabase,tabla,ids.id,buscar.tipo,buscar.tamanio,ids,instr.referencia,tempA)
tc.actualizar(tipo,useCurrentDatabase,tabla,ids.id)
elif instr.tipo == 'FOREIGN':
if instr.opciones_constraint != []:
temp = TS.Simbolo(instr.id,'CONSTRAINT',0,tabla)
ts.agregar(temp)
for ids in instr.opciones_constraint:
buscar = tc.obtenerReturn(useCurrentDatabase,tabla,instr.columna)
if buscar == False:
print('No Encontrado')
else:
tempA = buscar.listaCons
tempA.append(OPCIONES_CONSTRAINT.FOREIGN)
tipo = TC.Tipo(useCurrentDatabase,tabla,instr.columna,buscar.tipo,buscar.tamanio,ids,instr.referencia,tempA)
tc.actualizar(tipo,useCurrentDatabase,tabla,instr.columna)
elif instr.tipo == 'CHECK':
if instr.opciones_constraint != []:
temp = TS.Simbolo(instr.id,'CONSTRAINT',0,tabla)
ts.agregar(temp)
for ids in instr.opciones_constraint:
if type(ids.exp1) == ExpresionIdentificador:
buscar = tc.obtenerReturn(useCurrentDatabase,tabla,ids.exp1.id)
if buscar == False:
print('No Encontrado')
else:
tempA = buscar.listaCons
tempA.append(OPCIONES_CONSTRAINT.CHECK)
tipo = TC.Tipo(useCurrentDatabase,tabla,ids.exp1.id,buscar.tipo,buscar.tamanio,"","",tempA)
tc.actualizar(tipo,useCurrentDatabase,tabla,ids.exp1.id)
else:
buscar = tc.obtenerReturn(useCurrentDatabase,tabla,ids.exp2.id)
if buscar == False:
print('No Encontrado')
else:
tempA = buscar.listaCons
tempA.append(OPCIONES_CONSTRAINT.CHECK)
tipo = TC.Tipo(useCurrentDatabase,tabla,ids.exp2.id,buscar.tipo,buscar.tamanio,"","",tempA)
tc.actualizar(tipo,useCurrentDatabase,tabla,ids.exp2.id)
def procesar_asignacion(instr, ts):
print("procesar_asignacion> " + str(instr.expNumerica))
if isinstance(instr.expNumerica, ExpresionDobleComilla):
procesar_definicion(instr, ts)
val = resolver_expresion_aritmetica(instr.expNumerica, ts)
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.CARACTER, val)
else:
procesar_definicion(instr, ts)
val = resolver_expresion_aritmetica(instr.expNumerica, ts)
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.NUMERO, val)
print("tipo : " + str(simbolo.tipo))
ts.actualizar(simbolo)
def procesar_conversion(instr, ts):
val = resolver_expresion_aritmetica(instr.expNumerica.id, ts)
tipoVal = ts.obtener(instr.expNumerica.id).valor
newVal = ""
if instr.expNumerica.tipo == "int":
if type(tipoVal) == int:
newVal = int(tipoVal)
elif type(tipoVal) == float:
newVal = int(tipoVal)
elif type(tipoVal) == str:
newVal = ord(tipoVal[0])
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.NUMERO, newVal,
instr.ambito)
if ts.buscar(instr.id):
ts.actualizar(simbolo)
else:
ts.agregar(simbolo)
elif instr.expNumerica.tipo == "float":
if type(tipoVal) == int:
newVal = float(tipoVal)
elif type(tipoVal) == float:
newVal = float(tipoVal)
elif type(tipoVal) == str:
tipoVal = ord(tipoVal[0])
newVal = float(tipoVal)
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.NUMERO, newVal,
instr.ambito)
if ts.buscar(instr.id):
ts.actualizar(simbolo)
else:
ts.agregar(simbolo)
elif instr.expNumerica.tipo == "char":
if type(tipoVal) == int:
newVal = chr(tipoVal)
elif type(tipoVal) == float:
tipoVal = int(tipoVal)
newVal = chr(tipoVal)
elif type(tipoVal) == str:
newVal = tipoVal[0]
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.CADENA, newVal,
instr.ambito)
if ts.buscar(instr.id):
ts.actualizar(simbolo)
else:
ts.agregar(simbolo)
elif isinstance(tipoVal, dict):
print("Arreglo")
else:
print(tipoVal, "--------", instr.expNumerica.id)
def procesar_indice_valor(instr, ts):
flag = ts.buscar(instr.id)
if flag == True:
val = resolver_indice_valor(instr.expNumerica, ts)
try:
valorFinal = int(val)
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.NUMERO, valorFinal,
instr.ambito)
except:
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.CADENA, val,
instr.ambito)
ts.actualizar(simbolo)
else:
procesar_definicion(instr, ts)
procesar_indice_valor(instr, ts)
def procesar_alterdatabase(instr,ts,tc):
global salida
if isinstance(instr.tipo_id,ExpresionIdentificador) :
global salida
print('OWNER ' + str(instr.tipo_id.id))
elif isinstance(instr.tipo_id, ExpresionComillaSimple) :
print('OWNER ' + str(instr.tipo_id.val))
else:
result = j.alterDatabase(str(instr.id_tabla),str(instr.tipo_id))
if result == 0:
tipo = TC.Tipo(useCurrentDatabase,instr.id_tabla,instr.id_tabla,"",OPCIONES_CONSTRAINT.CHECK,None,None)
tc.actualizarDatabase(tipo,instr.id_tabla,instr.tipo_id)
temp1 = ts.obtener(instr.id_tabla,"")
temp2 = TS.Simbolo(instr.tipo_id,temp1.tipo,temp1.valor,temp1.ambito)
ts.actualizarDB(temp2,temp1.id)
ts.actualizarDBTable(temp1.id,temp2.id)
salida = "\nALTER DATABASE"
elif result == 1 :
salida = "\nERROR: internal_error \nSQL state: XX000 "
elif result == 2 :
salida = "\nERROR: database \"" + str(instr.id_tabla) +"\" does not exist \nSQL state: 3D000"
elif result == 3 :
salida = "\nERROR: database \"" + str(instr.tipo_id) +"\" alredy exists\nSQL state: 42P04"
def procesar_asignacion_cadena(instr, ts):
val = resolver_cadena(instr.expNumerica, ts)
flag = ts.buscar(instr.id)
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.CADENA, val, instr.ambito)
if (flag == True):
ts.actualizar(simbolo)
else:
procesar_definicion_cadena(instr, ts)
ts.actualizar(simbolo)
def procesar_asignacion_relacional(instr, ts):
val = resolver_expresion_binaria_relacional(instr.expNumerica, ts)
flag = ts.buscar(instr.id)
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.BOOL, val, instr.ambito)
if (flag == True):
ts.actualizar(simbolo)
else:
procesar_definicion_relacional(instr, ts)
ts.agregar(simbolo)
def procesar_llamada(instr, ts):
ts_local = TS.TablaDeSimbolos(ts.simbolos, ts.funciones)
funcion = ts.obtener_funcion(instr.id)
if len(funcion.parametros) == len(instr.parametros):
for par in enumerate(funcion.parametros):
val = resolver_expresion_aritmetica(instr.parametros[par[0]], ts)
#print(par.id, " = ", val)
simbolo = TS.Simbolo(par[1].id, TS.TIPO_DATO.NUMERO, val)
ts_local.agregar(simbolo)
return procesar_instrucciones(funcion.instrucciones, ts_local)
else:
print('Error: cantidad de parametros no erronea')
def procesar_asignacion(instr, ts):
val = resolver_expresion_aritmetica(instr.expNumerica, ts)
#print("procesar asignacion :",instr.id,"=",val)
if isinstance(instr.expNumerica, AccesoArreglo):
#print("es arreglo")
if ts.existe(instr):
# print("existe solo se actualiza")
if isinstance(val, str):
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.CADENA, val)
ts.actualizar(simbolo)
elif isinstance(val, int):
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.NUMERO, val)
ts.actualizar(simbolo)
elif isinstance(val, float):
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.NUMERO, val)
ts.actualizar(simbolo)
else:
# print("no existe se guarda en ts")
if isinstance(val, str):
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.CADENA, val)
ts.agregar(simbolo)
elif isinstance(val, int):
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.NUMERO, val)
ts.agregar(simbolo)
elif isinstance(val, float):
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.NUMERO, val)
ts.agregar(simbolo)
#simbolo = TS.Simbolo(instr.id,instr.expNumerica.expNumerica.tipo, val)
#ts.agregar(simbolo)
else:
if ts.existe(instr):
# print("existe solo se actualiza")
simbolo = TS.Simbolo(instr.id, instr.expNumerica.tipo, val)
ts.actualizar(simbolo)
else:
# print("no existe se guarda en ts")
simbolo = TS.Simbolo(instr.id, instr.expNumerica.tipo, val)
ts.agregar(simbolo)
def procesar_createTable(instr,ts,tc) :
global pks
columns = []
i = 0
if instr.instrucciones != []:
global salida
for ins in instr.instrucciones:
if isinstance(ins, Definicion_Columnas):
i+=1
columns.append(i)
procesar_Definicion(ins,ts,tc,instr.id)
elif isinstance(ins, LLave_Primaria):
procesar_primaria(ins,ts,tc,instr.id)
elif isinstance(ins, Definicon_Foranea):
procesar_Foranea(ins,ts,tc,instr.id)
elif isinstance(ins, Lista_Parametros):
procesar_listaId(ins,ts,tc,instr.id)
elif isinstance(ins, definicion_constraint):
procesar_constraint(ins,ts,tc,instr.id)
try:
result = j.createTable(str(useCurrentDatabase),str(instr.id),int(len(columns)))
if result == 0:
salida = "\nCREATE TABLE"
temp1 = TS.Simbolo(str(instr.id),'Table',int(len(columns)),str(useCurrentDatabase))
ts.agregar(temp1)
elif result == 1 :
salida = "\nERROR: internal_error \nSQL state: XX000 "
elif result == 2 :
salida = "\nERROR: database \"" + useCurrentDatabase +"\" does not exist \nSQL state: 3D000"
elif result == 3 :
salida = "\nERROR: relation \"" + str(instr.id) +"\" alredy exists\nSQL state: 42P07"
except :
pass
try:
print(pks)
result = j.alterAddPK(str(useCurrentDatabase),str(instr.id),pks)
pks = []
print(pks)
except :
pass
def procesar_instrucciones2(instrucciones, indice, ts):
## lista de instrucciones recolectadas
global shell
while indice >= 0:
instr = instrucciones[indice]
if isinstance(instr, Imprimir):
procesar_imprimir(instr.exp, ts)
elif isinstance(instr, Asignacion):
procesar_asignacion(instr, ts)
elif isinstance(instr, AsignacionPosicionArray):
procesar_asignacion_array(instr, ts)
elif isinstance(instr, Etiqueta):
flag = ts.buscar(instr.id)
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.CONSTANTE, indice,
"Main")
if flag: ts.actualizar(simbolo)
else: ts.agregar(simbolo)
elif isinstance(instr, Goto):
procesar_goto2(instr, instrucciones, ts)
break
elif isinstance(instr, If):
condicion = procesar_if(instr, ts)
if condicion == 1:
procesar_goto2(instr.id, instrucciones, ts)
break
elif isinstance(instr, Unset):
procesar_unset(instr, ts)
elif isinstance(instr, Exit):
return
elif isinstance(instr, Read):
variable = showDialog()
print('ReadMe')
print(variable)
else:
Diccionario = {
'Tipo': 'Semantico',
'Error': "Instruccion",
'Descripcion': 'Instruccion invalida'
}
erroresSemanticos.agregar(Diccionario)
indice -= 1
def procesar_asignacion(instr, ts):
global erroresSemanticos
val = resolver_expresion_aritmetica(instr.expNumerica, ts)
if (val != None):
if (val == "cadena"):
procesar_asignacion_cadena(instr, ts)
elif (val == "logicabinaria"):
procesar_asignacion_logica(instr, ts)
elif (val == "logicaunitaria"):
procesar_asignacion_logica_unitaria(instr, ts)
elif (val == "bitbinaria"):
procesar_asignacion_bit(instr, ts)
elif (val == "bitunitaria"):
procesar_asignacion_bit_unitaria(instr, ts)
elif (val == "relacionalbinaria"):
procesar_asignacion_relacional(instr, ts)
elif (val == "asignacionarray"):
procesar_indice_valor(instr, ts)
elif (val == "declaracionarray"):
procesar_definicion_array(instr, ts)
elif (val == "conversion"):
procesar_conversion(instr, ts)
else:
flag = ts.buscar(instr.id)
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.NUMERO, val,
instr.ambito)
if (flag == True):
ts.actualizar(simbolo)
else:
procesar_definicion(instr, ts)
ts.actualizar(simbolo)
else:
Diccionario = {
'Tipo': 'Semantico',
'Error': str(val),
'Descripcion': 'No se puede declarar este tipo de variable',
'Fila': str(instr.fila),
'Columna': str(instr.columna)
}
erroresSemanticos.agregar(Diccionario)
print("Error: No se puede declarar esta variable por tipo de dato")
def procesar_Definicion(instr, ts):
# print('Definicion')
simbolo = TS.Simbolo(instr.id.id, TS.TIPO_DATO.CREATE_TABLE, 0)
ts.agregar(simbolo)
def procesar_createTable_Herencia(instr, ts):
# print('Crear Tabla con herencia')
simbolo = TS.Simbolo(instr.nombre_tabla, TS.TIPO_DATO.CREATE_TABLE, 0)
ts.agregar(simbolo)
if instr.intrucc != []:
procesar_instrucciones(instr.intrucc, ts)
def calcularSelectWhere(arbol, ts):
global lstResultado
global contador
contador += 1
print("--#Iniciando calcular[" + str(contador) + "]" + "[\'\'\'" +
str(arbol.etiqueta) + "]")
if arbol.esHoja == 'S':
if len(arbol.hijos) == 1:
id = inc()
simbolo = TS.Simbolo(str(arbol.etiqueta), TS.TIPO_DATO.ETIQUETA,
str(arbol.lexema))
ts.agregar(simbolo)
#********************* HOJAS PARA UNA SENTENCIA SELECT **************
if (ts.tipo_operacion == TS.TIPO_OPERACION.SELECT):
#estamos en una hoja de la seccion campos, almacenamos en lista campos
if (ts.operacion_actual == TS.TIPO_SELECT.CAMPOS):
if (arbol.etiqueta == 'column_name_func'
or arbol.etiqueta == 'select_function_element'):
ts.valor_temporal = TS.ValorTemporal(
str(arbol.lexema), str(arbol.etiqueta))
#se comento ya que daba error en lista de id...
# elif(arbol.etiqueta == 'column_name_id' or arbol.etiqueta == 'value_expression') :
# ts.valor_temporal = TS.ValorTemporal(str(arbol.lexema), str(arbol.etiqueta))
elif (arbol.etiqueta == 'column_name_opmult'):
ts.valor_temporal = TS.ValorTemporal(
str(arbol.lexema), str(arbol.etiqueta))
expCampo = TS.ExpresionCampo(
str(TS.CAMPO_FUNCION.SELECT_ASTERISCO.name),
str(arbol.lexema), None, None, None, None)
ts.agregarCampoSelect(expCampo)
elif (arbol.etiqueta == 'column_name_now'):
ts.valor_temporal = TS.ValorTemporal(
str(arbol.lexema), str(arbol.etiqueta))
expCampo = TS.ExpresionCampo(
str(TS.CAMPO_FUNCION.NOW.name), str(arbol.lexema),
None, None, None, None)
ts.agregarCampoSelect(expCampo)
elif (arbol.etiqueta == 'column_name_current_date'):
ts.valor_temporal = TS.ValorTemporal(
str(arbol.lexema), str(arbol.etiqueta))
expCampo = TS.ExpresionCampo(
str(TS.CAMPO_FUNCION.CURRENT_DATE.name),
str(arbol.lexema), None, None, None, None)
ts.agregarCampoSelect(expCampo)
elif (arbol.etiqueta == 'column_name_current_time'):
ts.valor_temporal = TS.ValorTemporal(
str(arbol.lexema), str(arbol.etiqueta))
expCampo = TS.ExpresionCampo(
str(TS.CAMPO_FUNCION.CURRENT_TIME.name),
str(arbol.lexema), None, None, None, None)
ts.agregarCampoSelect(expCampo)
elif (arbol.etiqueta == 'column_name_random'):
ts.valor_temporal = TS.ValorTemporal(
str(arbol.lexema), str(arbol.etiqueta))
expCampo = TS.ExpresionCampo(
str(TS.CAMPO_FUNCION.RANDOM.name),
str(arbol.lexema), None, None, None, None)
ts.agregarCampoSelect(expCampo)
else:
expCampo = TS.ExpresionCampo(
str(TS.CAMPO_FUNCION.ID.name), str(arbol.lexema),
None, None, None, None)
ts.agregarCampoSelect(expCampo)
#ts.agregarCampoSelect(str(arbol.lexema))
#estamos en una hoja de la sección tablas, alamcenamos en lista tablas
elif (ts.operacion_actual == TS.TIPO_SELECT.TABLAS):
ts.agregarTablaSelect(str(arbol.lexema))
#estamos en una hoja de la sección condicion, enviamos como temporal el valor
elif (ts.operacion_actual == TS.TIPO_SELECT.CONDICION):
ts.valor_temporal = TS.ValorTemporal(
str(arbol.lexema), str(arbol.etiqueta))
#estamos en una hoja de la seccion grupo, almacenamos en lista grupo
elif (ts.operacion_actual == TS.TIPO_SELECT.GRUPO):
ts.agregarGrupoSelect(str(arbol.lexema))
return id
elif len(arbol.hijos) > 1:
id = inc()
if len(arbol.hijos) == 3:
if (ts.tipo_operacion == TS.TIPO_OPERACION.SELECT
and ts.operacion_actual == TS.TIPO_SELECT.CONDICION):
if (arbol.etiqueta == 'like_percent_predicate'):
ts.TIPO_SELECT_CONDICION = TS.TIPO_SELECT_CONDICION.IN
expComparacion = TS.ExpresionListaComparadores(
str(arbol.hijos[0]), str(arbol.hijos[1]),
str(arbol.hijos[2]))
ts.agregarCondicionSelect(expComparacion)
else:
for x in range(0, len(arbol.hijos)):
pass
# dot.edge(str(id),'#'+str(id)+'[' +str(arbol.hijos[x])+']')
return id
#region
elif len(arbol.hijos) == 1:
id = inc()
#arbol.hijos[0].etiquetaPadre = arbol.etiqueta
if (arbol.etiqueta == 'in_value_list'):
if (arbol.hijos[0].esHoja == 'S'):
ts.valor_temporal = arbol.hijos[0].lexema
else:
calcularSelectWhere(arbol.hijos[0], ts)
temporal1 = ts.valor_temporal
else:
valorRetorno = str(calcularSelectWhere(arbol.hijos[0], ts))
if (arbol.etiqueta == 'WHERE_CONDITION'):
if (hasattr(ts, 'TIPO_SELECT_CONDICION')
and ts.TIPO_SELECT_CONDICION
== TS.TIPO_SELECT_CONDICION.COMPARACION):
if (len(ts.lstcondiciones) == 0):
ts.agregarCondicionSelect(ts.valor_temporal)
else:
#se utiliza pruebas
ts.agregarCondicionSelect(ts.valor_temporal)
return id
elif len(arbol.hijos) == 2:
id = inc()
if (arbol.etiqueta == 'in_value_list'):
# str(calcularSelectWhere(arbol.hijos[0],ts))
# temporal1 = ts.valor_temporal.valor
if (arbol.hijos[0].esHoja == 'S'):
temporal1 = str(arbol.hijos[0].lexema)
else:
calcularSelectWhere(arbol.hijos[0], ts)
temporal1 = ts.valor_temporal
# str(calcularSelectWhere(arbol.hijos[1],ts))
# temporal2 = ts.valor_temporal.valor
if (arbol.hijos[1].esHoja == 'S'):
temporal2 = str(arbol.hijos[1].lexema)
else:
calcularSelectWhere(arbol.hijos[1], ts)
temporal2 = ts.valor_temporal
ts.valor_temporal = temporal1 + ',' + temporal2
else:
valorRetorno1 = str(calcularSelectWhere(arbol.hijos[0], ts))
valorRetorno2 = str(calcularSelectWhere(arbol.hijos[1], ts))
elif len(arbol.hijos) == 3:
id = inc()
if (arbol.etiqueta == 'comparison_predicate'):
ts.TIPO_SELECT_CONDICION = TS.TIPO_SELECT_CONDICION.COMPARACION
#se valida si se puede obtener directamente la hoja o hay que sintetizar
# str(calcularSelectWhere(arbol.hijos[0],ts))
# temporal1 = ts.valor_temporal.valor
if (arbol.hijos[0].etiqueta == 'value_expression'):
temporal1 = arbol.hijos[0].lexema
else:
calcularSelectWhere(arbol.hijos[0], ts)
temporal1 = ts.valor_temporal.valor
if (arbol.hijos[1].etiqueta == 'comp_op'):
temporal2 = arbol.hijos[1].lexema
else:
calcularSelectWhere(arbol.hijos[1], ts)
temporal2 = ts.valor_temporal.valor
if (arbol.hijos[2].etiqueta == 'value_expression'):
temporal3 = arbol.hijos[2].lexema
elif (arbol.hijos[2].etiqueta == 'fun_now'):
temporal3 = 'now'
else:
calcularSelectWhere(arbol.hijos[2], ts)
temporal3 = ts.valor_temporal.valor
#se almacena como un temporal porque probablemente existan mas item como lista
#valTemp = TS.ExpresionComparacion(temporal1,temporal2,temporal3,None,TS.TIPO_SELECT_CONDICION.COMPARACION)
#ts.valor_temporal.valor = TS.ValorTemporal(valTemp, None)
#expIn = TS.ExpresionComparacion(temporal1,temporal2,temporal3,None,TS.TIPO_SELECT_CONDICION.IN)
# ts.agregarCondicionSelect(expIn)
#ts.agregarCondicionSelect(expComparacion)
valTemp = TS.ExpresionComparacion(
temporal1, temporal2, temporal3, None,
TS.TIPO_SELECT_CONDICION.COMPARACION)
ts.valor_temporal = TS.ValorTemporal(valTemp, None)
elif (arbol.etiqueta == 'search_condition'):
ts.TIPO_SELECT_CONDICION = TS.TIPO_SELECT_CONDICION.COMPARACION
# valorRetorno1 = str(calcularSelectWhere(arbol.hijos[0],ts))
# temporal1 = ts.valor_temporal.valor
if (arbol.hijos[0].esHoja == 'S'):
if (arbol.hijos[0].etiqueta == 'like_percent_predicate'):
ts.TIPO_SELECT_CONDICION = TS.TIPO_SELECT_CONDICION.IN
expComparacion = TS.ExpresionListaComparadores(
str(arbol.hijos[0].hijos[0]),
str(arbol.hijos[0].hijos[1]),
str(arbol.hijos[0].hijos[2]))
ts.agregarCondicionSelect(expComparacion)
temporal1 = ts.valor_temporal
else:
calcularSelectWhere(arbol.hijos[0], ts)
temporal1 = ts.valor_temporal
#valorRetorno2 = str(calcularSelectWhere(arbol.hijos[1],ts))
#temporal2 = arbol.hijos[1].lexema
if (arbol.hijos[1].esHoja == 'S'):
temporal2 = arbol.hijos[1].lexema
else:
calcularSelectWhere(arbol.hijos[1], ts)
temporal2 = ts.valor_temporal
# valorRetorno3 = str(calcularSelectWhere(arbol.hijos[2],ts))
# temporal3 = ts.valor_temporal.valor
if (arbol.hijos[2].esHoja == 'S'):
temporal3 = arbol.hijos[2].lexema
else:
calcularSelectWhere(arbol.hijos[2], ts)
temporal3 = ts.valor_temporal
#Como es item unico se envía directamente a la lista de comparación
#expComparacion = TS.ExpresionListaComparadores(temporal1,temporal2,temporal3)
expComparacion = TS.ExpresionListaComparadores(
temporal1, temporal2, temporal3)
#ts.valor_temporal.valor = TS.ValorTemporal(valTemp, None)
ts.agregarCondicionSelect(expComparacion)
elif (arbol.etiqueta == 'boolean_term'):
ts.TIPO_SELECT_CONDICION = TS.TIPO_SELECT_CONDICION.COMPARACION
# valorRetorno1 = str(calcularSelectWhere(arbol.hijos[0],ts))
# temporal1 = ts.valor_temporal.valor
if (arbol.hijos[0].esHoja == 'S'):
temporal1 = arbol.hijos[0].lexema
else:
calcularSelectWhere(arbol.hijos[0], ts)
temporal1 = ts.valor_temporal
# valorRetorno2 = str(calcularSelectWhere(arbol.hijos[1],ts))
# temporal2 = ts.valor_temporal.valor
if (arbol.hijos[1].etiqueta == 'opAnd'
): # or arbol.hijos[1].etiqueta == 'opOr'):
temporal2 = arbol.hijos[1].lexema
else:
calcularSelectWhere(arbol.hijos[1], ts)
temporal2 = ts.valor_temporal.valor
# valorRetorno3 = str(calcularSelectWhere(arbol.hijos[2],ts))
# temporal3 = ts.valor_temporal.valor
if (arbol.hijos[2].esHoja == 'S'):
temporal3 = arbol.hijos[2].lexema
else:
calcularSelectWhere(arbol.hijos[2], ts)
temporal3 = ts.valor_temporal
expComparacion = TS.ExpresionComparacion(
temporal1, temporal2, temporal3, None,
TS.TIPO_SELECT_CONDICION.COMPARACION)
ts.valor_temporal = expComparacion
elif (arbol.etiqueta == 'in_predicate'):
ts.TIPO_SELECT_CONDICION = TS.TIPO_SELECT_CONDICION.IN
# str(calcularSelectWhere(arbol.hijos[0],ts))
# temporal1 = ts.valor_temporal.valor
if (arbol.hijos[0].esHoja == 'S'):
temporal1 = arbol.hijos[0].lexema
else:
calcularSelectWhere(arbol.hijos[0], ts)
temporal1 = ts.valor_temporal
if (arbol.hijos[1].etiqueta == 'predicatein'):
temporal2 = arbol.hijos[1].lexema
else:
calcularSelectWhere(arbol.hijos[1], ts)
temporal2 = ts.valor_temporal.valor
# str(calcularSelectWhere(arbol.hijos[2],ts))
# temporal3 = ts.valor_temporal.valor
if (arbol.hijos[2].esHoja == 'S'):
temporal3 = arbol.hijos[2].lexema
else:
calcularSelectWhere(arbol.hijos[2], ts)
temporal3 = ts.valor_temporal
expIn = TS.ExpresionComparacion(temporal1, temporal2, temporal3,
None, TS.TIPO_SELECT_CONDICION.IN)
ts.agregarCondicionSelect(expIn)
# elif(arbol.etiqueta == 'null_predicate'):
# ts.TIPO_SELECT_CONDICION = TS.TIPO_SELECT_CONDICION.NULL
# str(calcularSelectWhere(arbol.hijos[0],ts))
# temporal1 = ts.valor_temporal.valor
# str(calcularSelectWhere(arbol.hijos[1],ts))
# temporal2 = ts.valor_temporal.valor
# str(calcularSelectWhere(arbol.hijos[2],ts))
# temporal3 = ts.valor_temporal.valor
# expIn = TS.ExpresionComparacion(temporal1,temporal2,temporal3,None,TS.TIPO_SELECT_CONDICION.NULL)
# ts.agregarCondicionSelect(expIn)
elif (arbol.etiqueta == 'like_percent_predicate'):
ts.TIPO_SELECT_CONDICION = TS.TIPO_SELECT_CONDICION.LIKE
#str(calcularSelectWhere(arbol.hijos[0],ts))
temporal1 = arbol.hijos[0]
#str(calcularSelectWhere(arbol.hijos[1],ts))
temporal2 = arbol.hijos[1]
#str(calcularSelectWhere(arbol.hijos[2],ts))
temporal3 = arbol.hijos[2]
expIn = TS.ExpresionComparacion(temporal1, temporal2, temporal3,
None,
TS.TIPO_SELECT_CONDICION.LIKE)
ts.agregarCondicionSelect(expIn)
elif (arbol.etiqueta == 'column_reference'):
ts.TIPO_SELECT_CONDICION = TS.TIPO_SELECT_CONDICION.SUBSTRING
temporal1 = arbol.hijos[0].lexema
temporal2 = arbol.hijos[1].lexema
temporal3 = arbol.hijos[2].lexema
# str(calcularSelectWhere(arbol.hijos[3],ts))
# temporal4 = ts.valor_temporal.valor
#se almacena como un temporal porque probablemente existan mas item como lista
ts.valor_temporal = TS.ExpresionComparacion(
temporal1, temporal2, temporal3, None,
TS.TIPO_SELECT_CONDICION.SUBSTRING)
else:
valorRetorno1 = str(calcularSelectWhere(arbol.hijos[0], ts))
valorRetorno2 = str(calcularSelectWhere(arbol.hijos[1], ts))
valorRetorno3 = str(calcularSelectWhere(arbol.hijos[2], ts))
return id
#************************************
# ARBOL CON 4 HIJOS
#************************************
elif len(arbol.hijos) == 4:
id = inc()
if (arbol.etiqueta == 'null_predicate'):
ts.TIPO_SELECT_CONDICION = TS.TIPO_SELECT_CONDICION.NOT_NULL
# str(calcularSelectWhere(arbol.hijos[0],ts))
# temporal1 = ts.valor_temporal.valor
if (arbol.hijos[0].esHoja == 'S'):
temporal1 = arbol.hijos[0].lexema
else:
calcularSelectWhere(arbol.hijos[0], ts)
temporal1 = ts.valor_temporal
# str(calcularSelectWhere(arbol.hijos[1],ts))
# temporal2 = ts.valor_temporal.valor
if (arbol.hijos[1].esHoja == 'S'):
temporal2 = arbol.hijos[1].lexema
else:
calcularSelectWhere(arbol.hijos[1], ts)
temporal2 = ts.valor_temporal
# str(calcularSelectWhere(arbol.hijos[2],ts))
# temporal3 = ts.valor_temporal.valor
if (arbol.hijos[2].esHoja == 'S'):
temporal3 = arbol.hijos[2].lexema
else:
calcularSelectWhere(arbol.hijos[2], ts)
temporal3 = ts.valor_temporal
# str(calcularSelectWhere(arbol.hijos[3],ts))
# temporal4 = ts.valor_temporal.valor
if (arbol.hijos[3].esHoja == 'S'):
temporal4 = arbol.hijos[3].lexema
else:
calcularSelectWhere(arbol.hijos[3], ts)
temporal4 = ts.valor_temporal
expIn = TS.ExpresionComparacion(temporal1, temporal2, temporal3,
temporal4,
TS.TIPO_SELECT_CONDICION.NOT_NULL)
ts.agregarCondicionSelect(expIn)
elif (arbol.etiqueta == 'substring_predicate'):
ts.TIPO_SELECT_CONDICION = TS.TIPO_SELECT_CONDICION.SUBSTRING
if (arbol.hijos[0].esHoja == 'S'):
temporal1 = arbol.hijos[0].lexema
else:
calcularSelectWhere(arbol.hijos[0], ts)
temporal1 = ts.valor_temporal
# str(calcularSelectWhere(arbol.hijos[1],ts))
# temporal2 = ts.valor_temporal
if (arbol.hijos[1].esHoja == 'S'):
temporal2 = arbol.hijos[1].lexema
else:
calcularSelectWhere(arbol.hijos[1], ts)
temporal2 = ts.valor_temporal
# str(calcularSelectWhere(arbol.hijos[2],ts))
# temporal3 = ts.valor_temporal
if (arbol.hijos[2].esHoja == 'S'):
temporal3 = arbol.hijos[2].lexema
else:
calcularSelectWhere(arbol.hijos[2], ts)
temporal3 = ts.valor_temporal
# str(calcularSelectWhere(arbol.hijos[3],ts))
# temporal4 = ts.valor_temporal
if (arbol.hijos[3].esHoja == 'S'):
temporal4 = arbol.hijos[3].lexema
else:
calcularSelectWhere(arbol.hijos[3], ts)
temporal4 = ts.valor_temporal
expIn = TS.ExpresionComparacion(temporal1, temporal2, temporal3,
temporal4,
TS.TIPO_SELECT_CONDICION.SUBSTRING)
ts.agregarCondicionSelect(expIn)
else:
valorRetorno1 = str(calcularSelectWhere(arbol.hijos[0], ts))
valorRetorno2 = str(calcularSelectWhere(arbol.hijos[1], ts))
valorRetorno3 = str(calcularSelectWhere(arbol.hijos[2], ts))
valorRetorno4 = str(calcularSelectWhere(arbol.hijos[3], ts))
return id
#************************************
# ARBOL CON 5 HIJOS
#************************************
elif len(arbol.hijos) == 5:
id = inc()
#region
if (arbol.etiqueta == 'between_predicate'):
ts.TIPO_SELECT_CONDICION = TS.TIPO_SELECT_CONDICION.BETWEEN
temporal1 = arbol.hijos[0].lexema
temporal2 = arbol.hijos[1].lexema
temporal3 = arbol.hijos[2].lexema
temporal4 = arbol.hijos[3].lexema
temporal5 = arbol.hijos[4].lexema
expComparacion = TS.ExpresionComparacion(
temporal3, temporal1, temporal5, None,
TS.TIPO_SELECT_CONDICION.BETWEEN)
#ts.agregarCondicionSelect(expComparacion)
#valTemp = TS.ExpresionComparacion(temporal1, None, None,None,TS.TIPO_SELECT_CONDICION.COMPARACION)
ts.valor_temporal = TS.ValorTemporal(expComparacion, None)
elif (arbol.etiqueta == 'distinct_predicate'):
ts.TIPO_SELECT_CONDICION = TS.TIPO_SELECT_CONDICION.DISTINCT
temporal1 = arbol.hijos[0].lexema
temporal2 = arbol.hijos[1].lexema
temporal3 = arbol.hijos[2].lexema
temporal4 = arbol.hijos[3].lexema
temporal5 = arbol.hijos[4].lexema
expComparacion = TS.ExpresionComparacion(
temporal3, temporal1, temporal5, None,
TS.TIPO_SELECT_CONDICION.DISTINCT)
ts.agregarCondicionSelect(expComparacion)
#endregion
else:
valorRetorno1 = str(calcularSelectWhere(arbol.hijos[0], ts))
valorRetorno2 = str(calcularSelectWhere(arbol.hijos[1], ts))
valorRetorno3 = str(calcularSelectWhere(arbol.hijos[2], ts))
valorRetorno4 = str(calcularSelectWhere(arbol.hijos[3], ts))
valorRetorno5 = str(calcularSelectWhere(arbol.hijos[4], ts))
return id
#************************************
# ARBOL CON 6 HIJOS
#************************************
elif len(arbol.hijos) == 6:
id = inc()
#region
if (arbol.etiqueta == 'between_predicate'):
ts.TIPO_SELECT_CONDICION = TS.TIPO_SELECT_CONDICION.NOT_BETWEEN
# str(calcularSelectWhere(arbol.hijos[0],ts))
# temporal1 = ts.valor_temporal.valor
if (arbol.hijos[0].esHoja == 'S'):
temporal1 = arbol.hijos[0].lexema
else:
calcularSelectWhere(arbol.hijos[0], ts)
temporal1 = ts.valor_temporal
# str(calcularSelectWhere(arbol.hijos[1],ts))
# temporal2 = ts.valor_temporal.valor
if (arbol.hijos[1].esHoja == 'S'):
temporal2 = arbol.hijos[1].lexema
else:
calcularSelectWhere(arbol.hijos[1], ts)
temporal2 = ts.valor_temporal
# str(calcularSelectWhere(arbol.hijos[2],ts))
# temporal3 = ts.valor_temporal.valor
if (arbol.hijos[2].esHoja == 'S'):
temporal3 = arbol.hijos[2].lexema
else:
calcularSelectWhere(arbol.hijos[2], ts)
temporal3 = ts.valor_temporal
# str(calcularSelectWhere(arbol.hijos[3],ts))
# temporal4 = ts.valor_temporal.valor
if (arbol.hijos[3].esHoja == 'S'):
temporal4 = arbol.hijos[3].lexema
else:
calcularSelectWhere(arbol.hijos[3], ts)
temporal4 = ts.valor_temporal
# str(calcularSelectWhere(arbol.hijos[4],ts))
# temporal5 = ts.valor_temporal.valor
if (arbol.hijos[4].esHoja == 'S'):
temporal5 = arbol.hijos[4].lexema
else:
calcularSelectWhere(arbol.hijos[4], ts)
temporal5 = ts.valor_temporal
# str(calcularSelectWhere(arbol.hijos[5],ts))
# temporal6 = ts.valor_temporal.valor
if (arbol.hijos[5].esHoja == 'S'):
temporal6 = arbol.hijos[5].lexema
else:
calcularSelectWhere(arbol.hijos[5], ts)
temporal6 = ts.valor_temporal
expComparacion = TS.ExpresionComparacion(
temporal4, temporal1, temporal6, None,
TS.TIPO_SELECT_CONDICION.NOT_BETWEEN)
ts.agregarCondicionSelect(expComparacion)
#endregion
else:
valorRetorno1 = str(calcularSelectWhere(arbol.hijos[0], ts))
valorRetorno2 = str(calcularSelectWhere(arbol.hijos[1], ts))
valorRetorno3 = str(calcularSelectWhere(arbol.hijos[2], ts))
valorRetorno4 = str(calcularSelectWhere(arbol.hijos[3], ts))
valorRetorno5 = str(calcularSelectWhere(arbol.hijos[4], ts))
valorRetorno6 = str(calcularSelectWhere(arbol.hijos[5], ts))
def procesar_altertable(instr,ts,tc):
if instr.etiqueta == TIPO_ALTER_TABLE.ADD_CHECK:
global salida
if instr.expresionlogica.operador == OPERACION_LOGICA.AND or instr.expresionlogica.operador == OPERACION_LOGICA.OR:
print(instr.identificador)
print(instr.expresionlogica.exp1.exp1.id)
print(instr.expresionlogica.exp1.exp2.val)
print(instr.expresionlogica.operador)
print(instr.expresionlogica.exp2.exp1.id)
print(instr.expresionlogica.exp2.exp2.val)
else:
print(instr.identificador)
if isinstance(instr.expresionlogica.exp1,ExpresionIdentificador):
print(instr.expresionlogica.exp1.id)
buscar = tc.obtenerReturn(useCurrentDatabase,instr.identificador,instr.expresionlogica.exp1.id)
if buscar == False:
print('No Encontrado')
else:
tempA = buscar.listaCons
tempA.append(OPCIONES_CONSTRAINT.CHECK)
tipo = TC.Tipo(useCurrentDatabase,instr.identificador,instr.expresionlogica.exp1.id,buscar.tipo,buscar.tamanio,"","",tempA)
tc.actualizar(tipo,useCurrentDatabase,instr.identificador,instr.expresionlogica.exp1.id)
salida = "\nALTER TABLE"
elif isinstance(instr.expresionlogica.exp2,ExpresionIdentificador):
print(instr.expresionlogica.exp2.id)
buscar = tc.obtenerReturn(useCurrentDatabase,instr.identificador,instr.expresionlogica.exp2.id)
if buscar == False:
print('No Encontrado')
else:
salida = "\nALTER TABLE"
tempA = buscar.listaCons
tempA.append(OPCIONES_CONSTRAINT.CHECK)
tipo = TC.Tipo(useCurrentDatabase,instr.identificador,instr.expresionlogica.exp2.id,buscar.tipo,buscar.tamanio,"","",tempA)
tc.actualizar(tipo,useCurrentDatabase,instr.identificador,instr.expresionlogica.exp2.id)
salida = "\nALTER TABLE"
elif instr.etiqueta == TIPO_ALTER_TABLE.ADD_FOREIGN:
buscar = tc.obtenerReturn(useCurrentDatabase,instr.identificador,instr.columnid)
if buscar == False:
print('No Encontrado')
else:
tempA = buscar.listaCons
tempA.append(OPCIONES_CONSTRAINT.FOREIGN)
tipo = TC.Tipo(useCurrentDatabase,instr.identificador,instr.columnid,buscar.tipo,buscar.tamanio,instr.lista_campos,instr.tocolumnid,tempA)
tc.actualizar(tipo,useCurrentDatabase,instr.identificador,instr.columnid)
salida = "\nALTER TABLE"
elif instr.etiqueta == TIPO_ALTER_TABLE.ADD_CONSTRAINT_CHECK:
if instr.expresionlogica.operador == TIPO_LOGICA.AND or instr.expresionlogica.operador == TIPO_LOGICA.OR:
print(instr.expresionlogica.exp1.exp1.id)
print(instr.expresionlogica.exp1.exp2.val)
print(instr.expresionlogica.operador)
print(instr.expresionlogica.exp2.exp1.id)
print(instr.expresionlogica.exp2.exp2.val)
else:
temp = TS.Simbolo(instr.columnid,'CONSTRAINT',0,instr.identificador)
ts.agregar(temp)
if type(instr.expresionlogica.exp1) == ExpresionIdentificador:
buscar = tc.obtenerReturn(useCurrentDatabase,instr.identificador,instr.expresionlogica.exp1.id)
if buscar == False:
print('No Encontrado')
else:
tempA = buscar.listaCons
tempA.append(OPCIONES_CONSTRAINT.CHECK)
tipo = TC.Tipo(useCurrentDatabase,instr.identificador,instr.expresionlogica.exp1.id,buscar.tipo,buscar.tamanio,"","",tempA)
tc.actualizar(tipo,useCurrentDatabase,instr.identificador,instr.expresionlogica.exp1.id)
salida = "\nALTER TABLE"
else:
print(instr.expresionlogica.exp1.val)
print(instr.expresionlogica.exp2.id)
buscar = tc.obtenerReturn(useCurrentDatabase,instr.identificador,instr.expresionlogica.exp2.id)
if buscar == False:
print('No Encontrado')
else:
tempA = buscar.listaCons
tempA.append(OPCIONES_CONSTRAINT.CHECK)
tipo = TC.Tipo(useCurrentDatabase,instr.identificador,instr.expresionlogica.exp2.id,buscar.tipo,buscar.tamanio,"","",tempA)
tc.actualizar(tipo,useCurrentDatabase,instr.identificador,instr.expresionlogica.exp2.id)
salida = "\nALTER TABLE"
elif instr.etiqueta == TIPO_ALTER_TABLE.ADD_CONSTRAINT_UNIQUE:
print(instr.identificador)
print(instr.columnid)
if instr.lista_campos != []:
temp = TS.Simbolo(instr.columnid,'CONSTRAINT',0,instr.identificador)
ts.agregar(temp)
for datos in instr.lista_campos:
print(datos.id)
buscar = tc.obtenerReturn(useCurrentDatabase,instr.identificador,datos.id)
if buscar == False:
print('Encontrado')
else:
tempA = buscar.listaCons
tempA.append(OPCIONES_CONSTRAINT.UNIQUE)
tipo = TC.Tipo(useCurrentDatabase,instr.identificador,datos.id,buscar.tipo,buscar.tamanio,"","",tempA)
tc.actualizar(tipo,useCurrentDatabase,instr.identificador,datos.id)
salida = "\nALTER TABLE"
elif instr.etiqueta == TIPO_ALTER_TABLE.ADD_CONSTRAINT_FOREIGN:
temp = TS.Simbolo(instr.columnid,'CONSTRAINT',0,instr.identificador)
ts.agregar(temp)
buscar = tc.obtenerReturn(useCurrentDatabase,instr.identificador,instr.tocolumnid)
if buscar == False:
print('No Encontrado')
else:
tempA = buscar.listaCons
tempA.append(OPCIONES_CONSTRAINT.FOREIGN)
tipo = TC.Tipo(useCurrentDatabase,instr.identificador,instr.tocolumnid,buscar.tipo,buscar.tamanio,instr.lista_ref,instr.lista_campos,tempA)
tc.actualizar(tipo,useCurrentDatabase,instr.identificador,instr.tocolumnid)
salida = "\nALTER TABLE"
salida = "\nALTER TABLE"
elif instr.etiqueta == TIPO_ALTER_TABLE.ALTER_COLUMN:
print(instr.identificador)
if instr.lista_campos != []:
for lista in instr.lista_campos:
print(lista.identificador.id)
print(lista.tipo.id)
print(lista.par1)
tipodatoo = TIPO_DE_DATOS.text_
tamanioD = ""
if lista.tipo.id.upper() == 'TEXT':
tipodatoo = TIPO_DE_DATOS.text_
tamanioD = ""
elif lista.tipo.id.upper() == 'FLOAT':
tipodatoo = TIPO_DE_DATOS.float_
elif lista.tipo.id.upper() == 'INTEGER':
tipodatoo = TIPO_DE_DATOS.integer_
tamanioD = ""
elif lista.tipo.id.upper() == 'SMALLINT':
tipodatoo = TIPO_DE_DATOS.smallint_
elif lista.tipo.id.upper() == 'MONEY':
tipodatoo = TIPO_DE_DATOS.money
elif lista.tipo.id.upper() == 'BIGINT':
tipodatoo = TIPO_DE_DATOS.bigint
elif lista.tipo.id.upper() == 'REAL':
tipodatoo = TIPO_DE_DATOS.real
elif lista.tipo.id.upper() == 'DOUBLE':
tipodatoo = TIPO_DE_DATOS.double
elif lista.tipo.id.upper() == 'INTERVAL':
tipodatoo = TIPO_DE_DATOS.interval
tamanioD = lista.par1
elif lista.tipo.id.upper() == 'TIME':
tipodatoo = TIPO_DE_DATOS.time
elif lista.tipo.id.upper() == 'TIMESTAMP':
tipodatoo = TIPO_DE_DATOS.timestamp
elif lista.tipo.id.upper() == 'DATE':
tipodatoo = TIPO_DE_DATOS.date
elif lista.tipo.id.upper() == 'VARING':
tipodatoo = TIPO_DE_DATOS.varing
tamanioD = lista.par1
elif lista.tipo.id.upper() == 'VARCHAR':
tipodatoo = TIPO_DE_DATOS.varchar
tamanioD = lista.par1
elif lista.tipo.id.upper() == 'CHAR':
tipodatoo = TIPO_DE_DATOS.char
tamanioD = lista.par1
elif lista.tipo.id.upper() == 'CHARACTER':
tipodatoo = TIPO_DE_DATOS.character
tamanioD = lista.par1
elif lista.tipo.id.upper() == 'DECIMAL':
tipodatoo = TIPO_DE_DATOS.decimal
tamanioD = lista.par1
elif lista.tipo.id.upper() == 'NUMERIC':
tipodatoo = TIPO_DE_DATOS.numeric
tamanioD = lista.par1
elif lista.tipo.id.upper() == 'DOUBLE':
tipodatoo = TIPO_DE_DATOS.double_precision
buscar = tc.obtenerReturn(useCurrentDatabase,instr.identificador,lista.identificador.id)
if buscar == False:
print('No Encontrado')
else:
tipo = TC.Tipo(useCurrentDatabase,instr.identificador,lista.identificador.id,buscar.tipo,tamanioD,buscar.referencia,buscar.tablaRef,buscar.listaCons)
tc.actualizar(tipo,useCurrentDatabase,instr.identificador,lista.identificador.id)
salida = "\nALTER TABLE"
elif instr.etiqueta == TIPO_ALTER_TABLE.ALTER_COLUMN_NULL:
#print(instr.identificador,instr.columnid)
buscar = tc.obtenerReturn(useCurrentDatabase,instr.identificador,instr.columnid)
if buscar == False:
print('No Encontrado')
else:
tempA = buscar.listaCons
tempA.append(OPCIONES_CONSTRAINT.NULL)
tipo = TC.Tipo(useCurrentDatabase,instr.identificador,instr.columnid,buscar.tipo,buscar.tamanio,"","",tempA)
tc.actualizar(tipo,useCurrentDatabase,instr.identificador,instr.columnid)
salida = "\nALTER TABLE"
elif instr.etiqueta == TIPO_ALTER_TABLE.ALTER_COLUMN_NOT_NULL:
buscar = tc.obtenerReturn(useCurrentDatabase,instr.identificador,instr.columnid)
if buscar == False:
print('No Encontrado')
else:
tempA = buscar.listaCons
tempA.append(OPCIONES_CONSTRAINT.NOT_NULL)
tipo = TC.Tipo(useCurrentDatabase,instr.identificador,instr.columnid,buscar.tipo,buscar.tamanio,"","",tempA)
tc.actualizar(tipo,useCurrentDatabase,instr.identificador,instr.columnid)
salida = "\nALTER TABLE"
elif instr.etiqueta == TIPO_ALTER_TABLE.DROP_CONSTRAINT:
print(instr.identificador)
if instr.lista_campos != []:
for datos in instr.lista_campos:
print(datos.id)
ts.deleteConstraint(datos.id,instr.identificador)
salida = "\nALTER TABLE"
elif instr.etiqueta == TIPO_ALTER_TABLE.RENAME_COLUMN:
# NO EXISTE :(
print(instr.identificador)
print(instr.columnid)
print(instr.tocolumnid)
salida = "\nALTER TABLE"
elif instr.etiqueta == TIPO_ALTER_TABLE.DROP_COLUMN:
#print('Tabla',instr.identificador)
if instr.lista_campos != []:
for datos in instr.lista_campos:
#print('Columna',datos.id)
pos = tc.getPos(useCurrentDatabase,instr.identificador,datos.id)
print(pos)
#result = j.alterDropColumn('world','countries',1)
#print(result)
result = 0
if result == 0:
tc.eliminarID(useCurrentDatabase,instr.identificador,datos.id)
temp1 = ts.obtener(instr.identificador,useCurrentDatabase)
temp2 = TS.Simbolo(temp1.id,temp1.tipo,temp1.valor-1,temp1.ambito)
ts.actualizarDB(temp2,instr.identificador)
salida = "\nALTER TABLE"
print(salida)
elif result == 1 :
salida = "\nERROR: internal_error \nSQL state: XX000 "
elif result == 2 :
salida = "\nERROR: database \"" + str(useCurrentDatabase) +"\" does not exist \nSQL state: 3D000"
elif result == 3 :
salida = "\nERROR: relation \"" + str(instr.identificador) +"\" does not exist\nSQL state: 42P01"
elif result == 4 :
salida = "\nERROR: key cannot be removed\nSQL state: 42P04"
elif result == 5 :
salida = "\nERROR: column out of bounds\nSQL state: 42P05"
elif instr.etiqueta == TIPO_ALTER_TABLE.ADD_COLUMN:
tipodatoo = TIPO_DE_DATOS.text_
tamanioD = ""
if instr.lista_campos[0].tipo.id.upper() == 'TEXT':
tipodatoo = TIPO_DE_DATOS.text_
tamanioD = ""
elif instr.lista_campos[0].tipo.id.upper() == 'FLOAT':
tipodatoo = TIPO_DE_DATOS.float_
elif instr.lista_campos[0].tipo.id.upper() == 'INTEGER':
tipodatoo = TIPO_DE_DATOS.integer_
tamanioD = ""
elif instr.lista_campos[0].tipo.id.upper() == 'SMALLINT':
tipodatoo = TIPO_DE_DATOS.smallint_
elif instr.lista_campos[0].tipo.id.upper() == 'MONEY':
tipodatoo = TIPO_DE_DATOS.money
elif instr.lista_campos[0].tipo.id.upper() == 'BIGINT':
tipodatoo = TIPO_DE_DATOS.bigint
elif instr.lista_campos[0].tipo.id.upper() == 'REAL':
tipodatoo = TIPO_DE_DATOS.real
elif instr.lista_campos[0].tipo.id.upper() == 'DOUBLE':
tipodatoo = TIPO_DE_DATOS.double
elif instr.lista_campos[0].tipo.id.upper() == 'INTERVAL':
tipodatoo = TIPO_DE_DATOS.interval
tamanioD = instr.lista_campos[0].par1
elif instr.lista_campos[0].tipo.id.upper() == 'TIME':
tipodatoo = TIPO_DE_DATOS.time
elif instr.lista_campos[0].tipo.id.upper() == 'TIMESTAMP':
tipodatoo = TIPO_DE_DATOS.timestamp
elif instr.lista_campos[0].tipo.id.upper() == 'DATE':
tipodatoo = TIPO_DE_DATOS.date
elif instr.lista_campos[0].tipo.id.upper() == 'VARING':
tipodatoo = TIPO_DE_DATOS.varing
tamanioD = instr.lista_campos[0].par1
elif instr.lista_campos[0].tipo.id.upper() == 'VARCHAR':
tipodatoo = TIPO_DE_DATOS.varchar
tamanioD = instr.lista_campos[0].par1
elif instr.lista_campos[0].tipo.id.upper() == 'CHAR':
tipodatoo = TIPO_DE_DATOS.char
tamanioD = instr.lista_campos[0].par1
elif instr.lista_campos[0].tipo.id.upper() == 'CHARACTER':
tipodatoo = TIPO_DE_DATOS.character
tamanioD = instr.lista_campos[0].par1
elif instr.lista_campos[0].tipo.id.upper() == 'DECIMAL':
tipodatoo = TIPO_DE_DATOS.decimal
tamanioD = instr.lista_campos[0].par1
elif instr.lista_campos[0].tipo.id.upper() == 'NUMERIC':
tipodatoo = TIPO_DE_DATOS.numeric
tamanioD = instr.lista_campos[0].par1
elif instr.lista_campos[0].tipo.id.upper() == 'DOUBLE':
tipodatoo = TIPO_DE_DATOS.double_precision
if instr.lista_campos != []:
for datos in instr.lista_campos:
result = j.alterAddColumn(str(useCurrentDatabase),str(instr.identificador),1)
if result == 0:
buscar = tc.obtenerReturn(useCurrentDatabase,instr.identificador,datos.identificador.id)
if buscar == False:
tipo = TC.Tipo(useCurrentDatabase,instr.identificador,datos.identificador.id,tipodatoo,tamanioD,"","",[])
tc.agregar(tipo)
else:
print('New')
temp1 = ts.obtener(instr.identificador,useCurrentDatabase)
temp2 = TS.Simbolo(temp1.id,temp1.tipo,temp1.valor+1,temp1.ambito)
ts.actualizarDB(temp2,instr.identificador)
salida = "\nALTER TABLE"
elif result == 1 :
salida = "\nERROR: internal_error \nSQL state: XX000 "
elif result == 2 :
salida = "\nERROR: database \"" + str(useCurrentDatabase) +"\" does not exist \nSQL state: 3D000"
elif result == 3 :
salida = "\nERROR: relation \"" + str(instr.tipo_id) +"\" does not exist\nSQL state: 42P01"
def procesar_asignacion_array(instr, ts):
global erroresSemanticos
indices = PILA.Pila()
bkindices = PILA.Pila()
indicesCopia = []
flag = ts.buscar(instr.id)
if flag == True:
print("************ ", str(instr.id), " ***************")
valorId = ts.obtener(instr.id).valor
if isinstance(valorId, str):
valorNew = resolver_expresion_aritmetica(instr.expNumerica, ts)
########## GET INDICES
for expArray in instr.posicion:
if isinstance(expArray, ExpresionArray):
print("Expresion Array Indice")
val = resolver_indice_valor(instr.expNumerica, ts)
if (val != None):
indicesCopia.append(val)
else:
Diccionario = {
'Tipo': 'Semantico',
'Error': str(instr.id),
'Descripcion': 'Indices inexistentes'
}
erroresSemanticos.agregar(Diccionario)
print("ERROR: Array o Struct no exist")
return
elif isinstance(expArray, ExpresionNumerica):
val = resolver_expresion_aritmetica(expArray, ts)
if val == "cadena":
val = resolver_cadena(expArray, ts)
indicesCopia.append(val)
else:
indicesCopia.append(val)
if valorNew == "cadena":
valorNew = resolver_cadena(instr.expNumerica, ts)
if indicesCopia[0] < len(valorId):
arregloCadena = list(valorId)
arregloCadena[indicesCopia[0]] = str(valorNew)
cadena = "".join(arregloCadena)
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.CADENA, cadena,
instr.ambito)
ts.actualizar(simbolo)
else:
arregloCadena = list(valorId)
i = 0
while True:
if (i == indicesCopia[0]):
arregloCadena.append(str(valorNew))
break
elif (i >= len(valorId)):
arregloCadena.append(" ")
i += 1
cadena = "".join(arregloCadena)
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.CADENA, cadena,
instr.ambito)
ts.actualizar(simbolo)
else:
valorNew = resolver_expresion_aritmetica(instr.expNumerica, ts)
########## GET INDICES
for expArray in instr.posicion:
if isinstance(expArray, ExpresionArray):
print("Expresion Array Indice")
val = resolver_indice_valor(instr.expNumerica, ts)
if (val != None):
indices.push(val)
bkindices.push(val)
indicesCopia.append(val)
else:
print("ERROR: Array o Struct no exist")
Diccionario = {
'Tipo': 'Semantico',
'Error': str(instr.id),
'Descripcion': 'Array o Struct inexistente'
}
erroresSemanticos.agregar(Diccionario)
return
elif isinstance(expArray, ExpresionNumerica):
val = resolver_expresion_aritmetica(expArray, ts)
if val == "cadena":
val = resolver_cadena(expArray, ts)
indices.push(val)
bkindices.push(val)
indicesCopia.append(val)
else:
indices.push(val)
bkindices.push(val)
indicesCopia.append(val)
########## GET VALOR
if (valorNew == "asignacionarray"):
print("Expresion Array Valor")
val = resolver_indice_valor(instr.expNumerica, ts)
if (val != None):
valorNew = val
else:
print("ERROR: Array o Struct no exist")
Diccionario = {
'Tipo': 'Semantico',
'Error': str(instr.id),
'Descripcion': 'Array o Struct inexistente'
}
erroresSemanticos.agregar(Diccionario)
return
elif (valorNew == "cadena"):
valorNew = resolver_cadena(instr.expNumerica, ts)
##################### DICCIONARIO = VALOR
valorAux = indices.pop()
Diccionario = {valorAux: valorNew}
while indices.estaVacia() == False:
valorAux = indices.pop()
auxDiccionario = {valorAux: Diccionario}
Diccionario = auxDiccionario
try:
valorFinal = update(copy.deepcopy(valorId), Diccionario)
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.STRUCT, valorFinal,
instr.ambito)
ts.actualizar(simbolo)
except:
if type(valorId[indicesCopia[
len(indicesCopia) - 2]]) == str and type(
indicesCopia[len(indicesCopia) - 1]) == int:
if type(valorNew) == str:
cadena = valorId[indicesCopia[len(indicesCopia) - 2]]
arregloCadena = list(cadena)
tamanio = len(arregloCadena) - int(
indicesCopia[len(indicesCopia) - 1])
if tamanio >= 0:
arregloCadena[indicesCopia[len(indicesCopia) -
1]] = valorNew
cadena = "".join(arregloCadena)
bkindices.pop()
valorAux = bkindices.pop()
Diccionario = {valorAux: cadena}
while bkindices.estaVacia() == False:
valorAux = bkindices.pop()
auxDiccionario = {valorAux: Diccionario}
Diccionario = auxDiccionario
try:
#print("Nuevo valor: ",str(Diccionario))
#print("Valor de ts: ",str(valorId))
valorFinal = update(copy.deepcopy(valorId),
Diccionario)
simbolo = TS.Simbolo(instr.id,
TS.TIPO_DATO.STRUCT,
valorFinal, instr.ambito)
ts.actualizar(simbolo)
except:
Diccionario = {
'Tipo': 'Semantico',
'Error': str(valorNew),
'Descripcion': 'Indice ocupado'
}
erroresSemanticos.agregar(Diccionario)
shell.append(
">> Error Indice ocupado: " +
str(valorId) +
"\n No se puede ingresar el valor: " +
str(valorNew))
else:
Diccionario = {
'Tipo': 'Semantico',
'Error': str(valorNew),
'Descripcion': 'Indice ocupado'
}
erroresSemanticos.agregar(Diccionario)
shell.append(">> Error Indice ocupado: " +
str(valorId) +
"\n No se puede ingresar el valor: " +
str(valorNew))
else:
Diccionario = {
'Tipo': 'Semantico',
'Error': str(valorNew),
'Descripcion': 'Indice ocupado'
}
erroresSemanticos.agregar(Diccionario)
shell.append(">> Error Indice ocupado: " +
str(valorId) +
"\n No se puede ingresar el valor: " +
str(valorNew))
else:
Diccionario = {
'Tipo': 'Semantico',
'Error': str(valorNew),
'Descripcion': 'Indice ocupado'
}
erroresSemanticos.agregar(Diccionario)
shell.append(">> Error Indice ocupado: " + str(valorId) +
"\n No se puede ingresar el valor: " +
str(valorNew))
else:
procesar_definicion_array(instr, ts)
procesar_asignacion_array(instr, ts)
def procesar_definicion_bit_unitaria(instr, ts):
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.BIT, 0, instr.ambito)
ts.agregar(simbolo)
def procesar_constraintDefinicion(instr,ts,tc,tabla,id_column):
#print(tabla,id,instr.id,instr.tipo)
global pks
if instr.id == None:
if instr.tipo == OPCIONES_CONSTRAINT.NOT_NULL:
buscar = tc.obtenerReturn(useCurrentDatabase,tabla,id_column)
if buscar == False:
print('Encontrado')
else:
tempA = buscar.listaCons
tempA.append(OPCIONES_CONSTRAINT.NOT_NULL)
tipo = TC.Tipo(useCurrentDatabase,tabla,id_column,buscar.tipo,buscar.tamanio,"","",tempA)
tc.actualizar(tipo,useCurrentDatabase,tabla,id_column)
elif instr.tipo == OPCIONES_CONSTRAINT.NULL:
buscar = tc.obtenerReturn(useCurrentDatabase,tabla,id_column)
if buscar == False:
print('Encontrado')
else:
tempA = buscar.listaCons
tempA.append(OPCIONES_CONSTRAINT.NULL)
tipo = TC.Tipo(useCurrentDatabase,tabla,id_column,buscar.tipo,buscar.tamanio,"","",tempA)
tc.actualizar(tipo,useCurrentDatabase,tabla,id_column)
elif instr.tipo == OPCIONES_CONSTRAINT.PRIMARY:
pk = []
buscar = tc.obtenerReturn(useCurrentDatabase,tabla,id_column)
if buscar == False:
print('Encontrado')
else:
tempA = buscar.listaCons
tempA.append(OPCIONES_CONSTRAINT.PRIMARY)
tipo = TC.Tipo(useCurrentDatabase,tabla,id_column,buscar.tipo,buscar.tamanio,"","",tempA)
tc.actualizar(tipo,useCurrentDatabase,tabla,id_column)
pos = tc.getPos(useCurrentDatabase,tabla,id_column)
pk.append(pos)
pks = pk
elif instr.tipo == OPCIONES_CONSTRAINT.FOREIGN:
buscar = tc.obtenerReturn(useCurrentDatabase,tabla,id_column)
if buscar == False:
print('Encontrado')
else:
tempA = buscar.listaCons
tempA.append(OPCIONES_CONSTRAINT.FOREIGN)
tipo = TC.Tipo(useCurrentDatabase,tabla,id_column,buscar.tipo,buscar.tamanio,"","",tempA)
tc.actualizar(tipo,useCurrentDatabase,tabla,id_column)
elif instr.tipo == OPCIONES_CONSTRAINT.UNIQUE:
buscar = tc.obtenerReturn(useCurrentDatabase,tabla,id_column)
if buscar == False:
print('Encontrado')
else:
tempA = buscar.listaCons
tempA.append(OPCIONES_CONSTRAINT.UNIQUE)
tipo = TC.Tipo(useCurrentDatabase,tabla,id_column,buscar.tipo,buscar.tamanio,"","",tempA)
tc.actualizar(tipo,useCurrentDatabase,tabla,id_column)
elif instr.tipo == OPCIONES_CONSTRAINT.DEFAULT:
if instr.opciones_constraint != []:
buscar = tc.obtenerReturn(useCurrentDatabase,tabla,id_column)
if buscar == False:
print('Encontrado')
else:
tempA = buscar.listaCons
tempA.append(OPCIONES_CONSTRAINT.DEFAULT)
tipo = TC.Tipo(useCurrentDatabase,tabla,id_column,buscar.tipo,buscar.tamanio,"","",tempA)
tc.actualizar(tipo,useCurrentDatabase,tabla,id_column)
elif instr.tipo == OPCIONES_CONSTRAINT.CHECK:
buscar = tc.obtenerReturn(useCurrentDatabase,tabla,id_column)
if buscar == False:
print('Encontrado')
else:
tempA = buscar.listaCons
tempA.append(OPCIONES_CONSTRAINT.CHECK)
tipo = TC.Tipo(useCurrentDatabase,tabla,id_column,buscar.tipo,buscar.tamanio,"","",tempA)
tc.actualizar(tipo,useCurrentDatabase,tabla,id_column)
else:
if instr.tipo == OPCIONES_CONSTRAINT.UNIQUE:
if instr.opciones_constraint == None:
temp = TS.Simbolo(instr.id,'CONSTRAINT',0,tabla)
ts.agregar(temp)
buscar = tc.obtenerReturn(useCurrentDatabase,tabla,id_column)
if buscar == False:
print('Encontrado')
else:
tempA = buscar.listaCons
tempA.append(OPCIONES_CONSTRAINT.UNIQUE)
tipo = TC.Tipo(useCurrentDatabase,tabla,id_column,buscar.tipo,buscar.tamanio,"","",tempA)
tc.actualizar(tipo,useCurrentDatabase,tabla,id_column)
elif instr.tipo == OPCIONES_CONSTRAINT.CHECK:
if instr.opciones_constraint != None:
temp = TS.Simbolo(instr.id,'CONSTRAINT',0,tabla)
ts.agregar(temp)
buscar = tc.obtenerReturn(useCurrentDatabase,tabla,id_column)
if buscar == False:
print('Encontrado')
else:
tempA = buscar.listaCons
tempA.append(OPCIONES_CONSTRAINT.CHECK)
tipo = TC.Tipo(useCurrentDatabase,tabla,id_column,buscar.tipo,buscar.tamanio,"","",tempA)
tc.actualizar(tipo,useCurrentDatabase,tabla,id_column)
def ejecutar(self, ts, ms):
sym = ts.obtener(self.var.id)
reference = ts.obtener(self.refvar.id)
tipo_et = self.DefineRol(self.var.id)
recorrido = ""
print("id: " + str(self.var.id) + " referencia: " + str(reference))
if self.var.accesos == None:
if sym is not None:
GLO.pila = GLO.pila + 1
self.pila = GLO.pila
declarada = self.Declaradaen()
simbolo = TS.Simbolo(self.var.id, reference.tipo,
self.refvar.GetValor(ts, ms), tipo_et,
reference.dim, self.etiqueta.id,
declarada)
simbolo.SetReference(reference.id)
ts.actualizar(simbolo)
else:
GLO.pila = GLO.pila + 1
self.pila = GLO.pila
declarada = self.Declaradaen()
simbolo = TS.Simbolo(self.var.id, reference.tipo,
self.refvar.GetValor(ts, ms), tipo_et,
reference.dim, self.etiqueta.id,
declarada)
simbolo.SetReference(reference.id)
ts.agregar(simbolo)
else:
if sym is not None:
if (sym.tipo
== TS.TIPO_DATO.ARRAY) or (sym.tipo
== TS.TIPO_DATO.STRUCT):
array = sym.valor
arreglo = array.values
else:
print("Este temporal ya contiene un dato")
ms.AddMensaje(
MS.Mensaje("Este temporal ya contiene un dato",
self.linea, self.columna, True,
"Semantico"))
return None
else:
array = Arreglo()
arreglo = array.values
accesos = self.CheckA(self.var.accesos, ts, ms)
isint = self.CheckInt(self.var.accesos, ts, ms)
level = arreglo
for i in range(len(accesos)):
#print("lenght: "+str(len(accesos)))
if i == (len(accesos)) - 1:
#print("fin"+str(i)+str(accesos[i])+str(val)+str(level))
#guardar valor
recorrido += str(accesos[i])
if isinstance(self.refvar.GetValor(ts, ms), Arreglo):
level[accesos[i]] = self.refvar.GetValor(ts, ms).values
else:
level[accesos[i]] = self.refvar.GetValor(ts, ms)
else:
recorrido += str(accesos[i])
if accesos[i] in level:
if type(level[accesos[i]]) is dict:
#agregar a elemento
#print("is instance")
level = level[accesos[i]]
elif isinstance(level[accesos[i]], str):
if i + 2 == len(accesos):
if isinstance(accesos[i + 1], int):
if accesos[i + 1] < len(level[accesos[i]]):
#print("una cadenita:"+str(i))
level[accesos[i]] = level[
accesos[i]][:accesos[i + 1]] + str(
self.refvar.GetValor(ts, ms)
) + level[accesos[i]][accesos[i +
1] +
1:]
break
else:
r = len(level[accesos[i]])
adding = ""
while r < accesos[i + 1]:
adding = adding + " "
r += 1
adding += str(
self.refvar.GetValor(ts, ms))
level[accesos[i]] = level[
accesos[i]] + adding
else:
print(
"Solo se puede acceder con un numero a una cadena"
)
ms.AddMensaje(
MS.Mensaje(
"Solo se puede acceder con un numero a una cadena",
self.linea, self.columna, True,
"Semantico"))
else:
print(
"Error no se puede acceder a este tipo de elemento"
)
ms.AddMensaje(
MS.Mensaje(
"Error no se puede acceder a este tipo de elemento",
self.linea, self.columna, True,
"Semantico"))
else:
ms.AddMensaje(
MS.Mensaje(
"No se puede acceder a este tipo de elemento",
self.linea, self.columna, True,
"Semantico"))
print(
"error no se puede acceder a este tipo de elemento"
)
break
else:
#iterar o crear
#print("I am not" + str(accesos[i]))
level[accesos[i]] = {}
level = level[accesos[i]]
if array.GetTipo(ts, ms) == TS.TIPO_DATO.ARRAY:
rol = "Arreglo"
else:
rol = "Struct"
#print("es este:"+str(array.values)+" from: "+self.var.id)
GLO.pila = GLO.pila + 1
self.pila = GLO.pila
declarada = self.Declaradaen()
simbolo = TS.Simbolo(self.var.id, array.GetTipo(ts, ms), array,
tipo_et, reference.dim, self.etiqueta.id,
declarada)
#simbolo = TS.Simbolo(self.var.id, reference.tipo, reference.valor,tipo_et,reference.dim,self.etiqueta.id,declarada)
simbolo.SetReference(reference.id)
simbolo.SetPosicion(recorrido, reference.id)
ts.agregar(simbolo)
if sym is not None:
ts.actualizar(simbolo)
else:
ts.agregar(simbolo)
return None
def GetValor(self, ts, ms):
sym = ts.obtener(self.id)
if sym != None:
if self.accesos == None:
if sym.reference == None:
return sym.valor
else:
referencia = ts.obtener(sym.reference)
refsymbol = TS.Simbolo(self.id, referencia.tipo,
referencia.valor, referencia.rol,
referencia.dim, sym.ambito,
sym.declarada)
ts.actualizar(refsymbol)
if referencia != None:
return referencia.valor
else:
accesos = self.GetAccesos(self.accesos, ts, ms)
isint = self.CheckInt(self.accesos, ts, ms)
recorrido = ""
if (accesos is None):
print("Error obteniendo los accesos")
ms.AddMensaje(
MS.Mensaje("Error obteniendo los accesos", self.linea,
self.columna, True, "Semantico"))
return None
if (sym.tipo
== TS.TIPO_DATO.ARRAY) or (sym.tipo
== TS.TIPO_DATO.STRUCT):
arreglo = sym.valor
value = arreglo
level = arreglo.values
#print("levels: "+str(level)+" from:"+ self.id)
for i in range(len(accesos)):
if i == (len(accesos)) - 1:
#print("fin"+str(i))
#obtiene valor
recorrido += str(accesos[i])
if accesos[i] in level:
if sym.reference is None:
value = level[accesos[i]]
else:
if sym.posicion is not None:
if recorrido in sym.posicion:
refs = ts.obtener(
sym.posicion[recorrido])
value = refs.valor
level[accesos[i]] = value
else:
value = level[accesos[i]]
else:
value = level[accesos[i]]
else:
print(
"Error acceso a esta posicion esta vacios")
ms.AddMensaje(
MS.Mensaje(
"Error acceso a esta posicion esta vacios",
self.linea, self.columna, True,
"Semantico"))
else:
recorrido += str(accesos[i])
if accesos[i] in level:
if isinstance(level[accesos[i]], dict):
#agregar a elemento
level = level[accesos[i]]
elif isinstance(level[accesos[i]], str):
if i + 2 == len(accesos):
if isint:
if accesos[i + 1] < len(
level[accesos[i]]):
#print("una cadenita:"+str(i))
return level[accesos[i]][
accesos[i + 1]]
else:
print(
"Posicion mayor a cadena")
ms.AddMensaje(
MS.Mensaje(
"Posicion mayor a cadena",
self.linea,
self.columna, True,
"Semantico"))
else:
print(
"Solo se puede acceder con un numero a una cadena"
)
ms.AddMensaje(
MS.Mensaje(
"Solo se puede acceder con un numero a una cadena",
self.linea, self.columna,
True, "Semantico"))
else:
print(
"Error no se puede acceder a este tipo de elemento"
)
ms.AddMensaje(
MS.Mensaje(
"Error no se puede acceder a este tipo de elemento",
self.linea, self.columna, True,
"Semantico"))
else:
#error no se puede acceder a este tipo de elemento
print(
"Error no se puede acceder a este tipo de elemento"
)
ms.AddMensaje(
MS.Mensaje(
"Error no se puede acceder a este tipo de elemento",
self.linea, self.columna, True,
"Semantico"))
break
else:
print(
"Error acceso a esta posicion esta vacio")
ms.AddMensaje(
MS.Mensaje(
"Error acceso a esta posicion esta vacio",
self.linea, self.columna, True,
"Semantico"))
break
return value
elif sym.tipo == TS.TIPO_DATO.CHAR:
if len(accesos) == 1:
if isint:
if accesos[0] < len(sym.valor):
return sym.valor[accesos[0]]
else:
print("Posicion mayor a cadena")
ms.AddMensaje(
MS.Mensaje("Posicion mayor a cadena",
self.linea, self.columna, True,
"Semantico"))
else:
print(
"Solo se puede acceder con un numero a una cadena"
)
ms.AddMensaje(
MS.Mensaje(
"Solo se puede acceder con un numero a una cadena",
self.linea, self.columna, True,
"Semantico"))
else:
print(
"No se puede acceder multiples veces a una cadena")
ms.AddMensaje(
MS.Mensaje(
"No se puede acceder multiples veces a una cadena",
self.linea, self.columna, True, "Semantico"))
else:
print("No se puede aceeder a una variable con este tipo")
ms.AddMensaje(
MS.Mensaje(
"No se puede aceeder a una variable con este tipo",
self.linea, self.columna, True, "Semantico"))
print("No existe esta variable")
ms.AddMensaje(
MS.Mensaje("No existe esta variable", self.linea, self.columna,
True, "Semantico"))
return None
def actualizar(self,ts):
declarada = self.Declaradaen()
simbolo = TS.Simbolo(self.id,"Etiqueta", self,self.rol,0,"Global",declarada)
ts.actualizar(simbolo)
def procesar_definicion_cadena(instr, ts):
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.CADENA, "", instr.ambito)
ts.agregar(simbolo)
def procesar_definicion(instr, ts):
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.NUMERO,
0) # inicializamos con 0 como valor por defecto
ts.agregar(simbolo)
def inicializar(self, ts,ms,next):
declarada = self.Declaradaen()
simbolo = TS.Simbolo(self.id, "Etiqueta", self,"Etiqueta",0,"Global",declarada)
ts.agregar(simbolo)
self.next = next
def procesar_definicion_relacional(instr, ts):
simbolo = TS.Simbolo(instr.id, TS.TIPO_DATO.BOOL, 0, instr.ambito)
ts.agregar(simbolo)
