/*
* 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("");
}
}
/*
* Constructor de la clase
* @id nombre de la tabla
* @l linea del id
* @c columna del id
*/
public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT)
{
Mensaje mensa = new Mensaje();
string user = ambito.usuario;
string baseD = ambito.baseD;
LinkedList <string> mensajes = ambito.mensajes;
if (user.Equals("admin"))
{
Usuario usuario = TablaBaseDeDatos.getUsuario(id);
if (usuario == null)
{
usuario = new Usuario(id, password, new LinkedList <string>());
TablaBaseDeDatos.listaUsuario.AddLast(usuario);
mensajes.AddLast(mensa.message("El usuario: " + id + " se creo exitosamente"));
return("");
}
else
{
ambito.listadoExcepciones.AddLast(new Excepcion("useralreadyexists", "El usuario: " + id + " ya existe"));
mensajes.AddLast(mensa.error("El usuario: " + id + " ya existe", l, c, "Semantico"));
}
}
else
{
mensajes.AddLast(mensa.error("Solo un admin puede crear usuarios, el usuario: " + user + " no es admin", l, c, "Semantico"));
}
return(null);
}
public DeclaracionProcedure(TablaDeSimbolos tablaDeSimbolos, Id id, DeclaracionDeParametro[] parametros, ComandoBloque cuerpo)
{
this.id = id;
this.cuerpoDelProcedimiento = cuerpo;
this.parametros = parametros;
this.tablaDeSimbolos = tablaDeSimbolos;
}
public object Ejecutar(TablaDeSimbolos ts)
{
if (!Program.sistema.tienePermiso(user_actual, id_db))
{
salida.Add(Program.buildError(getLine(), getColumn(), "Semantico", "El usuario " + user_actual + " no posee permisos en " + id_db + "."));
}
else
{
if (Program.sistema.existUser(user))
{
foreach (Usuario item in Program.sistema.Usuarios)
{
if (item.Name.ToLower().Equals(user))
{
if (item.Revoke(id_db))
{
salida.Add(Program.buildMessage("Permiso revocado existasamente."));
}
else
{
salida.Add(Program.buildError(getLine(), getColumn(), "Semantico", "No existe el permiso en la lista de permisos del usuario " + user + "."));
}
return(null);
}
}
return(null);
}
else
{
salida.Add(Program.buildError(getLine(), getColumn(), "Semantico", user + " UserDontExists."));
}
}
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)
{
GuardarArchivo archivo = new GuardarArchivo();
archivo.guardarArchivo("Principal");
return("");
}
public NuevaInstancia(List <Type> libraries, TablaDeSimbolos tablaDeSimbolos, Id clase, Expresion[] argumentos)
{
this.tablaDeSimbolos = tablaDeSimbolos;
this.clase_Renamed = clase.Valor;
this.argumentos = argumentos;
this.libraries = libraries;
}
public ComandoEval(Assembly assembly, TablaDeSimbolos tablaDeSimbolos, Salida salida, Expresion expresion)
{
this.expresion = expresion;
this.tablaDeSimbolos = tablaDeSimbolos;
this.salida = salida;
this.assembly = assembly;
}
/*
* Metodo que ejecutara las acciones
* @ts tabla de simbolos
* @user usuario que ejecuta la accion
* return Mensaje LUP de Correcta accion o Incorrecta
*/
public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT)
{
Mensaje mensa = new Mensaje();
BaseDeDatos db = TablaBaseDeDatos.getBase(bd);
if (db == null)
{
ambito.mensajes.AddLast(mensa.error("La base de datos: " + bd + " no existe ", linea, columna, "Semantico"));
ambito.listadoExcepciones.AddLast(new Excepcion("bddontexists", "La base de datos: " + bd + " no existe "));
return(null);
}
if (TablaBaseDeDatos.getEnUso(bd, ambito.usuario))
{
ambito.mensajes.AddLast(mensa.error("La base de datos: " + bd + " esta siendo utilizada por otro usuario ", linea, columna, "Semantico"));
return(null);
}
Usuario usu = TablaBaseDeDatos.getUsuario(ambito.usuario);
if (usu == null && !ambito.usuario.Equals("admin"))
{
ambito.mensajes.AddLast(mensa.error("El usuario: " + ambito.usuario + " no existe ", linea, columna, "Semantico"));
return(null);
}
ambito.baseD = bd;
USO newU = new USO(ambito.baseD, ambito.usuario);
TablaBaseDeDatos.deleteMine(ambito.usuario);
TablaBaseDeDatos.listaEnUso.AddLast(newU);
ambito.mensajes.AddLast(mensa.message("Se esta utilizando la base " + ambito.baseD + " exitosamente"));
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);
}
}
public Parser(Assembly assembly, TablaDeSimbolos tablaDeSimbolos, Salida salida)
{
libraries = LoadTypesFromLibrary(assembly);
this.tablaDeSimbolos = tablaDeSimbolos;
this.salida = salida;
this.assembly = assembly;
lexer = new Lexer(" \f");
}
/*
* 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);
}
}
public ComandoFor(Salida salida, TablaDeSimbolos tablaDeSimbolos, string variable, Expresion expresion, Comando cuerpo)
{
this.salida = salida;
this.tablaDeSimbolos = tablaDeSimbolos;
this.variable = variable;
this.expresion = expresion;
this.cuerpo = cuerpo;
}
/*
* Constructor de la clase que asigna valores a una id en especifico
* @id el nombre de la varibale
* @l linea del nombre de la variable
* @c columna del nombre de la variable
* @a valor a guardar
* @operacion que se realizara
*/
public Asignacion(string id, int l, int c, Expresion a, string operacion)
{
this.id = id;
this.l = l;
this.c = c;
this.a = a;
this.operacion = operacion;
this.tPadre = 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 = (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);
}
/*
* 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 r = expresion.ejecutar(ts, ambito, tsT);
if (r != null)
{
ambito.mensajes.AddLast(ms.message(r.ToString()));
}
return("");
}
public object Ejecutar(TablaDeSimbolos ts)
{
string opcion = instruccion_switch.Expresion.Ejecutar(ts).ToString();
TablaDeSimbolos tabla_local = new TablaDeSimbolos();
tabla_local.addPadre(ts);
bool encontrado = false;
foreach (Tipo_Case caso in instruccion_switch.Casos)
{
if (opcion.ToLower().Equals(caso.Expresion.ToLower()) || encontrado)
{
encontrado = true;
foreach (Instruccion item in caso.Instrucciones)
{
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());
}
}
}
}
foreach (Instruccion item in instruccion_switch.Instrucciones_default)
{
if (item.getType() == Tipo.BREAK)
{
break;
}
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());
}
}
return(null);
}
public void destruirTS()
{
if (tablaLocalActiva)
{
tsl = null;
tablaLocalActiva = false;
}
else
{
tsg.ImprimirTS();
tsg = null;
}
}
public Actor(String persona)
{
if (String.IsNullOrEmpty(persona))
{
throw new ArgumentNullException(nameof(persona));
}
Assembly library = this.GetType().Assembly;
tablaDeSimbolos = new TablaDeSimbolos();
salida = new Salida();
parser = new Parser(library, tablaDeSimbolos, salida);
this.persona = persona;
}
/*
* 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);
}
/*
* METODO DEVOLVERA Todas las columnas
* @param lista: Todas las columnas de la tabla
* @param ts: lista de simbolos del padre
* @param user : usuario que ejecuta las acciones
* @param baseD : nombre de la base de datos se pasa por referencia
* @param mensajes: output de salida
*/
private LinkedList <Data> getAllData(Tabla t, TablaDeSimbolos ts, Ambito ambito, LinkedList <Columna> cabeceras)
{
Mensaje mensa = new Mensaje();
LinkedList <Data> listaR = new LinkedList <Data>();
LinkedList <string> mensajes = ambito.mensajes;
foreach (Data data in t.datos)
{
TablaDeSimbolos tsT = new TablaDeSimbolos();
guardarTemp(data.valores, tsT);
int i = 0;
if (operacion.Equals("none"))
{
listaR.AddLast(new Data(data.valores));
}
else
{
if (operacion.Contains("a"))
{
object condi = (condicion == null) ? null : condicion.ejecutar(ts, ambito, tsT);
if (condi != null)
{
if (condi.GetType() == typeof(Boolean))
{
if ((Boolean)condi)
{
listaR.AddLast(new Data(data.valores));
}
}
else
{
mensajes.AddLast(mensa.error("La condicion tiene que ser un valor booleano no se reconoce: " + condi, l, c, "Semantico"));
return(null);
}
}
else
{
mensajes.AddLast(mensa.error("No se aceptan columnas null", l, c, "Semantico"));
return(null);
}
}
else
{
listaR.AddLast(new Data(data.valores));
}
}
}
return(listaR);
}
public TablaDeSimbolos crearTS(bool global)
{
numeroTS++;
if (global)
{
tsg = new TablaDeSimbolos(true);
tsg.NumeroTs = numeroTS;
return(tsg);
}
tsl = new TablaDeSimbolos(false);
tablaLocalActiva = true;
tsl.NumeroTs = numeroTS;
return(tsl);
}
public object Ejecutar(TablaDeSimbolos ts)
{
if (!Program.sistema.tienePermiso(user_actual, id_db))
{
salida.Add(Program.buildError(getLine(), getColumn(), "Semantico", "El usuario " + user_actual + " no posee permisos en " + id_db + "."));
}
else
{
if (Program.sistema.existUser(user))
{
if (!Program.sistema.existPermission(user, id_db))
{
if (Program.sistema.existDataBase(id_db))
{
string bd_correct = "";
foreach (Database item in Program.sistema.Databases)
{
if (item.Name.ToLower().Equals(id_db))
{
bd_correct = item.Name;
}
}
Permiso new_permiso = new Permiso(bd_correct);
if (Program.sistema.setPermission(user, new_permiso))
{
salida.Add(Program.buildMessage("Permisos concedidos a " + user + " para base de datos " + id_db + "."));
}
else
{
salida.Add(Program.buildMessage("Error interno del sistema."));
}
}
else
{
salida.Add(Program.buildError(getLine(), getColumn(), "Semantico", id_db + " BDDontExists."));
}
}
else
{
salida.Add(Program.buildError(getLine(), getColumn(), "Semantico", "El usuario " + user + " ya tiene permiso sobre " + id_db + "."));
}
}
else
{
salida.Add(Program.buildError(getLine(), getColumn(), "Semantico", user + " UserDontExists."));
}
}
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 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(TablaDeSimbolos ts)
{
if (Program.sistema.existUser(user))
{
salida.Add(Program.buildError(getLine(), getColumn(), "Semantico", user + " UserAlreadyExists."));
}
else
{
Usuario new_user = new Usuario {
Name = user, Password = password
};
Program.sistema.Usuarios.Add(new_user);
salida.Add(Program.buildMessage("Usuario creado exitosamente."));
}
return(null);
}
/*
* METODO que aplica el limit
* @param lista: Todas las columnas de la tabla
* @param ts: lista de simbolos del padre
* @param user : usuario que ejecuta las acciones
* @param baseD : nombre de la base de datos se pasa por referencia
* @param mensajes: output de salida
*/
private LinkedList <Data> limitar(LinkedList <Data> datos, TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT)
{
LinkedList <Data> limiData = new LinkedList <Data>();
LinkedList <string> mensajes = ambito.mensajes;
Mensaje mensa = new Mensaje();
object res = (condicion2 == null) ? null : condicion2.ejecutar(ts, ambito, tsT);
if (res != null)
{
if (res.GetType() == typeof(int))
{
int limit = (int)res;
if (limit > 0)
{
int i = 0;
foreach (Data data in datos)
{
if (i < limit)
{
limiData.AddLast(data);
}
i++;
}
}
else
{
mensajes.AddLast(mensa.error("Limit tiene que ser entero mayor a cero no se reconoce: " + res, l, c, "Semantico"));
return(null);
}
}
else
{
mensajes.AddLast(mensa.error("Limit tiene que ser entero no se reconoce: " + res, l, c, "Semantico"));
return(null);
}
}
else
{
mensajes.AddLast(mensa.error("No se acepta un limit null", l, c, "Semantico"));
return(null);
}
return(limiData);
}
public void analizar(String cadena)
{
Gramatica gramatica = new Gramatica();
LanguageData lenguaje = new LanguageData(gramatica);
Parser parser = new Parser(lenguaje);
ParseTree arbol = parser.Parse(cadena);
ParseTreeNode raiz = arbol.Root;
LinkedList <Instruccion> AST = instrucciones(raiz.ChildNodes.ElementAt(0));
TablaDeSimbolos global = new TablaDeSimbolos();
foreach (Instruccion ins in AST)
{
ins.ejecutar(global);
}
}
/*
* 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 Ejecutar(TablaDeSimbolos ts)
{
if (Program.sistema.En_uso())
{
if (Program.sistema.existeObjeto(name))
{
Program.sistema.deleteObjeto(name.ToLower());
}
else
{
salida.Add(Program.buildError(getLine(), getColumn(), "Semantico", name + " TypeDontExists."));
}
}
else
{
//no hay ninguna base de datos seleccionada.
salida.Add(Program.buildError(getLine(), getColumn(), "Semantico", "No existe ninguna base de datos en uso."));
}
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("");
}
/*
* 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("");
}
