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)