/* * Constructor de la clase padre * @ts tabla de simbolos padre * @user usuario que esta ejecutando las acciones * @baseD string por referencia de que base de datos estamos trabajando * @mensajes el output de la ejecucion */ public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT) { if (condicion == null) { TablaDeSimbolos ambitoLocal = new TablaDeSimbolos(); foreach (Simbolo s in ts) { ambitoLocal.AddLast(s); } foreach (InstruccionCQL i in cuerpo) { object r = i.ejecutar(ambitoLocal, ambito, tsT); if (r == null) { return(r); } } return(""); } else { Mensaje mensa = new Mensaje(); object a = condicion.ejecutar(ts, ambito, tsT); if (a != null) { if (a.GetType() == typeof(Boolean)) { flag = (Boolean)a; if ((Boolean)a) { TablaDeSimbolos ambitoLocal = new TablaDeSimbolos(); foreach (Simbolo s in ts) { ambitoLocal.AddLast(s); } foreach (InstruccionCQL i in cuerpo) { object r = i.ejecutar(ambitoLocal, ambito, tsT); if (r == null) { return(r); } } return(""); } } else { ambito.mensajes.AddLast(mensa.error("La condicion tiene que ser de tipo Bool: " + a.ToString(), l, c, "Semantico")); return(null); } } else { ambito.mensajes.AddLast(mensa.error("No se aceptan condiciones null ", l, c, "Semantico")); return(null); } return(""); } }
/* * Metodo que se encargara de guardar los valores como variables temporales * @atributos es la data a guardar * @tsT es la tabla temporal */ private void guardarTemp(LinkedList <Atributo> atributos, TablaDeSimbolos tsT) { foreach (Atributo atributo in atributos) { tsT.AddLast(new Simbolo(atributo.tipo, atributo.nombre)); tsT.setValor(atributo.nombre, atributo.valor); } }
/* * Metodo que se encargara de guardar los valores como variables temporales * @atributos es la data a guardar * @tsT es la tabla temporal */ private void setColumnas(LinkedList <Columna> atributos, TablaDeSimbolos tsT) { foreach (Columna atributo in atributos) { tsT.AddLast(new Simbolo(atributo.tipo, atributo.name)); tsT.setValor(atributo.name, atributo.name); } }
/* * Constructor de la clase padre * @ts tabla de simbolos padre * @user usuario que esta ejecutando las acciones * @baseD string por referencia de que base de datos estamos trabajando * @mensajes el output de la ejecucion */ public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT) { object res = (condicion == null) ? null : condicion.ejecutar(ts, ambito, tsT); object condi = verificarCondicion(res, ambito.mensajes); if (condi != null) { TablaDeSimbolos nuevoAmbito = new TablaDeSimbolos(); foreach (Simbolo s in ts) { nuevoAmbito.AddLast(s); } foreach (InstruccionCQL i in cuerpo) { object resultado = i.ejecutar(nuevoAmbito, ambito, tsT); if (resultado == null) { return(null); } } while ((Boolean)condi) { nuevoAmbito = new TablaDeSimbolos(); foreach (Simbolo s in ts) { nuevoAmbito.AddLast(s); } //------------------------------------------------------------ INSTRUCCIONES DO WHILE ------------------------------------------ foreach (InstruccionCQL i in cuerpo) { object resultado = i.ejecutar(nuevoAmbito, ambito, tsT); if (resultado == null) { return(null); } else if (resultado.GetType() == typeof(Retorno)) { return((Retorno)resultado); } else if (i.GetType() == typeof(Continue) || resultado.GetType() == typeof(Continue)) { break; } } res = (condicion == null) ? null : condicion.ejecutar(nuevoAmbito, ambito, tsT); condi = verificarCondicion(res, ambito.mensajes); if (condi == null) { return(null); } } return(""); } return(null); }
/* * Constructor de la clase padre * @ts tabla de simbolos padre * @user usuario que esta ejecutando las acciones * @baseD string por referencia de que base de datos estamos trabajando * @mensajes el output de la ejecucion */ public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT) { Mensaje ms = new Mensaje(); object res = (condicion == null) ? null : condicion.ejecutar(ts, ambito, tsT); object condi = verificarCondicion(res, ambito.mensajes); if (condi != null) { while ((Boolean)condi) { TablaDeSimbolos nuevoAmbito = new TablaDeSimbolos(); foreach (Simbolo s in ts) { nuevoAmbito.AddLast(s); } //--------------------------------------------------- INSTRUCCIONES DENTRO DEL WHILE------------------------------------ foreach (InstruccionCQL i in cuerpo) { object resultado = i.ejecutar(nuevoAmbito, ambito, tsT); if (resultado == null) { System.Diagnostics.Debug.WriteLine("TIPOWHILE: " + i.GetType()); return(null); } else if (resultado.GetType() == typeof(Retorno)) { return((Retorno)resultado); } else if (i.GetType() == typeof(Continue) || resultado.GetType() == typeof(Continue)) { break; } } res = (condicion == null) ? null : condicion.ejecutar(nuevoAmbito, ambito, tsT); condi = verificarCondicion(res, ambito.mensajes); if (condi == null) { return(null); } } return(""); } else { ambito.listadoExcepciones.AddLast(new Excepcion("exception", "La coindicion no puede ser null")); ambito.mensajes.AddLast(ms.error("La coindicion no puede ser null", l, c, "Semantico")); } return(null); }
/* * Constructor de la clase padre * @ts tabla de simbolos padre * @user usuario que esta ejecutando las acciones * @baseD string por referencia de que base de datos estamos trabajando * @mensajes el output de la ejecucion */ public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT) { Mensaje ms = new Mensaje(); object existeVariable = ts.getValor(id); if (existeVariable.Equals("none")) { TypeCursor typeCursor; if (select.GetType() == typeof(Expresion)) { object respuesta = (select == null) ? null : select.ejecutar(ts, ambito, tsT); if (respuesta == null) { return(null); } if (respuesta.GetType() == typeof(TypeCursor)) { typeCursor = (TypeCursor)respuesta; } else { ambito.mensajes.AddLast(ms.error("A un cursor solo se le puede asignar un tipo Select no se reconoce: " + respuesta, l, c, "Semantico")); return(null); } } else { typeCursor = new TypeCursor(null, (Select)select); } ts.AddLast(new Simbolo("cursor", id)); ts.setValor(id, typeCursor); return(""); } else { ambito.mensajes.AddLast(ms.error("Ya existe la variable: " + id + " en este ambito", l, c, "Semantico")); } return(null); }
public object Ejecutar(TablaDeSimbolos ts) { TablaDeSimbolos tabla_local = new TablaDeSimbolos(); tabla_local.addPadre(ts); if (variable.Asignacion) { Tipo type = ts.getType(variable.Id); Operacion val = (Operacion)variable.Valor; object valor = val.Ejecutar(ts); salida.AddRange(val.getSalida()); if (valor != null) { if (Program.casteos.comprobarCasteo(type, valor)) { ts.setValor(variable.Id, valor); } else { salida.Add(Program.buildError(getLine(), getColumn(), "Semantico", "No se puede convertir a" + ts.tipoAsignado(variable.Id))); } } } else { Simbolo new_simbol = new Simbolo(Program.getTipo(variable.Tipo.ToLower()), variable.Id); new_simbol.Sub_tipo = Tipo.VARIABLE; Operacion valor = (Operacion)variable.Valor; try { new_simbol.Valor = valor.Ejecutar(ts); if (new_simbol.Valor == null) { new_simbol.Valor = variable.Valor; } } catch (Exception) { new_simbol.Valor = valor; } tabla_local.AddLast(new_simbol); } while ((bool)expresion.Ejecutar(tabla_local)) { foreach (Instruccion item in instruccions) { if (item.getType() == Tipo.BREAK) { return(null); } if (item.getType() == Tipo.USER_TYPES || item.getType() == Tipo.FUNCION || item.getType() == Tipo.METODO || item.getType() == Tipo.PROCEDURE) { salida.Add(Program.buildError(item.getLine(), item.getColumn(), "Semantico", "No puede venir instruccion del tipo: " + item.getType() + " en un ambito local.")); } else { item.Ejecutar(tabla_local); salida.AddRange(item.getSalida()); item.clearSalida(); } } actualizacion.Ejecutar(tabla_local); } return(null); }
/* * Constructor de la clase padre * @ts tabla de simbolos padre * @user usuario que esta ejecutando las acciones * @baseD string por referencia de que base de datos estamos trabajando * @mensajes el output de la ejecucion */ public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT) { TablaDeSimbolos nuevoAmbito = new TablaDeSimbolos(); foreach (Simbolo s in ts) { nuevoAmbito.AddLast(s); } object inici = (inicializacion == null) ? null : ((InstruccionCQL)inicializacion).ejecutar(nuevoAmbito, ambito, tsT); if (inici != null) { System.Diagnostics.Debug.WriteLine("VALOR: " + inici); object res = (condicion == null) ? null : condicion.ejecutar(nuevoAmbito, ambito, tsT); object condi = verificarCondicion(res, ambito.mensajes); if (condi != null) { while ((Boolean)condi) { TablaDeSimbolos nuevoAmbito2 = new TablaDeSimbolos(); foreach (Simbolo s in nuevoAmbito) { nuevoAmbito2.AddLast(s); } //---------------------------------------------------- instrucciones del for ----------------------------------------------- foreach (InstruccionCQL i in cuerpo) { object resultado = i.ejecutar(nuevoAmbito2, ambito, tsT); if (resultado == null) { return(null); } else if (resultado.GetType() == typeof(Retorno)) { return((Retorno)resultado); } else if (i.GetType() == typeof(Continue) || resultado.GetType() == typeof(Continue)) { break; } } object actu = (actualizacion == null) ? null : actualizacion.ejecutar(nuevoAmbito, ambito, tsT); if (actu == null) { return(null); } res = (condicion == null) ? null : condicion.ejecutar(nuevoAmbito, ambito, tsT); condi = verificarCondicion(res, ambito.mensajes); if (condi == null) { return(null); } } return(""); } } return(null); }
/* * Metodo de la implementacion * @ts tabla de simbolos global * @user usuario que ejecuta la accion * @baseD base de datos donde estamos ejecutando todo * @mensajes linkedlist con la salida deseada */ public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT) { Mensaje ms = new Mensaje(); TablaDeSimbolos newAmbito = new TablaDeSimbolos(); foreach (Simbolo s in ambito.tablaPadre) { newAmbito.AddLast(s); } if (tamanioTotalParametros() == valores.Count()) { int index = 0; //-------------------------------------------- CREACION Y ASIGNACION DE PARAMETROS -------------------------------------------------------------- for (int i = 0; i < parametros.Count(); i++) { LinkedList <InstruccionCQL> parametro = parametros.ElementAt(i).lista; for (int j = 0; j < parametro.Count(); j++) { Declaracion d = (Declaracion)parametro.ElementAt(j); d.parametro = true; object rd = d.ejecutar(newAmbito, ambito, tsT); if (rd == null) { return(null); } Asignacion a = new Asignacion(d.id, l, c, valores.ElementAt(index), "ASIGNACION"); a.tPadre = ts; object ra = a.ejecutar(newAmbito, ambito, tsT); if (ra == null) { return(null); } index++; } } //--------------------------------------------------- INSTRUCCIONES DEL PROCEDURE ---------------------------------------------- foreach (InstruccionCQL ins in cuerpo) { object r = ins.ejecutar(newAmbito, ambito, tsT); if (r == null) { return(null); } else if (r.GetType() == typeof(Retorno)) { object re = ((Retorno)r).valor; if (re != null) { LinkedList <object> temp; if (re.GetType() == typeof(LinkedList <object>)) { temp = (LinkedList <object>)re; } else { temp = new LinkedList <object>(); temp.AddLast(re); } string idGenerado = idOut(temp); if (idGenerado == null) { return(null); } if (idGenerado.Equals(identificadorRetornos)) { return(temp); } else { ambito.listadoExcepciones.AddLast(new Excepcion("numberreturnsexception", "La cantidad de valores retornados no concuerda con el valor de parametros se esperaba: " + identificadorRetornos + " se obtuvo " + idGenerado)); ambito.mensajes.AddLast(ms.error("La cantidad de valores retornados no concuerda con el valor de parametros se esperaba: " + identificadorRetornos + " se obtuvo " + idGenerado, l, c, "Semantico")); return(null); } } return(null); } } if (identificadorRetornos.Equals("")) { return(""); } else { ambito.listadoExcepciones.AddLast(new Excepcion("numberreturnsexception", "Se necesita retornar valores de tipo: " + identificadorRetornos)); ambito.mensajes.AddLast(ms.error("Se necesita retornar valores de tipo: " + identificadorRetornos, l, c, "Semantico")); return(null); } } else { ambito.mensajes.AddLast(ms.error("La cantidad de valores no concuerda con la cantidad de parametros", l, c, "Semantico")); } return(null); }
public object Ejecutar(TablaDeSimbolos ts) { if (!global) { foreach (Variable item in variables_asignar) { if (!ts.existID_AA(item.Id.ToLower())) { Simbolo new_simbol = new Simbolo(real_type, item.Id); new_simbol.Tipo_asignado = type; string name = item.Valor.GetType().Name; if (item.Instanciada) { if (real_type == Tipo.USER_TYPES) { if (name.Equals("Tipo_Objeto")) { Tipo_Objeto objext = (Tipo_Objeto)item.Valor; List <Tipo_Objeto> objeto = (List <Tipo_Objeto>)Program.sistema.buildObject(objext.Name.ToLower()); new_simbol.Valor = objeto; } else { List <Tipo_Collection> objeto = (List <Tipo_Collection>)item.Valor; new_simbol.Valor = Program.sistema.getValor(type.ToLower(), objeto, ts); } } else if (real_type == Tipo.NUMERO || real_type == Tipo.ENTERO) { if (name.Equals("Variable")) { Variable aux_var = (Variable)item.Valor; object valor = ts.getValorByAttr(aux_var.Id, aux_var.Atributos); new_simbol.Valor = valor; } else { Operacion valor = (Operacion)item.Valor; try { new_simbol.Valor = valor.Ejecutar(ts); if (new_simbol.Valor == null) { new_simbol.Valor = item.Valor; } } catch (Exception) { new_simbol.Valor = valor; } } } else if (real_type == Tipo.MAP) { Map objeto = (Map)item.Valor; new_simbol.Valor = objeto; } else if (real_type == Tipo.LIST) { Lista objeto = (Lista)item.Valor; new_simbol.Valor = objeto; } } else { if (real_type == Tipo.NUMERO) { new_simbol.Valor = 0; } if (real_type == Tipo.USER_TYPES || real_type == Tipo.MAP || real_type == Tipo.LIST) { new_simbol.Valor = null; } } ts.AddLast(new_simbol); } else { salida.Add(Program.buildError(getLine(), getColumn(), "Semantico", item.Id + " ObjectAlreadyExists3")); } } } return(null); }
/* * Metodo de la implementacion * @ts tabla de simbolos global * @user usuario que ejecuta la accion * @baseD base de datos donde estamos ejecutando todo * @mensajes linkedlist con la salida deseada */ public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT) { Mensaje ms = new Mensaje(); TablaDeSimbolos newAmbito = new TablaDeSimbolos(); foreach (Simbolo s in ambito.tablaPadre) { newAmbito.AddLast(s); } if (parametros.Count() == valores.Count()) { //-------------------------------------- CREACION Y ASIGNACION DE PARAMETROS ----------------------------------------------------- for (int i = 0; i < parametros.Count(); i++) { Declaracion d = (Declaracion)parametros.ElementAt(i); d.parametro = true; object rd = d.ejecutar(newAmbito, ambito, tsT); if (rd == null) { return(null); } Asignacion a = new Asignacion(d.id, l, c, valores.ElementAt(i), "ASIGNACION"); a.tPadre = ts; object ra = a.ejecutar(newAmbito, ambito, tsT); if (ra == null) { return(null); } } //---------------------------------------- INSTRUCCIONES DE LA FUNCION ----------------------------------------------------------- foreach (InstruccionCQL ins in cuerpo) { object r = ins.ejecutar(newAmbito, ambito, tsT); if (r == null) { ambito.mensajes.AddLast(ms.error("Problema en la Funcion: " + id, l, c, "Semantico")); return(null); } else if (r.GetType() == typeof(Retorno)) { object re = ((Retorno)r).valor; if (re != null) { if (re.GetType() == typeof(int) && tipo.Equals("int")) { return((int)re); } else if (re.GetType() == typeof(string) && tipo.Equals("string")) { return((String)re); } else if (re.GetType() == typeof(Boolean) && tipo.Equals("boolean")) { return((Boolean)re); } else if (re.GetType() == typeof(double) && tipo.Equals("double")) { return((Double)re); } else if (re.GetType() == typeof(DateTime) && tipo.Equals("date")) { return((DateTime)re); } else if (re.GetType() == typeof(TimeSpan) && tipo.Equals("time")) { return((TimeSpan)re); } else if (re.GetType() == typeof(Map) && tipo.Equals("map")) { return((Map)re); } else if (re.GetType() == typeof(List) && tipo.Equals("list")) { return((List)re); } else if (re.GetType() == typeof(Set) && tipo.Equals("set")) { return((Set)re); } else if (re.GetType() == typeof(TypeCursor) && tipo.Equals("cursor")) { return((TypeCursor)re); } else if (re.GetType() == typeof(InstanciaUserType)) { InstanciaUserType temp = (InstanciaUserType)re; if (temp.tipo.Equals(tipo)) { return(temp); } else { ambito.mensajes.AddLast(ms.error("No coincide el tipo de USERTYPE", l, c, "Semantico")); } } else { ambito.mensajes.AddLast(ms.error("No coincide el tipo: " + tipo + " con el valor: " + re, l, c, "Semantico")); } return(null); } } } ambito.mensajes.AddLast(ms.error("La funcion no posee ningun return", l, c, "Semantico")); return(null); } else { ambito.mensajes.AddLast(ms.error("No coinciden el numero de parametros con el numero de valores", l, c, "Semantico")); } return(null); }
/* * Metodo de la implementacion * @ts tabla de simbolos global * @user usuario que ejecuta la accion * @baseD base de datos donde estamos ejecutando todo * @mensajes linkedlist con la salida deseada */ public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT) { Mensaje ms = new Mensaje(); object res = ts.getValor(id); if (!res.Equals("none")) { if (res.GetType() == typeof(TypeCursor)) { TypeCursor tabla = (TypeCursor)res; if (tabla.tabla != null) { generarIdentificador(tabla.tabla); if (tabla.tabla.columnas.Count() == parametros.Count()) { string identificadorParametros = generarIdentificadorDeclaracion(); if (identificadorParametros.Equals(identificador)) { foreach (Data data in tabla.tabla.datos) { TablaDeSimbolos newAmbito = new TablaDeSimbolos(); foreach (Simbolo s in ambito.tablaPadre) { newAmbito.AddLast(s); } //-------------------------------------- ASIGNARLE A LOS PARAMETROS LOS VALORES DE LA CONSULTA ---------------------------- for (int i = 0; i < parametros.Count(); i++) { Declaracion d = (Declaracion)parametros.ElementAt(i); d.parametro = true; object rd = d.ejecutar(newAmbito, ambito, tsT); if (rd == null) { return(null); } Atributo atributo = data.valores.ElementAt(i); newAmbito.setValor(d.id, atributo.valor); } //---------------------------------------- EJECUTAR INSTRUCCIONES DENTRO DEL FOREACH ----------------------------------------- foreach (InstruccionCQL i in cuerpo) { object resultado = i.ejecutar(newAmbito, ambito, tsT); if (resultado == null) { return(null); } else if (resultado.GetType() == typeof(Retorno)) { return((Retorno)resultado); } else if (i.GetType() == typeof(Continue) || resultado.GetType() == typeof(Continue)) { break; } } } return(""); } else { ambito.mensajes.AddLast(ms.error("No coinciden el tipo de parametros con el tipo de columnas", l, c, "Semantico")); } } else { ambito.mensajes.AddLast(ms.error("No coincide la cantidad de parametros con la cantidad de columnas", l, c, "Semantico")); } } else { ambito.mensajes.AddLast(ms.error("El cursor: " + id + " no ha sido abierto", l, c, "Semantico")); } } else { ambito.mensajes.AddLast(ms.error("La variable tiene que ser de tipo Cursor no se reconoce: " + res, l, c, "Semantico")); } } else { ambito.mensajes.AddLast(ms.error("La variable : " + id + " no existe en este ambito", l, c, "Semantico")); } return(null); }
/* * METODO DE LA CLASE PADRE QUE SE IMPLEMENTA * @param {ts} tabla de simbolos del padre * @param {ambito} ambito de atributos a manejar * @param {tsT} tabla de simbolos(CQL) del padre */ public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT) { Mensaje ms = new Mensaje(); TablaDeSimbolos newAmbito = new TablaDeSimbolos(); Boolean flagCatch = false; foreach (Simbolo s in ts) { newAmbito.AddLast(s); } foreach (InstruccionCQL ins in cuerpoTry) { object res = ins.ejecutar(newAmbito, ambito, tsT); if (res == null) { System.Diagnostics.Debug.WriteLine("TIPO: " + ins.GetType()); flagCatch = true; break; } else if (ins.GetType() == typeof(Return)) { return((Retorno)res); } } if (flagCatch) { if (ambito.listadoExcepciones.Count() > 0) { Excepcion e = (Excepcion)ambito.listadoExcepciones.Last.Value; if (e.tipo.Equals(tipo) || e.tipo.Equals("exception")) { ambito.listadoExcepciones.RemoveLast(); ambito.mensajes.RemoveLast(); newAmbito = new TablaDeSimbolos(); foreach (Simbolo s in ts) { newAmbito.AddLast(s); } newAmbito.AddLast(new Simbolo("exception", id)); newAmbito.setValor(id, e); foreach (InstruccionCQL ins in cuerpoCatch) { object res = ins.ejecutar(newAmbito, ambito, tsT); if (res == null) { System.Diagnostics.Debug.WriteLine("TIPO2: " + ins.GetType()); return(null); } else if (ins.GetType() == typeof(Return)) { return((Retorno)res); } } return(""); } else { ambito.mensajes.AddLast(ms.error("No coinciden el tipo de Excepcion en el catch con la Excepcion lanzada: " + tipo + " con: " + e.tipo, l, c, "Semantico")); } } } else { return(""); } return(null); }
/* * Constructor de la clase padre * @ts tabla de simbolos padre * @user usuario que esta ejecutando las acciones * @baseD string por referencia de que base de datos estamos trabajando * @mensajes el output de la ejecucion */ public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT) { flagCondicion = false; object a = (condicion == null) ? null : condicion.ejecutar(ts, ambito, tsT); Mensaje men = new Mensaje(); //----------------------------------------------------------- ELSE ----------------------------------------------------------- if (condicion == null) { TablaDeSimbolos ambitoLocal = new TablaDeSimbolos(); foreach (Simbolo s in ts) { ambitoLocal.AddLast(s); } TablaDeSimbolos tablaTemp = new TablaDeSimbolos(); foreach (Simbolo s in tsT) { tablaTemp.AddLast(s); } foreach (InstruccionCQL i in cuerpo) { object r = i.ejecutar(ambitoLocal, ambito, tablaTemp); if (r == null) { System.Diagnostics.Debug.WriteLine("ACCION: " + i.GetType()); return(r); } else if (r.GetType() == typeof(Retorno)) { return(r); } } return(""); } //--------------------------------------------------------------------------------- IF ELSE IF else { if (a != null) { if (a.GetType() == typeof(Boolean)) { flagCondicion = (Boolean)a; if (flagCondicion) { TablaDeSimbolos ambitoLocal = new TablaDeSimbolos(); foreach (Simbolo s in ts) { ambitoLocal.AddLast(s); } TablaDeSimbolos tablaTemp = new TablaDeSimbolos(); foreach (Simbolo s in tsT) { tablaTemp.AddLast(s); } //------------------------------------------------- INSTRUCCIONES DEL IF ----------------------------------------------- foreach (InstruccionCQL i in cuerpo) { object r = i.ejecutar(ambitoLocal, ambito, tablaTemp); if (r == null) { return(r); } else if (r.GetType() == typeof(Retorno)) { return((Retorno)r); } else if (i.GetType() == typeof(Continue)) { return(i); } } } return(""); } else { ambito.mensajes.AddLast(men.error("La condicion tiene que ser de tipo boolean no se reconoce: " + a.ToString(), l, c, "Semantico")); } } else { ambito.mensajes.AddLast(men.error("No se acepta un null como condicion", l, c, "Semantico")); } } return(null); }
/* * Metodo de la implementacion * @ts tabla de simbolos global * @user usuario que ejecuta la accion * @baseD base de datos donde estamos ejecutando todo * @mensajes linkedlist con la salida deseada */ public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT) { Mensaje mensa = new Mensaje(); object a = (valor == null) ? null : valor.ejecutar(ts, ambito, tsT); LinkedList <string> mensajes = ambito.mensajes; object res = ts.getValor(id); string baseD = ambito.baseD; string existe = (res == null) ? "si" : res.ToString(); if (parametro) { ts.AddLast(new Simbolo(tipo, id)); if (tipo.Equals("list")) { ts.setValor(id, new List("none", new LinkedList <object>())); } else if (tipo.Equals("set")) { ts.setValor(id, new Set("none", new LinkedList <object>())); } else if (tipo.Equals("map")) { ts.setValor(id, new Map("none", new LinkedList <KeyValue>())); } else if (tipo.Equals("string") || tipo.Equals("int") || tipo.Equals("double") || tipo.Equals("date") || tipo.Equals("time") || tipo.Equals("boolean") || tipo.Equals("cursor")) { } else { ts.setValor(id, new InstanciaUserType("none", new LinkedList <Atributo>())); } return(""); } else if (existe.Equals("none")) { if (valor == null) { if (tipo.Equals("int")) { ts.AddLast(new Simbolo(tipo, id)); ts.setValor(id, 0); } else if (tipo.Equals("double")) { ts.AddLast(new Simbolo(tipo, id)); ts.setValor(id, 0.0); } else if (tipo.Equals("boolean")) { ts.AddLast(new Simbolo(tipo, id)); ts.setValor(id, false); } else if (tipo.Equals("string") || tipo.Equals("date") || tipo.Equals("time")) { ts.AddLast(new Simbolo(tipo, id)); ts.setValor(id, null); return(""); } else if (tipo.Equals("map")) { mensajes.AddLast(mensa.error("El tipo MAP necesita ser instanciado", l, c, "Semantico")); return(null); } else if (tipo.Equals("list")) { mensajes.AddLast(mensa.error("El tipo LIST necesita ser instanciado", l, c, "Semantico")); return(null); } else if (tipo.Equals("set")) { mensajes.AddLast(mensa.error("El tipo SET necesita ser instanciado", l, c, "Semantico")); return(null); } else if (tipo.Equals("cursor")) { mensajes.AddLast(mensa.error("El tipo CURSOR necesita ser instanciado", l, c, "Semantico")); return(null); } else { BaseDeDatos bd = TablaBaseDeDatos.getBase(baseD); if (bd != null) { if (TablaBaseDeDatos.getUserType(tipo.ToLower(), bd)) { ts.AddLast(new Simbolo(tipo, id)); ts.setValor(id, new InstanciaUserType(tipo, null)); } else { mensajes.AddLast(mensa.error("El tipo " + tipo + " no es un userType en esta base de datos: " + baseD, l, c, "Semantico")); return(null); } } return(""); } } else { if (a != null) { if (tipo.Equals("string") && a.GetType() == typeof(string)) { ts.AddLast(new Simbolo(tipo, id)); ts.setValor(id, (string)a); } else if (tipo.Equals("int") && a.GetType() == typeof(int)) { ts.AddLast(new Simbolo(tipo, id)); ts.setValor(id, (int)a); } else if (tipo.Equals("int") && a.GetType() == typeof(Double)) { ts.AddLast(new Simbolo(tipo, id)); ts.setValor(id, Convert.ToInt32((Double)a)); } else if (tipo.Equals("double") && a.GetType() == typeof(Double)) { ts.AddLast(new Simbolo(tipo, id)); ts.setValor(id, (Double)a); } else if (tipo.Equals("double") && a.GetType() == typeof(int)) { ts.AddLast(new Simbolo(tipo, id)); ts.setValor(id, Convert.ToDouble((int)a)); } else if (tipo.Equals("boolean") && a.GetType() == typeof(Boolean)) { ts.AddLast(new Simbolo(tipo, id)); ts.setValor(id, (Boolean)a); } else if (tipo.Equals("date") && a.GetType() == typeof(DateTime)) { ts.AddLast(new Simbolo(tipo, id)); ts.setValor(id, (DateTime)a); } else if (tipo.Equals("time") && a.GetType() == typeof(TimeSpan)) { ts.AddLast(new Simbolo(tipo, id)); ts.setValor(id, (TimeSpan)a); } else if (tipo.Equals("map") && a.GetType() == typeof(Map)) { ts.AddLast(new Simbolo(tipo, id)); ts.setValor(id, (Map)a); } else if (tipo.Equals("list") && a.GetType() == typeof(List)) { ts.AddLast(new Simbolo(tipo, id)); ts.setValor(id, (List)a); } else if (tipo.Equals("set") && a.GetType() == typeof(Set)) { ts.AddLast(new Simbolo(tipo, id)); Set temp = (Set)a; object resp = temp.buscarRepetidos(mensajes, l, c); if (resp == null) { return(null); } temp.order(); ts.setValor(id, temp); } else if (tipo.Equals("cursor") && a.GetType() == typeof(TypeCursor)) { ts.AddLast(new Simbolo(tipo, id)); ts.setValor(id, (TypeCursor)a); } else if (a.GetType() == typeof(InstanciaUserType)) { InstanciaUserType ins = (InstanciaUserType)a; if (tipo.Equals(ins.tipo.ToLower())) { ts.AddLast(new Simbolo(tipo, id)); ts.setValor(id, ins); } else { Mensaje me = new Mensaje(); mensajes.AddLast(me.error("La variable " + id + " es de Tipo: " + tipo + " no se puede instanciar al tipo: " + ins.tipo, l, c, "Semantico")); } } else { Mensaje me = new Mensaje(); mensajes.AddLast(me.error("La variable " + id + " no se le puede asignar este valor " + a.ToString(), l, c, "Semantico")); return(null); } return(""); } else { if (tipo.Equals("string") || tipo.Equals("date") || tipo.Equals("time")) { ts.AddLast(new Simbolo(tipo, id)); ts.setValor(id, null); } else if (tipo.Equals("int") || tipo.Equals("double") || tipo.Equals("map") || tipo.Equals("set") || tipo.Equals("list") || tipo.Equals("cursor") || tipo.Equals("boolean")) { mensajes.AddLast(mensa.error("No se le puede asignar un valor null al tipo: " + tipo, l, c, "Semantico")); return(null); } else { ts.AddLast(new Simbolo(tipo, id)); ts.setValor(id, new InstanciaUserType(tipo, null)); } return(""); } } } else { Mensaje me = new Mensaje(); ambito.listadoExcepciones.AddLast(new Excepcion("objectalreadyexists", "La variable " + id + " ya existe en este ambito")); mensajes.AddLast(me.error("La variable " + id + " ya existe en este ambito", l, c, "Semantico")); } return(null); }