public Object crearTabla(ZContenedor e) { if (!data.Exists(v => v is NodoCrearNombre) || !data.Exists(v => v is NodoColumns)) { throw new SemanticError(" no se definio el atrbuto tipo o los parametros del objeto"); } string nombre = (string)data.First(v => v is NodoCrearNombre).ejecutar(e); NodoColumns nC = (NodoColumns)data.First(v => v is NodoColumns); nC.definirTabla(nombre); nC.ejecutar(e); Tabla tab = Dbms.getBd().getTabla(nombre); if (!data.Exists(v => v is NodoData)) { throw new SemanticError("no existe este el atributo data"); } NodoData nD = (NodoData)data.First(v => v is NodoData); List <NodoFila> nodoFilas = nD.Filas; foreach (NodoFila nodo in nodoFilas) { ZFila entorno = tab.crearFila(); nodo.ejecutar(entorno); tab.addFila(entorno); } //------------------------------------------------------------- return(null); }
public override object ejecutarSinposicion(ZContenedor e) { bd = Dbms.BdSeleccionada; if (!data.Exists(v => v is NodoObtenerTipo)) { throw new SemanticError(" no se definio el atrbuto tipo"); } var nTipo = data.First(v => v is NodoObtenerTipo); string tipo = (string)nTipo.ejecutar(e); if (tipo.Equals("object")) { return(crearObjeto(e)); } if (tipo.Equals("table")) { return(crearTabla(e)); } if (tipo.Equals("procedure")) { return(crearProc(e)); } return(null); }
public override object ejecutarSinposicion(ZContenedor e) { while (Utilidades.evaluarCondicion(exp, e).obtenerValor()) { ZContenedor local = new ZContenedor(e, null); local.enFuncion = e.enFuncion; local.enProcedimiento = e.enProcedimiento; var result = Utilidades.ejecutarSentencias(lInstrucciones, local); if (result is NodoBreak) { return(null); } if (result is NodoContinue) { continue; } if (result is Retorno || result is RetornoProc) { return(result); } } return(null); }
public ZContenedor casteoExplicitoCadnea(ZContenedor valor) { if (valor is ZDate n1) { return(new ZCadena(n1.stringBonito())); } if (valor is ZTiempo n2) { return(new ZCadena(n2.stringBonito())); } if (valor is ZNumero n3) { return(new ZCadena(n3.obtenerValor() + "")); } if (valor is ZDecimal n4) { return(new ZCadena(n4.obtenerValor() + "")); } if (valor is ZCadena) { return(valor); } throw new SemanticError("se esta intentando castear un tipo a string no compatible"); }
public object crearProc(ZContenedor e) { if (!data.Exists(v => v is NodoCrearNombre) || !data.Exists(v => v is NodoParametro) || !data.Exists(v => v is NodoCrearInstruProc)) { throw new SemanticError(" no se definio el atrbuto tipo o los parametros del procedimiento"); } string nombre = (string)data.First(v => v is NodoCrearNombre).ejecutar(e); List <NodoCrearParametro> list = (List <NodoCrearParametro>)data.First(v => v is NodoParametro).ejecutar(e); List <NodoDeclararParametro> lEntrada = new List <NodoDeclararParametro>(); List <NodoDeclararParametro> lSalida = new List <NodoDeclararParametro>(); foreach (NodoCrearParametro nodo in list) { if (nodo.isIn()) { lEntrada.Add((NodoDeclararParametro)nodo.ejecutar(e)); } else { lSalida.Add((NodoDeclararParametro)nodo.ejecutar(e)); } } List <Instruccion> lis = (List <Instruccion>)data.First(v => v is NodoCrearInstruProc).ejecutar(e); NodoDeclararProce nProc = new NodoDeclararProce(nombre, lEntrada, lSalida, lis); return(nProc.ejecutar(e)); }
public void ejecutarAnalizador(string entrada) { AnalizadorChison analizador = new AnalizadorChison(); Parser parser = new Parser(analizador); ParseTree arbol = parser.Parse(entrada); ParseTreeNode raiz = arbol.Root; if (raiz == null || arbol.ParserMessages.Count > 0 || arbol.HasErrors()) { if (raiz == null || arbol.ParserMessages.Count > 0 || arbol.HasErrors()) { //---------------------> Hay Errores foreach (var item in arbol.ParserMessages) { MessageBox.Show("Error->" + item.Message + " Line:" + item.Location.Line); } return; } } List <Instruccion> listIns = (List <Instruccion>)arbol.Root.AstNode; ZContenedor global = new ZContenedor(null, null); Dbms.cargarTedeUs(); EjecutarAnalizadorCQL.loadToday(global); EjecutarAnalizadorCQL.loadNow(global); Utilidades.ejecutarSenteciass(listIns, global); BaseDeDatos bd = Dbms.BdSeleccionada; Console.WriteLine("--- analizado chison ---"); }
public override object ejecutarSinposicion(ZContenedor e) { Tabla tab = Dbms.getBd().getTabla(nombreTabla); tab.alterAdd(encabezados); return(null); }
public override object ejecutarSinposicion(ZContenedor e) { var sim = i1.ejecutar(e); if (sim is Simbolo s1) { var val = Utilidades.desenvolver(s1); if (val is ZNumero n1) { ZNumero novo = new ZNumero(n1.obtenerValor() - 1); s1.definirValor(novo); return(new ZNumero(n1.obtenerValor())); } if (val is ZDecimal n2) { ZDecimal novo = new ZDecimal(n2.obtenerValor() - 1); s1.definirValor(novo); return(new ZDecimal(n2.obtenerValor()));; } throw new SemanticError("error en exp--; tipos no compatbiles"); } throw new SemanticError("el lado izquierdo no es un simbolo exp--"); }
public override object ejecutarSinposicion(ZContenedor e) { TeDeU tipo = e.getTeDeU("int"); tipo.isCount = true; return(tipo); }
public override object ejecutarSinposicion(ZContenedor e) { if (entrada == "") { return(new List <Instruccion>()); } AnalizadorCQL an = new AnalizadorCQL(); Parser parser = new Parser(an); ParseTree arbol = parser.Parse(entrada); ParseTreeNode raiz = arbol.Root; //verificar si el arbol no sta nulo if (raiz == null || arbol.ParserMessages.Count > 0 || arbol.HasErrors()) { if (raiz == null || arbol.ParserMessages.Count > 0 || arbol.HasErrors()) { //---------------------> Hay Errores foreach (var item in arbol.ParserMessages) { MessageBox.Show("Error->" + item.Message + " Line:" + item.Location.Line); } return(null); } } List <Instruccion> listIns = (List <Instruccion>)arbol.Root.AstNode; return(listIns ?? new List <Instruccion>()); }
public override object ejecutarSinposicion(ZContenedor e) { BaseDeDatos bd = Dbms.crearBDChison(nombre); Dbms.seleccionarBaseDeDatos(nombre); return(bd); }
public virtual ZContenedor ejecutarFuncion(List <ZContenedor> argumentos) { ZContenedor ambitoFuncion = new ZContenedor(ambitoCapturado, null); ambitoFuncion.enFuncion = true; //los argumentos ya estan desembueltos for (int i = 0; i < nodosDeclararParametro.Count; i++) { Simbolo sim = (Simbolo)nodosDeclararParametro[i].ejecutarSinposicion(ambitoFuncion); sim.definirValor(argumentos[i]); } var result = Utilidades.ejecutarSentencias(listaInstrucciones, ambitoFuncion); //las funciones siempre tienn que retornar algo if (!(result is Retorno r)) { throw new SemanticError("Error la funcion no devuelve nignun valor"); } if (tipoRetorno == r.Tipo || r.Tipo == TiposPrimitivos.tipoNulo) { return(r.Valor); //valor es un Z o sea un z valor } throw new SemanticError("Error la funcion, no es del mismo tipo con el que se retorna"); }
public override object ejecutarSinposicion(ZContenedor e) { var algo1 = i1.ejecutar(e); var algo2 = i2.ejecutar(e); ZContenedor valor1 = Utilidades.desenvolver(algo1); ZContenedor valor2 = Utilidades.desenvolver(algo2); if (valor1 is ZNumero n1 && valor2 is ZNumero n2) { return(new ZNumero(n1.obtenerValor() % n2.obtenerValor())); } if (valor1 is ZDecimal n11 && valor2 is ZDecimal n12) { return(new ZDecimal(n11.obtenerValor() % n12.obtenerValor())); } if (valor1 is ZNumero n111 && valor2 is ZDecimal n122) { return(new ZDecimal(n111.obtenerValor() % n122.obtenerValor())); } if (valor1 is ZDecimal n11a && valor2 is ZNumero n12b) { return(new ZDecimal(n11a.obtenerValor() % n12b.obtenerValor())); } throw new SemanticError("Error; operacion % no compatible con tipos"); }
public static ZBool IgualIgual(ZContenedor valor1, ZContenedor valor2) { if (valor1 is ZBool b1 && valor2 is ZBool b2) { return(new ZBool(b1.obtenerValor() == b2.obtenerValor())); } if (valor1 is ZCadena c1 && valor2 is ZCadena c2) { return(new ZBool(c1.obtenerValor() == c2.obtenerValor())); } if (valor1 is ZDecimal d1 && valor2 is ZDecimal d2) { return(new ZBool(d1.obtenerValor() == d2.obtenerValor())); } if (valor1 is ZNumero n1 && valor2 is ZNumero n2) { return(new ZBool(n1.obtenerValor() == n2.obtenerValor())); } if (valor1 is ZNumero n3 && valor2 is ZDecimal d3) { return(new ZBool(n3.obtenerValor() == d3.obtenerValor())); } if (valor1 is ZDecimal d4 && valor2 is ZNumero n4) { return(new ZBool(d4.obtenerValor() == n4.obtenerValor())); } if (valor1 is ZDate d5 && valor2 is ZDate n5) { return(new ZBool(d5.obtenerValor().Equals(n5.obtenerValor()))); } if (valor1 is ZTiempo d6 && valor2 is ZTiempo n6) { return(new ZBool(d6.obtenerValor().Equals(n6.obtenerValor()))); } if ((valor1 is ZInstancia || valor1.Origen == TiposPrimitivos.tipoNulo) && (valor2 is ZInstancia || valor2.Origen == TiposPrimitivos.tipoNulo)) { return(new ZBool(valor1 == valor2)); } if (valor1 is ZCadena d9 && valor2 is ZNull) { return(new ZBool(d9.obtenerValor() == null)); } if (valor1 is ZNull && valor2 is ZCadena d10) { return(new ZBool(d10.obtenerValor() == null)); } return(null); }
public void pruebaCqlFuncionesList() { var entrada = @" list<int> ids = []; log(ids); ids.insert(1993); ids.insert(93); ids.insert(17); log(ids); log(ids.get(1)); ids.set(1, 993); log(ids); ids.remove(1); log(ids); log(ids.size()); log(ids.contains(17)); log(ids.contains(18)); ids.clear(); log(ids); "; var an = new AnalizadorCQL(); var parser = new Parser(an); var arbol = parser.Parse(entrada); var mensajes = arbol .ParserMessages .Select(message => $"{message.Location} - {message.Message}") ; var errores = string.Join("\n", mensajes); Assert.IsFalse(arbol.HasErrors(), errores); List <Instruccion> listIns = (List <Instruccion>)arbol.Root.AstNode; ZContenedor global = new ZContenedor(null, null); Dbms.cargarTedeUs(); Utilidades.cargarFuncionesNativas(global); //funciones // loadToday(global); // loadNow(global); Utilidades.ejecutarSentencias(listIns, global); }
public RetornoProc enProcedimiento(ZContenedor e) { NodoCrearTupla aux = new NodoCrearTupla(listaExp); ZTupla tupla = (ZTupla)aux.ejecutar(e); RetornoProc ret = new RetornoProc(tupla); return(ret); }
public override object ejecutarSinposicion(ZContenedor e) { ZBool cond = Utilidades.evaluarCondicion(condicion, e); return(cond.obtenerValor() ? Utilidades.desenvolver(valor1.ejecutar(e)) : Utilidades.desenvolver(valor2.ejecutar(e))); }
public override object ejecutarSinposicion(ZContenedor e) { Object algo = exp.ejecutar(e); ZContenedor zAlgo = Utilidades.desenvolver(algo); Simbolo sim = acPunto(zAlgo, id); return(sim); }
public override object ejecutarSinposicion(ZContenedor e) { Tabla tab = Dbms.getBd().getTabla(id); tab.truncate(); return(null); }
public override object ejecutarSinposicion(ZContenedor e) { var algo = expresion.ejecutar(e); ZContenedor valor = Utilidades.desenvolver(algo); List <ZContenedor> argumentos = Utilidades.desnvolverArgumento(this.argumentos, e); return(Utilidades.invocarFuncionPunto(valor, id, argumentos)); }
public override object ejecutarSinposicion(ZContenedor e) { Tabla tab = Dbms.getBd().getTabla(nombreTabla); tab.alterDrop(listaId); return(null); }
public override object ejecutarSinposicion(ZContenedor e) { TeDeU ti = (TeDeU)tipo.ejecutar(e); Funcion funcion = new Funcion(ti, parametros, lInsturcciones, e); e.declararFuncion(id, funcion); return(null); }
public override object ejecutarSinposicion(ZContenedor e) { BaseDeDatos bd = (BaseDeDatos)this.bd.ejecutar(e); Utilidades.ejecutarSenteciass(data, e); return(null); }
public Simbolo acPunto(ZContenedor Zalgo, string id) { if (Zalgo.exsiteVariableActual(id)) { return(Zalgo.getVariableActual(id)); } throw new SemanticError("no posee el valor " + id); }
public void pruebaCqlFuncionesAgregacion() { var entrada = @" create database prueba; use prueba; create table alumnos (peso int, edad int); insert into alumnos values (50, 26); insert into alumnos values (502, 36); insert into alumnos values (93, 17); int algo = count(<<select * from alumnos>>); log(algo); int sumaTotal = sum(<< select edad from alumnos >>); log(sumaTotal); int promedio = avg(<< select edad from alumnos >>); log(promedio); int maximo = max(<< select edad from alumnos >>); int minimo = min(<< select edad from alumnos >>); log(maximo); log(minimo); "; var an = new AnalizadorCQL(); var parser = new Parser(an); var arbol = parser.Parse(entrada); var mensajes = arbol .ParserMessages .Select(message => $"{message.Location} - {message.Message}") ; var errores = string.Join("\n", mensajes); Assert.IsFalse(arbol.HasErrors(), errores); List <Instruccion> listIns = (List <Instruccion>)arbol.Root.AstNode; ZContenedor global = new ZContenedor(null, null); Dbms.cargarTedeUs(); Utilidades.cargarFuncionesNativas(global); //funciones // loadToday(global); // loadNow(global); Utilidades.ejecutarSentencias(listIns, global); }
public void setValor(int indice, ZContenedor valor) { if (indice < 0 || indice >= this.Elementos.Count) { throw new SemanticError($"Accesso [{indice}] fuera de rango [0..{this.Elementos.Count}]"); } this.Elementos[indice] = valor; }
public Funcion(TeDeU tipoRetorno, List <NodoDeclararParametro> nodosDeclararParametro, List <Instruccion> listaInstrucciones, ZContenedor ambitoCapturado) { this.tipoRetorno = tipoRetorno; this.nodosDeclararParametro = nodosDeclararParametro; this.listaInstrucciones = listaInstrucciones; this.ambitoCapturado = ambitoCapturado; //se valida que el ambito capturado sea una funcion }
public override object ejecutarSinposicion(ZContenedor e) { var tab = (Tabla)tabla.ejecutar(e); var result = procesarFilas(tab.Filas); imprimirTabla(result); return(new ZResultadoQuery(result)); }
public static object ejecutarSenteciass(List <Instruccion> lista, ZContenedor f) { foreach (Instruccion ins in lista) { ins.ejecutar(f); } return(null); }
public override object ejecutarSinposicion(ZContenedor e) { TeDeU nuevoTeDeU = new TeDeU(id); nuevoTeDeU.definirListaDeclaraciones(listaAtributos); e.setTeDeU(id, nuevoTeDeU); //se declara el TeDeU return(null); }