private List <Object> getValoresParam(Ambito ambito) { List <Object> valores = new List <object>(); foreach (Expresion e in this.expresiones) { //object val = e.getValor(ambito); object val = e.getValor(Estatico.temporal); if (val != null) { valores.Add(val); } } return(valores); }
/* * 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 valores = (expresion == null) ? null : expresion.ejecutar(ts, ambito, tsT); LinkedList <string> mensajes = ambito.mensajes; if (valores != null) { if (valores.GetType() == typeof(LinkedList <object>)) { LinkedList <object> lista = (LinkedList <object>)valores; if (lista.Count() == listaId.Count()) { for (int i = 0; i < lista.Count(); i++) { string tipo = ts.getTipo(listaId.ElementAt(i)).ToLower().TrimEnd().TrimStart(); if (!tipo.Equals("none")) { object res = checkValues(lista.ElementAt(i), tipo, mensajes, ts, listaId.ElementAt(i)); if (res == null) { return(null); } } else { mensajes.AddLast(ms.error("La variable: " + listaId.ElementAt(i) + " no existe en este ambito", l, c, "Semantico")); return(null); } } return(""); } else { mensajes.AddLast(ms.error("No coincide la cantidad de valores con la cantidad de variables", l, c, "Semantico")); } } else { mensajes.AddLast(ms.error("No se puede asignar este valor: " + valores + " a la lista de ID'S", l, c, "Semantico")); } } else { mensajes.AddLast(ms.error("No se puede asignar un valor null a la lista de ID's", l, c, "Semantico")); } return(null); }
public object Ejecutar(Ambito ambito) { try { object path = ruta.getValor(ambito); object condicion = condicional.getValor(ambito); if (path is String && condicion is Boolean) { //String currentDir = System.IO.Directory.GetCurrentDirectory() + "\\"; String currentDir = Estatico.PROYECT_PATH + "\\"; String cad = (String)path; Boolean cond = (Boolean)condicion; if (System.IO.File.Exists(cad)) { XForms.GUI.Funciones.DisplayImage im = new GUI.Funciones.DisplayImage(cad); im.ShowDialog(); } else if (System.IO.File.Exists(currentDir + cad)) { XForms.GUI.Funciones.DisplayImage im = new GUI.Funciones.DisplayImage(currentDir + cad); im.ShowDialog(); } else { TError error = new TError("Semantico", "La ruta de la Imagen a desplegar no existe, Ruta: \"" + cad + "\" | Tampoco se encontro en el directorio raiz: \"" + currentDir + "\" | Clase: " + clase + " | Archivo: " + ambito.archivo, linea, columna, false); Estatico.ColocaError(error); Estatico.errores.Add(error); } return(new Nulo()); } else { TError error = new TError("Semantico", "La funcion Imagen() recibe como parametros unicamente: (Cadena, Booleano) | Clase: " + clase + " | Archivo: " + ambito.archivo, linea, columna, false); Estatico.ColocaError(error); Estatico.errores.Add(error); } } catch (Exception e) { TError error = new TError("Ejecucion", "Error al ejecutar la funcion Imagen() | Clase: " + clase + " | Archivo: " + ambito.archivo + " | Mensaje: " + e.Message, linea, columna, false); Estatico.ColocaError(error); Estatico.errores.Add(error); } return(new Nulo()); }
public FCaso(Ambito amb, String tipo, Object valor) { this.ambito = amb; this.Tipo = tipo; switch (this.Tipo) { case Constante.TNumber: this.ValNumero = Double.Parse(valor.ToString()); break; case Constante.TString: this.ValCadena = valor.ToString(); break; } }
public string getTipo(Ambito ambito) { if (valor is int) { return("entero"); } if (valor is String) { return("cadena"); } if (valor is double) { return("decimal"); } return("nulo"); }
public object Ejecutar(Ambito ambito) { try { call.getValor(ambito); return(new Nulo()); } catch { TError error = new TError("", "Error en la ejecucion de la llamada a funcion | Clase: " + this.clase + " | Archivo: " + ambito.archivo, linea, columna, false); Estatico.errores.Add(error); Estatico.ColocaError(error); } return(new Nulo()); }
public object getValor(Ambito ambito) { try { Object val = this.valor.getValor(ambito); this.val = val.ToString(); return(this.val); } catch (Exception e) { TError error = new TError("Ejecucion", "Error al intentar comventir en cadena: Funcion: Cadena() | Clase: " + this.clase + " | Archivo: " + ambito.archivo + " | Mensaje: " + e.Message, linea, columna, false); Estatico.errores.Add(error); Estatico.ColocaError(error); } return(new Nulo()); }
public object getValor(Ambito ambito) { try { DateTime ahora = DateTime.Now; Date d = new Date(ahora); return d; } catch(Exception e) { TError error = new TError("Ejecucion", "Error al ejecutar la funcion hoy() | Clase: " + this.clase + " | Archivo: " + ambito.archivo + " | Mensaje: " + e.Message, linea, columna, false); Estatico.errores.Add(error); Estatico.ColocaError(error); } return new Nulo(); }
public object ejecutar(Ambito amb, AST arbol) { if ((bool)(Condicion.getValorImplicito(amb, arbol))) { //Si se cumple Ambito local = new Ambito(amb); foreach (NodoAST nodo in condInstrucciones) { if (nodo is Instruccion) { Instruccion ins = (Instruccion)nodo; object result = ins.ejecutar(local, arbol); if (result != null) { return(result); } } else if (nodo is Exp) { Exp expr = (Exp)nodo; return(expr.getValorImplicito(local, arbol)); } } }//Si no se cumple else { Ambito local = new Ambito(amb); foreach (NodoAST nodo in InstruccionesElse) { if (nodo is Instruccion) { Instruccion ins = (Instruccion)nodo; object result = ins.ejecutar(local, arbol); if (result != null) { return(result); } } else if (nodo is Exp) { Exp expr = (Exp)nodo; return(expr.getValorImplicito(local, arbol)); } } } return(null); }
private Type dameTipo(Ambito ambitoPregunta) { Simbolo s = (Simbolo)ambitoPregunta.getSimbolo("respuesta"); if (s != null) { String tipo = s.Tipo.ToLower(); switch (tipo) { case "booleano": { return(typeof(Boolean)); } case "entero": { return(typeof(int)); } case "decimal": { return(typeof(double)); } case "cadena": { return(typeof(String)); } case "fecha": { return(typeof(Date)); } case "hora": { return(typeof(Hour)); } case "fechahora": { return(typeof(DateTime)); } } } return(null); }
private void declaracionApartirDeArbol(Ambito ambito) { if (!ambito.existeVariable(this.idArr.ToLower())) { GeneradorArreglo gen = new GeneradorArreglo(this.arbolArreglo); if (!gen.huboError) { int numaux = gen.numDimensiones; if (NumDim == gen.numDimensiones) { ///FALTA COMPROBAR SI TODOS LOS ELEMENTOS DEL ARREGLO SON DEL MISMO TIPO /// List <Object> valores = linealizadaValores(gen.linealizacion, ambito); if (valores != null) { Arreglo arr = new Arreglo(this.arbolArreglo, valores, gen.dimensiones, this.NumDim, this.idArr.ToLower(), true, this.visibilidad, this.tipo); ambito.agregarVariableAlAmbito(this.idArr.ToLower(), arr); } else { TError error = new TError("Semantico", "El Arreglo: \"" + this.idArr + "\" no concuerda con el tipo esperado: " + this.tipo + " | Clase: " + this.clase + " | Archivo: " + ambito.archivo, this.linea, this.columna, false); Estatico.errores.Add(error); Estatico.ColocaError(error); } } else { TError error = new TError("Semantico", "Las dimensiones declaradas para: \"" + this.idArr + "\" No concuerdan, Se esperaban: " + this.NumDim + " y se encontro: " + gen.numDimensiones + " | Clase: " + this.clase + " | Archivo: " + ambito.archivo, this.linea, this.columna, false); Estatico.errores.Add(error); Estatico.ColocaError(error); } } else { TError error = new TError("Semantico", "Declaracion erreonea de Arreglo: \"" + this.idArr + "\" en este Ambito | Error: " + gen.mensajesError + " | Clase: " + this.clase + " | Archivo: " + ambito.archivo, this.linea, this.columna, false); Estatico.errores.Add(error); Estatico.ColocaError(error); } } else { TError error = new TError("Semantico", "Ya existe una declaracion de: \"" + this.idArr + "\" en este Ambito | Clase: " + this.clase + " | Archivo: " + ambito.archivo, this.linea, this.columna, false); Estatico.errores.Add(error); Estatico.ColocaError(error); } }
private void ejecutaLasDeclaracionesPregunta(Ambito ambito, List <Instruccion> declaraciones) { foreach (Instruccion instruccion in declaraciones) { if (instruccion is DeclaracionFuncion) { instruccion.Ejecutar(ambito); } } foreach (Instruccion instruccion in declaraciones) { if (instruccion is DeclaracionVar || instruccion is DeclaracionArreglo) { instruccion.Ejecutar(ambito); } } }
public string getTipo(Ambito ambito) { if (this.valor is bool) { return("Booleano"); } else if (this.valor is string) { return("Cadena"); } else if (this.valor is int) { return("Entero"); } else if (this.valor is double) { return("Decimal"); } else if (this.valor is System.DateTime) { return("FechaHora"); } else if (this.valor is Date) { return("Fecha"); } else if (this.valor is Hour) { return("Hora"); } else if (this.valor is Nulo) { return("Nulo"); } else if (this.valor is Objeto) { Objeto aux = (Objeto)this.valor; return(aux.idClase); } else if (this.valor is Arreglo) { return("Arreglo"); } //AQUI FALTA EL TIPO OBJETO return("Objeto"); }
private List <int> getDimensiones(Ambito ambito) { List <int> dims = new List <int>(); foreach (Expresion e in this.dimensiones) { Object valor = e.getValor(ambito); if (valor is int) { dims.Add((int)valor); } else { return(null); } } return(dims); }
//Actualizar estado public async Task UpdateEstado(Ambito Ambito) { try { var _Ambito = await _ctx.Ambito.FirstOrDefaultAsync(e => e.AmbitoId == Ambito.AmbitoId); if (_Ambito != null) { _Ambito.estado = Ambito.estado; await _ctx.SaveChangesAsync(); } } catch (Exception e) { throw new Exception(e.Message, e); } }
public object getValor(Ambito ambito) { try { Object cad = cadena.getValor(ambito); String tipoCad = cadena.getTipo(ambito); Object pos = posicion.getValor(ambito); String tipoPos = posicion.getTipo(ambito); if (cad is String && pos is int) { String cadenaAux = (String)cad; int posi = (int)pos; if (posi > 0 && posi < cadenaAux.Length) { char aux = cadenaAux[posi]; tipo = aux.ToString(); return(tipo); } else { TError error = new TError("Semantico", "La funcion PosCad, el parametro entero debe estar dentro de los limites: 0 y " + cadenaAux.Length + " | Clase: " + this.clase + " | Archivo: " + ambito.archivo, linea, columna, false); Estatico.errores.Add(error); Estatico.ColocaError(error); } } else { TError error = new TError("Semantico", "Funcion PosCad requiere parametros: (cadena, entero) y se encontro: (" + tipoCad + "," + tipoPos + ") | Clase: " + this.clase + " | Archivo: " + ambito.archivo, linea, columna, false); Estatico.errores.Add(error); Estatico.ColocaError(error); } } catch (Exception e) { TError error = new TError("Ejecucion", "Error al ejecutar la funcion Poscade | Clase: " + clase + " | Archivo: " + ambito.archivo + " | Mensaje: " + e.Message, linea, columna, false); Estatico.errores.Add(error); Estatico.ColocaError(error); } return(new Nulo()); }
//Actualizar Ambito public async Task Update(Ambito Ambito) { try { var _Ambito = await _ctx.Ambito.FirstOrDefaultAsync(e => e.AmbitoId == Ambito.AmbitoId); if (_Ambito != null) { _Ambito.Descripcion = Ambito.Descripcion; _Ambito.DescripcionCorta = Ambito.DescripcionCorta; await _ctx.SaveChangesAsync(); } } catch (Exception e) { throw new Exception(e.Message, e); } }
public object getValor(Ambito ambito) { try { Object valor = this.exp.getValor(ambito); if (valor is String) { String real = (String)valor; try { DateTime aux = DateTime.ParseExact(real + " 00:00:00", "dd/MM/yyyy hh:mm:ss", System.Globalization.CultureInfo.InvariantCulture); Date fecha = new Date(aux); this.val = fecha.ToString(); return(fecha); } catch { TError error = new TError("Semantico", "No se encontro una cadena que cumpla con el formato: dd/mm/yyyy para la funcion Fecha() / o se ingreso valor invalido | Clase: " + this.clase + " | Archivo: " + ambito.archivo, linea, columna, false); Estatico.errores.Add(error); Estatico.ColocaError(error); } } else if (valor is Date) { this.val = valor.ToString(); return(valor); } else { TError error = new TError("Semantico", "La funcion Fecha() recibe como parametros solo una cadena | Clase: " + this.clase + " | Archivo: " + ambito.archivo, linea, columna, false); Estatico.errores.Add(error); Estatico.ColocaError(error); } } catch (Exception e) { TError error = new TError("Ejecucion", "Error al intentar convertir cadena a Fecha: Funcion: Fecha() | Clase: " + this.clase + " | Archivo: " + ambito.archivo + " | Mensaje: " + e.Message, linea, columna, false); Estatico.errores.Add(error); Estatico.ColocaError(error); } return(new Nulo()); }
public object getValor(Ambito ambito) { try { Object valor = this.exp.getValor(ambito); if (valor is String) { try { String aux = (String)valor; DateTime real = DateTime.ParseExact("12/10/1996 " + aux, "dd/MM/yyyy hh:mm:ss", System.Globalization.CultureInfo.InvariantCulture); Hour hora = new Hour(real); this.val = hora.ToString(); return(hora); } catch { TError error = new TError("Semantico", "El formato de la cadena para la funcion Hora() no cumple el formato: hh:mm:ss / o se ingreso valor invalido | Clase: " + clase + " | Archivo: " + ambito.archivo, linea, columna, false); Estatico.ColocaError(error); Estatico.errores.Add(error); } } else if (valor is Hour) { this.val = valor.ToString(); return(valor); } else { TError error = new TError("Semantico", "La funcion Hora() unicamente puede recibir una cadena como parametro una cadena | Clase: " + clase + " | Archivo: " + ambito.archivo, linea, columna, false); Estatico.ColocaError(error); Estatico.errores.Add(error); } } catch (Exception e) { TError error = new TError("Ejecucion", "Error al intentar convertir cedena a hora, en funcion Hora() | Clase: " + this.clase + " | Archivo: " + ambito.archivo + " | Mensaje: " + e.Message, linea, columna, false); Estatico.errores.Add(error); Estatico.ColocaError(error); } return(new Nulo()); }
private Opciones dameOpciones(Ambito ambitoObjet) { try { Simbolo s = (Simbolo)ambitoObjet.getSimbolo("cutz"); if (s != null) { Variable v = (Variable)s; Opciones op = (Opciones)v.valor; return(op); } return(new Opciones("nada", new Ambito(null, "nada"))); } catch { return(new Opciones("nada", new Ambito(null, "nada"))); } }
/* * 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) { if (valor != null) { if (valor.GetType() == typeof(Expresion)) { object res = (valor == null) ? null : ((Expresion)valor).ejecutar(ts, ambito, tsT); return(new Retorno(res)); } LinkedList <Expresion> listaExpresiones = (LinkedList <Expresion>)valor; LinkedList <object> valoresReturn = new LinkedList <object>(); foreach (Expresion e in listaExpresiones) { object res = (e == null) ? null : e.ejecutar(ts, ambito, tsT); valoresReturn.AddLast(res); } return(new Retorno(valoresReturn)); } return(new Retorno(null)); }
public object getValor(Ambito ambito) { try { Estatico.temporal = ambito; //AQUI SETEO EL TEMPORAL if (this.expresiones.Count == 1) //SI SOLO SE HACE REFERENCIA A UN ID O UNA LLAMADA A UNA FUNCION { this.valorAux = expresiones.ElementAt(0).getValor(ambito); if (valorAux is Este) { //return new Nulo(); return(new Este()); } return(valorAux); } else if (this.expresiones.Count > 1)//AQUI ES DONDE YA SE VA A HACER REFERENCIA A OBJETOS { Ambito ambitoAux = null; Object auxiliar = this.expresiones.ElementAt(0).getValor(ambito); if (auxiliar is Este) { ambitoAux = (Ambito)buscaAtributoDeClase(ambito); return(recorreExpresiones(ambitoAux, auxiliar)); } else if (auxiliar is Objeto) { Objeto ob = (Objeto)auxiliar; ambitoAux = ob.ambito; return(recorreExpresiones(ambitoAux, ob)); } return(new Nulo()); } } catch (Exception e) { TError error = new TError("Ejecucion", "Ocurrio un Error al acceder a Objeto en Clase: " + this.clase + " | Archivo: " + ambito.archivo + " | Error: " + e.Message, this.linea, this.columna, false); Estatico.errores.Add(error); Estatico.ColocaError(error); } return(new Nulo()); }
public object getValor(Ambito ambito) { try { Object valor = exp.getValor(ambito); if (valor is int) { int v = (int)valor; if (v < 0) { this.valor = 0.0; return(0.0); } this.valor = Math.Log10(v); return(this.valor); } else if (valor is double) { double v = (double)valor; if (v < 0) { this.valor = 0.0; return(0.0); } this.valor = Math.Log10(v); return(this.valor); } else { TError error = new TError("Semantico", "El parametro que reciba la Funcion Log10() puede ser Entero o Decimal | Clase: " + this.clase + " | Archivo: " + ambito.archivo, linea, columna, false); Estatico.errores.Add(error); Estatico.ColocaError(error); } } catch (Exception e) { TError error = new TError("Ejecucion", "Error al ejecutar la funcion Log10() | Clase: " + this.clase + " | Archivo: " + ambito.archivo + " | Mensaje: " + e.Message, linea, columna, false); Estatico.errores.Add(error); Estatico.ColocaError(error); } this.valor = 0.0; return(0.0); }
public object getValor(Ambito ambito) { try { if (tipo == 1) { int maximo = this.expresiones.Count - 1; /// TOMO EL VALOR MAXIMO Random r = new Random(); /// FUNCION RANDOM int index = r.Next(0, maximo); /// VALOR DEL INDEX DE LA EXPRESION Expresion v = this.expresiones.ElementAt(index); /// ELEMENTO this.valor = v.getValor(ambito); if (valor is string || valor is int || valor is double) { return(valor); } else { TError error = new TError("Semantico", "La Funcion Random() solo permite retornar valores: Cadena, entero o Decimal | Clase: " + clase + " | Archivo: " + ambito.archivo, linea, columna, false); Estatico.errores.Add(error); Estatico.ColocaError(error); } return(new Nulo()); } else { Random r = new Random(); this.valor = r.Next(0, 1); return(this.valor); } } catch (Exception e) { TError error = new TError("Ejecucion", "Error al ejecutar la funcion: Random() | Clase: " + this.clase + " | Archivo: " + ambito.archivo + " | Mensaje: " + e.Message, linea, columna, false); Estatico.errores.Add(error); Estatico.ColocaError(error); } return(new Nulo()); }
public object ejecutar(Ambito amb, AST arbol) { foreach (NodoAST nodo in LLInstrucciones) { if (nodo is Instruccion) { Instruccion ins = (Instruccion)nodo; object objResult = ins.ejecutar(amb, arbol); if (objResult != null) { if (verificarTipo(this.Tipo, objResult)) { return(objResult); } else { Console.WriteLine("error"); return(null); } } } else if (nodo is Exp) { Exp expr = (Exp)nodo; object result = expr.getValorImplicito(amb, arbol); if (result != null) { if (expr.getTipo(amb, arbol) == this.Tipo) { return(result); } else { Console.Write("EL tipo del retorno no es el declarado en la funcion"); return(null); } } } } return(null); }
/* * Metodo de la implementacion de la clase InstruccionCQL * @ts Tabla de simbolos global * @user usuario que ejecuta la accion * @baseD base de datos en la que se realizara la accion, es pasada por referencia */ public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT) { Mensaje ms = new Mensaje(); GuardarArchivo guardar = new GuardarArchivo(); guardar.guardarArchivo("Principal2"); foreach (InstruccionCQL ins in cuerpo) { object respuesta = ins.ejecutar(ts, ambito, tsT); if (respuesta == null) { ambito.listadoExcepciones.AddLast(new Excepcion("batchexception", "Hubo un error en la ejecucion del batch, Linea: " + l + " Columna: " + c)); ambito.mensajes.AddLast(ms.error("Hubo un error en la ejecucion del batch", l, c, "Semantico")); LeerArchivo leer = new LeerArchivo("Principal2.chison"); return(null); } } return(""); }
internal Variable GetVariable(string id, string ambito) { Ambito a = GetAmbito(ambito); if (a != null) { foreach (Variable v in a.Variables) { if (v.Id.Equals(id)) { return(v); } } } if (!ambito.Equals("GLOBAL")) { return(GetVariable(id, "GLOBAL")); } 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) { object res = ts.getValor(id); Mensaje ms = new Mensaje(); if (!res.Equals("none")) { if (res.GetType() == typeof(TypeCursor)) { if (operacion.Equals("open")) { object tabla = ((TypeCursor)res).consulta.ejecutar(ts, ambito, tsT); if (tabla != null) { ambito.mensajes.RemoveLast(); if (tabla.GetType() == typeof(TablaSelect)) { ((TypeCursor)res).tabla = (TablaSelect)tabla; } } } else { ((TypeCursor)res).tabla = null; } return(""); } 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("No se encuentra la variable: " + id + " en este ambito", l, c, "Semantico")); } return(null); }
public object getValor(Ambito ambito) { try { Ambito ambitoOpcs = new Ambito(null, this.clase, ambito.archivo); //CREO EL AMBITO DEL OBJETO Opciones listado = new Opciones("opciones", null); // CREO EL LISTADO QUE VA A MANEJAR LOS VALORES Variable v = new Variable("cutz", "opciones", Estatico.Vibililidad.LOCAL, listado); // SETEO LA VARIABLE QUE ME VA A GUARDAR EL LISTADO ambitoOpcs.agregarVariableAlAmbito("cutz", v); /// LO AGREGO AL AMBITO Objeto opciones = new Objeto("opciones", ambitoOpcs); /// CREO EL OBJETO OPCIONES return(opciones); //LO RETORNO } catch { } return(new Nulo()); }
/* * 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) { Boolean ejecutar = false; foreach (Case c in listado) { if ((c.isDefault && !ejecutar) || (!c.isDefault)) { object res = c.ejecutar(ts, ambito, tsT); if (res == null) { return(null); } } if (c.flag && !ejecutar) { ejecutar = c.flag; } } return(""); }