public static void asginar(Simbolo ladoIzq, Object ladoDer)
{
ZContenedor derecho = desenvolver(ladoDer);
if (ladoIzq.obtenerInstanciaTipo() == derecho.Origen)
{
ladoIzq.definirValor(derecho);
return;
}
if (ladoIzq.obtenerInstanciaTipo() is TeDeULista && derecho.Origen == TiposPrimitivos.tipoListaVacia)
{
ladoIzq.definirValor(new ZLista(new List <ZContenedor>(), ladoIzq.obtenerInstanciaTipo()));
return;
}
if (derecho.Origen == TiposPrimitivos.tipoNulo)
{
ladoIzq.definirValor(TiposPrimitivos.instanicaNulo);
return;
}
if (isNumeric(ladoIzq))
{
casteoImplicitoNumero(ladoIzq, derecho);
return;
}
// throw new SemanticError("se intenta asignar algo que no es del mismo tipo");
throw new SemanticError($"No se puede asignar valor de tipo '{derecho.Origen.Nombre}' en variable de tipo '{ladoIzq.obtenerInstanciaTipo().Nombre}'");
}
public static ZContenedor invocarSoloFuncion(ZContenedor c, string id, List <ZContenedor> argumentos)
{
//argi,emtps deberoam de or desebmuetlos
AgenteFuncion agente = c.getAgente(id);
return(agente.ejecutar(argumentos));
}
public override object ejecutarSinposicion(ZContenedor e)
{
var algo = exp.ejecutar(e);
ZContenedor valor = Utilidades.desenvolver(algo);
Console.WriteLine(valor.stringBonito());
return(null);
}
public static ZBool evaluarCondicion(Instruccion exp, ZContenedor e)
{
var algo = exp.ejecutar(e);
var condicion = desenvolver(algo);
if (condicion is ZBool c)
{
return(c);
}
throw new SemanticError("la expresion evaluada no es una condicion");
}
public override object ejecutarSinposicion(ZContenedor e)
{
TeDeU @struct = (TeDeU)tipo.ejecutar(e);
ZTupla algo = (ZTupla)tupla.ejecutar(e);
ZInstancia zinstancia = @struct.crearInstancia(e);
@struct.asignarValores(algo.argumentos, zinstancia);
return(zinstancia);
}
public static Simbolo buscarId(ZContenedor e, string id)
{
for (ZContenedor temporal = e; temporal != null; temporal = temporal.anterior)
{
if (temporal.exsiteVariableActual(id))
{
return(temporal.getVariableActual(id));
}
}
return(null);
}
public static Object ejecutarSentencias(List <Instruccion> lInstruc, ZContenedor c)
{
foreach (Instruccion ins in lInstruc)
{
var result = ins.ejecutar(c);
if (result is NodoBreak || result is NodoContinue || result is Retorno || result is RetornoProc)
{
return(result);
}
}
return(null);
}
public static void loadNow(ZContenedor e)
{
List <NodoDeclararParametro> parametros = new List <NodoDeclararParametro>();
FuncionNativa f = new FuncionNativa(TiposPrimitivos.tipoDate, parametros, e,
list =>
{
return(new ZTiempo(DateTime.Now.ToString()));
}
);
e.declararFuncion("now", f);
}
public static List <ZContenedor> desnvolverArgumento(List <Instruccion> instruccionesArgumentos, ZContenedor e)
{
List <ZContenedor> argumentos = new List <ZContenedor>();
foreach (Instruccion ins in instruccionesArgumentos)
{
var algo = ins.ejecutar(e);
ZContenedor valor = desenvolver(algo);
argumentos.Add(valor);
}
return(argumentos);
}
public static void casteoImplicitoNumero(Simbolo algo1, ZContenedor d2)
{
if (algo1.obtenerInstanciaTipo() == TiposPrimitivos.tipoNumero && d2 is ZDecimal n2)
{
algo1.definirValor(new ZNumero((int)n2.obtenerValor()));
return;
}
if (algo1.obtenerInstanciaTipo() == TiposPrimitivos.tipoDicimal && d2 is ZNumero n3)
{
algo1.definirValor(new ZDecimal(n3.obtenerValor()));
return;
}
throw new SemanticError($"No se puede asignar valor de tipo '{d2.Origen.Nombre}' en variable de tipo '{algo1.obtenerInstanciaTipo().Nombre}'");
}
public static ZContenedor accederElementoLista(ZContenedor ambito, Instruccion exp1, Instruccion exp2)
{
var z1 = desenvolver(exp1.ejecutar(ambito));
var z2 = desenvolver(exp2.ejecutar(ambito));
if (!(z1 is ZLista zLista))
{
throw new SemanticError($"Operador de accesso [] no valido para acceder tipo '{z1.Origen.Nombre}' ");
}
if (!(z2 is ZNumero zNumero))
{
throw new SemanticError($"Operador de accesso [] tiene que tener valores enteros, no de tipo '{z2.Origen.Nombre}'");
}
return(zLista.obtenerElemento(zNumero.obtenerValor()));
}
public void ejecutarAnalizador(string entrada)
{
//llamada a los cosos de irony
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;
}
}
List <Instruccion> listIns = (List <Instruccion>)arbol.Root.AstNode;
ZContenedor global = new ZContenedor(null, null);
Dbms.cargarTedeUs();
//funciones
loadToday(global);
loadNow(global);
Utilidades.ejecutarSentencias(listIns, global);
}
public static void cargarFuncionesNativas(ZContenedor e)
{
var countZFun = new FuncionNativa(
TiposPrimitivos.tipoNumero,
crearListaParametros(TiposPrimitivos.tipoResultadoQuery),
e,
args =>
{
var resultadoQuery = (ZResultadoQuery)args[0];
return(new ZNumero(resultadoQuery.Resultado.Count));
}
);
var sumZFun = new FuncionNativa(
TiposPrimitivos.tipoDicimal,
crearListaParametros(TiposPrimitivos.tipoResultadoQuery),
e,
args =>
{
var resultado = ((ZResultadoQuery)args[0]).Resultado;
if (resultado.Count == 0)
{
return(new ZDecimal(0));
}
tieneUnaSolaColumna(resultado);
double total = 0;
foreach (var fila in resultado)
{
switch (fila[0])
{
case ZNumero zNumero:
total += zNumero.obtenerValor();
continue;
case ZDecimal zDecimal:
total += zDecimal.obtenerValor();
continue;
default:
throw new SemanticError($"Todos los valores deben de ser numericos en 'sum'. Encontrado '{fila[0].Origen.Nombre}'");
}
}
return(new ZDecimal(total));
}
);
var avgZFun = new FuncionNativa(
TiposPrimitivos.tipoDicimal,
crearListaParametros(TiposPrimitivos.tipoResultadoQuery),
e,
args =>
{
var resultado = ((ZResultadoQuery)args[0]).Resultado;
if (resultado.Count == 0)
{
return(new ZDecimal(0));
}
tieneUnaSolaColumna(resultado);
double total = 0;
foreach (var fila in resultado)
{
switch (fila[0])
{
case ZNumero zNumero:
total += zNumero.obtenerValor();
continue;
case ZDecimal zDecimal:
total += zDecimal.obtenerValor();
continue;
default:
throw new SemanticError($"Todos los valores deben de ser numericos en 'sum'. Encontrado '{fila[0].Origen.Nombre}'");
}
}
return(new ZDecimal(total / resultado.Count));
}
);
var maxZFun = new FuncionNativa(
TiposPrimitivos.tipoDicimal,
crearListaParametros(TiposPrimitivos.tipoResultadoQuery),
e,
args =>
{
var resultado = ((ZResultadoQuery)args[0]).Resultado;
if (resultado.Count == 0)
{
return(new ZDecimal(0));
}
tieneUnaSolaColumna(resultado);
DateTime?maxTiempo = null;
DateTime?maxDate = null;
double?maximo = null;
foreach (var fila in resultado)
{
switch (fila[0])
{
case ZNumero zNumero:
if (maximo == null)
{
maximo = zNumero.obtenerValor();
}
else
{
if (zNumero.obtenerValor() > maximo)
{
maximo = zNumero.obtenerValor();
}
}
continue;
case ZDecimal zDecimal:
if (maximo == null)
{
maximo = zDecimal.obtenerValor();
}
else
{
if (zDecimal.obtenerValor() > maximo)
{
maximo = zDecimal.obtenerValor();
}
}
continue;
case ZDate zDate:
if (maxDate == null)
{
maxDate = zDate.obtenerValor();
}
else
{
if (zDate.obtenerValor() > maxDate)
{
maxDate = zDate.obtenerValor();
}
}
continue;
case ZTiempo zTiempo:
if (maxTiempo == null)
{
maxTiempo = zTiempo.obtenerValor();
}
else
{
if (zTiempo.obtenerValor() > maxTiempo)
{
maxTiempo = zTiempo.obtenerValor();
}
}
continue;
default:
throw new SemanticError($"Tipo no valido para 'max'. Encontrado '{fila[0].Origen.Nombre}'");
}
}
if (maximo != null)
{
return(new ZDecimal(maximo.Value));
}
if (maxDate != null)
{
return(new ZDate(maxDate.Value));
}
if (maxTiempo != null)
{
return(new ZTiempo(maxTiempo.Value));
}
return(TiposPrimitivos.instanicaNulo);
}
);
var minZFun = new FuncionNativa(
TiposPrimitivos.tipoDicimal,
crearListaParametros(TiposPrimitivos.tipoResultadoQuery),
e,
args =>
{
var resultado = ((ZResultadoQuery)args[0]).Resultado;
if (resultado.Count == 0)
{
return(new ZDecimal(0));
}
tieneUnaSolaColumna(resultado);
DateTime?maxTiempo = null;
DateTime?maxDate = null;
double?maximo = null;
foreach (var fila in resultado)
{
switch (fila[0])
{
case ZNumero zNumero:
if (maximo == null)
{
maximo = zNumero.obtenerValor();
}
else
{
if (zNumero.obtenerValor() < maximo)
{
maximo = zNumero.obtenerValor();
}
}
continue;
case ZDecimal zDecimal:
if (maximo == null)
{
maximo = zDecimal.obtenerValor();
}
else
{
if (zDecimal.obtenerValor() < maximo)
{
maximo = zDecimal.obtenerValor();
}
}
continue;
case ZDate zDate:
if (maxDate == null)
{
maxDate = zDate.obtenerValor();
}
else
{
if (zDate.obtenerValor() < maxDate)
{
maxDate = zDate.obtenerValor();
}
}
continue;
case ZTiempo zTiempo:
if (maxTiempo == null)
{
maxTiempo = zTiempo.obtenerValor();
}
else
{
if (zTiempo.obtenerValor() < maxTiempo)
{
maxTiempo = zTiempo.obtenerValor();
}
}
continue;
default:
throw new SemanticError($"Tipo no valido para 'min'. Encontrado '{fila[0].Origen.Nombre}'");
}
}
if (maximo != null)
{
return(new ZDecimal(maximo.Value));
}
if (maxDate != null)
{
return(new ZDate(maxDate.Value));
}
if (maxTiempo != null)
{
return(new ZTiempo(maxTiempo.Value));
}
return(TiposPrimitivos.instanicaNulo);
}
);
e.declararFuncion("count", countZFun);
e.declararFuncion("sum", sumZFun);
e.declararFuncion("avg", avgZFun);
e.declararFuncion("max", maxZFun);
e.declararFuncion("min", minZFun);
}
public static ZContenedor invocarFuncionPunto(ZContenedor c, string id, List <ZContenedor> argumentos)
{
AgenteFuncion agente = c.getAgenteActual(id);
return(agente.ejecutar(argumentos));
}
public static ZTupla invocarProcedimiento(ZContenedor e, string id, List <ZContenedor> argumentos)
{
AgenteProcedimiento agente = Dbms.getBd().getProc(id);
return(agente.ejecutar(argumentos));
}
public void definirValor(ZContenedor valor)
{
this.valor = valor;
}
public Simbolo(TeDeU instanciaTipo, ZContenedor valorInicial)
{
this.instanciaTipo = instanciaTipo;
valor = valorInicial;
}
