public override object ejecutarSinposicion(ZContenedor e)
{
var algo1 = exp1.ejecutar(e);
var algo2 = exp2.ejecutar(e);
if (!(algo1 is Simbolo))
{
throw new SemanticError("Lado izquierdo no es una referencia");
}
Utilidades.asginar((Simbolo)algo1, algo2);
return(null);
}
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);
}
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 override object ejecutarSinposicion(ZContenedor e)
{
var sim = i1.ejecutar(e);
if (sim is Simbolo s1)
{
var valor1 = Utilidades.desenvolver(s1);
var algo2 = i2.ejecutar(e);
var valor2 = Utilidades.desenvolver(algo2);
if (valor1 is ZNumero n1 && valor2 is ZNumero n2)
{
NodoDivision.isZero(n2.obtenerValor());
ZNumero novo = new ZNumero(n1.obtenerValor() / n2.obtenerValor());
s1.definirValor(novo);
return(novo);
}
if (valor1 is ZDecimal n11 && valor2 is ZDecimal n12)
{
NodoDivision.isZero(n12.obtenerValor());
ZDecimal novo = new ZDecimal(n11.obtenerValor() / n12.obtenerValor());
s1.definirValor(novo);
return(novo);
}
if (valor1 is ZNumero n111 && valor2 is ZDecimal n122)
{
throw new SemanticError("tipos no compatibles");
}
if (valor1 is ZDecimal n11a && valor2 is ZNumero n12b)
{
NodoDivision.isZero(n12b.obtenerValor());
ZDecimal novo = new ZDecimal(n11a.obtenerValor() / n12b.obtenerValor());
s1.definirValor(novo);
return(novo);
}
throw new SemanticError("tipos no compatiples exp-=");
}
throw new SemanticError("el lado izquierdo no es un simbolo exp-=exp");
}
public override object ejecutarSinposicion(ZContenedor e)
{
var algo1 = i1.ejecutar(e);
ZContenedor valor1 = Utilidades.desenvolver(algo1);
if (valor1 is ZNumero n1)
{
return(new ZNumero(n1.obtenerValor() * +1));
}
if (valor1 is ZDecimal n2)
{
return(new ZDecimal(n2.obtenerValor() * +1));
}
throw new SemanticError("Error operacion +ex; tipo no compatibles");
}
public override object ejecutarSinposicion(ZContenedor e)
{
Simbolo sim = new Simbolo(tipo, null);
Utilidades.AsignarValorInicial(sim);
if (expresion == null)
{
e.setVariable(id, sim);
return(null);
}
var algo = expresion.ejecutar(e);
Utilidades.asginar(sim, Utilidades.desenvolver(algo));
e.setVariable(id, sim);
return(null);
}
public object ejecutar(Entorno ent, AST arbol)
{
foreach (NodoAST nodo in Instrucciones)
{
if (nodo is Instruccion)
{
Instruccion ins = (Instruccion)nodo;
object result = ins.ejecutar(ent, arbol);
if (result != null)
{
if (verificarTipo(this.Tipo, result))
{
return(result);
}
else
{
Program.getGUI().appendSalida("EL tipo del retorno no es el declarado en la funcion");
return(null);
}
}
}
else if (nodo is Expresion)
{
Expresion expr = (Expresion)nodo;
object result = expr.getValorImplicito(ent, arbol);
if (result != null)
{
if (expr.getTipo(ent, arbol) == this.Tipo)
{
return(result);
}
else
{
Program.getGUI().appendSalida("EL tipo del retorno no es el declarado en la funcion");
return(null);
}
}
}
}
return(null);
}
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);
}
public object ejecutar(Entorno ent, AST arbol)
{
Entorno local = new Entorno(ent);
inicializacion.ejecutar(local, arbol);
siguiente:
if ((bool)condicion.getValorImplicito(local, arbol))
{
foreach (Instruccion objIns in instrucciones)
{
if (objIns is Break)
{
return(null);
}
else if (objIns is Continue)
{
this.actualizacion.ejecutar(local, arbol);
goto siguiente;
}
else
{
object resultado = objIns.ejecutar(local, arbol);
if (resultado is Break)
{
return(null);
}
else if (resultado is Continue)
{
this.actualizacion.ejecutar(local, arbol);
goto siguiente;
}
}
}
this.actualizacion.ejecutar(local, arbol);
goto siguiente;
}
return(null);
}
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 ZBool(n1.obtenerValor() > n2.obtenerValor()));
}
if (valor1 is ZDecimal n11 && valor2 is ZDecimal n12)
{
return(new ZBool(n11.obtenerValor() > n12.obtenerValor()));
}
if (valor1 is ZNumero n111 && valor2 is ZDecimal n122)
{
return(new ZBool(n111.obtenerValor() > n122.obtenerValor()));
}
if (valor1 is ZDecimal n11a && valor2 is ZNumero n12b)
{
return(new ZBool(n11a.obtenerValor() > n12b.obtenerValor()));
}
if (valor1 is ZDate d5 && valor2 is ZDate n5)
{
return(new ZBool(d5.obtenerValor() > n5.obtenerValor()));
}
if (valor1 is ZTiempo d6 && valor2 is ZTiempo n6)
{
return(new ZBool(d6.obtenerValor() > n6.obtenerValor()));
}
throw new SemanticError("Error; operacion > no compatible con tipos");
}
public Object ejecutar(Contexto ctx, Stuff stuff)
{
object resCond = null;
do
{
Contexto local = ctx.shallowCopy();
local.terminable = true;
local.continuable = true;
foreach (Instruccion i in ins)
{
object resIns = i.ejecutar(local, stuff);
if (resIns is Break)
{
return(null);
}
else if (resIns is Continue)
{
break;
}
else if (resIns is Return)
{
return(resIns);
}
}
resCond = Operacion.Validar(cond.ejecutar(ctx, stuff), ctx, stuff, getLinea(), getColumna());
if (resCond == null)
{
stuff.error("Semántico", "'DO WHILE', la condición tuvo un error durante la ejecucion.", ((Operacion)cond).fila2, ((Operacion)cond).columna2, ctx);
return(null);
}
if (!(resCond is bool))
{
stuff.error("Semántico", "'DO WHILE', la condición YA NO es del tipo correcto. Esperado: 'BOOLEANO'. Encontrado: " + (Operacion.getTipo(resCond)), ((Operacion)cond).fila2, ((Operacion)cond).columna2, ctx);
return(null);
}
} while ((bool)resCond);
return(null);
}
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)
{
isZero(n2.obtenerValor());
return(new ZNumero(n1.obtenerValor() / n2.obtenerValor()));
}
if (valor1 is ZDecimal n11 && valor2 is ZDecimal n12)
{
isZero(n12.obtenerValor());
return(new ZDecimal(n11.obtenerValor() / n12.obtenerValor()));
}
if (valor1 is ZNumero n111 && valor2 is ZDecimal n122)
{
isZero(n122.obtenerValor());
return(new ZDecimal(n111.obtenerValor() / n122.obtenerValor()));
}
if (valor1 is ZDecimal n11a && valor2 is ZNumero n12b)
{
isZero(n12b.obtenerValor());
return(new ZDecimal(n11a.obtenerValor() / n12b.obtenerValor()));
}
throw new SemanticError("Error; operacion / no compatible con tipos");
}
public override object ejecutarSinposicion(ZContenedor e)
{
TeDeU tedeu = (TeDeU)tipo.ejecutar(e);
Object algo = this.valor.ejecutar(e);
ZContenedor valor = Utilidades.desenvolver(algo);
//lado izquierdo cadena
if (tedeu == TiposPrimitivos.tipoString)
{
return(casteoExplicitoCadnea(valor));
}
//lado derecho cadena
if (valor is ZCadena n1)
{
return(ladoDerechoCadena(n1.obtenerValor(), tedeu));
}
throw new SemanticError("se esta intentando castear un tipo a string no compatible");
}
public override object ejecutarSinposicion(ZContenedor e)
{
Tabla tab = (Tabla)tabla.ejecutar(e);
List <ZFila> zfilas = tab.Filas;
foreach (ZFila fila in zfilas)
{
bool bandera = false;
if (@where != null)
{
var algo = @where.ejecutar(fila);
ZContenedor valor = Utilidades.desenvolver(algo);
bandera = NodoSelect.ejecutarWhere(valor);
}
//con where
if (bandera && @where != null)
{
Utilidades.ejecutarSentencias(asignaciones, fila);
continue;
}
//sin where
if (!bandera && @where == null)
{
Utilidades.ejecutarSentencias(asignaciones, fila);
}
}
return(null);
}
public object ejecutar(Contexto ctx, Stuff stuff)
{
object resEx = Operacion.Validar(exp.ejecutar(ctx, stuff), ctx, stuff, exp.getLinea(), exp.getColumna());
if (resEx == null)
{
return(null);
}
if (resEx is Arreglo)
{
object resIndice = Operacion.Validar(indice.ejecutar(ctx, stuff), ctx, stuff, indice.getLinea(), indice.getColumna());
if (resIndice == null)
{
return(null);
}
if (resIndice is BigInteger index)
{
Arreglo arr = (Arreglo)resEx;
if (index < 0)
{
stuff.error("Semántico", "'ACCESO ARREGLO', el valor del indice es demasiado pequeño. Encontrado: " + index + ", Minimo: 0.", indice.getLinea(), indice.getColumna(), ctx);
return(null);
}
if (index >= arr.val.Count)
{
stuff.error("Semántico", "'ACCESO ARREGLO', el valor del indice es demasiado grande. Encontrado: " + index + ", Maximo: " + (arr.val.Count - 1) + ".", indice.getLinea(), indice.getColumna(), ctx);
return(null);
}
return(arr.val.ElementAt((int)index));
}
stuff.error("Semántico", "'ACCESO ARREGLO', el tipo del indice es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(resIndice) + ", Esperado: 'ENTERO'.", indice.getLinea(), indice.getColumna(), ctx);
return(null);
}
stuff.error("Semántico", "'ACCESO ARREGLO', el tipo del operando es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(resEx) + ", Esperado: 'ARREGLO'.", exp.getLinea(), exp.getColumna(), ctx);
return(null);
}
public object ejecutar(Contexto ctx, Stuff stuff)
{
object resOp = Operacion.Validar(op.ejecutar(ctx, stuff), ctx, stuff, fila, columna);
if (resOp == null)
{
return(null);
}
if (!(resOp is string))
{
stuff.error("Semántico", "'IMPORTAR', el parámetro 1 es del tipo incorrecto. Encontrado: " + Operacion.getTipo(resOp) + ", Esperado: 'CADENA'.", fila, columna, ctx);
return(null);
}
foreach (Contexto instancia in instanciasArchivos)
{
string filee;
if (ctx.currentFile == null)
{
filee = Path.GetFullPath(Path.Combine(resOp.ToString()));
}
else
{
filee = Path.GetFullPath(Path.Combine(ctx.currentFile, @"..\", resOp.ToString()));
}
if (instancia.currentFile.Equals(filee))
{
if (ctx != instancia)
{
ctx.otrosArchivos.Add(instancia);
}
return(null);
}
}
string file = "";
try
{
StringBuilder sb = new StringBuilder();
if (ctx.currentFile == null)
{
file = Path.GetFullPath(Path.Combine(resOp.ToString()));
}
else
{
file = Path.GetFullPath(Path.Combine(ctx.currentFile, @"..\", resOp.ToString()));
}
foreach (string line in File.ReadLines(file))
{
sb.AppendLine(line);
}
String entrada = sb.Replace("”", "\"").Replace("“", "\"").Replace("\r", "").Replace("\f", "").ToString();
if (entrada.Length > 0)
{
Gramatica gramatica = new Gramatica();
LanguageData lenguaje = new LanguageData(gramatica);
Parser parser = new Parser(lenguaje);
ParseTree arbol = parser.Parse(entrada);
ParseTreeNode AST = arbol.Root;
List <Instruccion> myAST = new List <Instruccion>();
if (AST != null)
{
myAST = new GeneradorAST().Analizar(AST);
}
foreach (Irony.LogMessage error in parser.Context.CurrentParseTree.ParserMessages)
{
stuff.erroresLexicosSintacticos.Add(new Irony.LogMessage(error.Level, error.Location, ((file != null) ? Path.GetFileName(file) + ": " : "No File: ") + error.Message, error.ParserState));
}
if (stuff.erroresLexicosSintacticos.Count == 0)
{
Contexto otroGlobal = new Contexto();
otroGlobal.currentFile = file;
foreach (Instruccion i in myAST)
{
if (i is Importar)
{
i.ejecutar(otroGlobal, stuff);
}
}
foreach (Instruccion i in myAST)
{
if (i is DeclaracionMetodo || i is DeclaracionClase)
{
i.ejecutar(otroGlobal, stuff);
}
}
foreach (Instruccion i in myAST)
{
if (i is DeclaracionMetodo || i is DeclaracionClase || i is Main || i is Importar)
{
}
else
{
i.ejecutar(otroGlobal, stuff);
}
}
foreach (Instruccion i in myAST)
{
if (i is Main)
{
stuff.error("Semántico", "'MAIN' está declarado en otro archivo que no es el principal.", i.getLinea(), i.getColumna(), otroGlobal);
}
}
foreach (Clase c in otroGlobal.clases)
{
ctx.clases.Add(c);
}
ctx.otrosArchivos.Add(otroGlobal);
instanciasArchivos.Add(otroGlobal);
return(null);
}
}
}
catch (FileNotFoundException)
{
stuff.error("Semántico", "'IMPORTAR', el archivo '" + file + "' no existe o no se puede leer.", fila, columna, ctx);
}
catch (IOException e)
{
stuff.error("Semántico", e.Message, fila, columna, ctx);
}
return(null);
}
public object ejecutar(Contexto ctx, Stuff stuff)
{
if (tipo == Tipo.GLOBAL)
{
if (op == null)
{
foreach (string id in ids)
{
Simbolo s = ctx.findGlobal(id);
if (s != null)
{
stuff.error("Semántico", "'DECLARACION GLOBAL', la variable '" + id + "' ya existe.", fila, columna, ctx);
}
else
{
s = new Simbolo(id, Simbolo.NULL);
ctx.globales.Add(s);
}
}
return(null);
}
bool evaluado = false;
object resOp = null;
foreach (string id in ids)
{
Simbolo s = ctx.findGlobal(id);
if (s != null)
{
stuff.error("Semántico", "'DECLARACION GLOBAL', la variable '" + id + "' ya existe.", fila, columna, ctx);
}
else
{
if (!evaluado)
{
evaluado = true;
resOp = Operacion.Validar(op.ejecutar(ctx, stuff), ctx, stuff, fila, columna);
if (resOp == null)
{
resOp = Simbolo.NULL;
}
}
s = new Simbolo(id, resOp);
ctx.globales.Add(s);
}
}
return(null);
}
else if (tipo == Tipo.ATRIBUTO)
{
if (op == null)
{
foreach (string id in ids)
{
Simbolo s = ctx.findAttribute(id);
if (s != null)
{
stuff.error("Semántico", "'DECLARACION ATRIBUTO', la variable '" + id + "' ya existe.", fila, columna, ctx);
}
else
{
s = new Simbolo(id, Simbolo.NULL);
ctx.atributos.Add(s);
}
}
return(null);
}
bool evaluado = false;
object resOp = null;
foreach (string id in ids)
{
Simbolo s = ctx.findAttribute(id);
if (s != null)
{
stuff.error("Semántico", "'DECLARACION ATRIBUTO', la variable '" + id + "' ya existe.", fila, columna, ctx);
}
else
{
if (!evaluado)
{
evaluado = true;
resOp = Operacion.Validar(op.ejecutar(ctx, stuff), ctx, stuff, fila, columna);
if (resOp == null)
{
resOp = Simbolo.NULL;
}
}
s = new Simbolo(id, resOp);
ctx.atributos.Add(s);
}
}
return(null);
}
else
{
if (op == null)
{
foreach (string id in ids)
{
Simbolo s = ctx.findLocalSame(id);
if (s != null)
{
stuff.error("Semántico", "'DECLARACION', la variable '" + id + "' ya existe.", fila, columna, ctx);
}
else
{
s = new Simbolo(id, Simbolo.NULL);
ctx.locales_mismo_nivel.Add(s);
ctx.locales_cualquier_nivel.Insert(0, s);
}
}
return(null);
}
bool evaluado = false;
object resOp = null;
foreach (string id in ids)
{
Simbolo s = ctx.findLocalSame(id);
if (s != null)
{
stuff.error("Semántico", "'DECLARACION', la variable '" + id + "' ya existe.", fila, columna, ctx);
}
else
{
if (!evaluado)
{
evaluado = true;
resOp = Operacion.Validar(op.ejecutar(ctx, stuff), ctx, stuff, fila, columna);
if (resOp == null)
{
resOp = Simbolo.NULL;
}
}
s = new Simbolo(id, resOp);
ctx.locales_mismo_nivel.Add(s);
ctx.locales_cualquier_nivel.Insert(0, s);
}
}
return(null);
}
}
public object ejecutar(Contexto ctx, Stuff stuff)
{
object resExp1 = Operacion.Validar(exp1.ejecutar(ctx, stuff), ctx, stuff, exp1.getLinea(), exp1.getColumna());
if (resExp1 == null)
{
return(null);
}
if (resExp1 is Objeto)
{
if (exp2 is LlamadaMetodo)
{
LlamadaMetodo ll = (LlamadaMetodo)exp2;
Objeto ob = (Objeto)resExp1;
Metodo m = ob.atributos.findLocalMethod(ll.id, ll.expresiones_params.Count);
if (m == null)
{
stuff.error("Semántico", "'LLAMADA METODO/FUNCION', el método o función '" + ll.id + "' no está definido dentro de la clase '" + ob.nombre_clase + "', o no tiene '" + ll.expresiones_params.Count + "' parametros.", ll.getLinea(), ll.getColumna(), ctx);
return(null);
}
else
{
Contexto ctx_metodo = new Contexto();
ctx_metodo.otrosArchivos = ob.atributos.otrosArchivos;
ctx_metodo.currentFile = ob.atributos.currentFile;
ctx_metodo.globales = ob.atributos.globales;
ctx_metodo.atributos = ob.atributos.atributos;
ctx_metodo.clases = ob.atributos.clases;
ctx_metodo.metodos = ob.atributos.metodos;
ctx_metodo.metodos_globales = ob.atributos.metodos_globales;
ctx_metodo.terminable = false;
ctx_metodo.continuable = false;
ctx_metodo.retornable = true;
ctx_metodo.esVoid = m.esVoid;
if (m.decl_params != null)
{
m.decl_params.ejecutar(ctx_metodo, stuff);
}
for (int j = 0; j < m.cantidad_params; j++)
{
Simbolo s = ctx_metodo.locales_mismo_nivel.ElementAt(j);
Instruccion i = ll.expresiones_params.ElementAt(j);
object resIns = Operacion.Validar(i.ejecutar(ctx, stuff), ctx, stuff, i.getLinea(), i.getColumna());
if (resIns == null)
{
resIns = Simbolo.NULL;
}
s.value = resIns;
}
foreach (Instruccion i in m.listaInstrucciones)
{
object res = i.ejecutar(ctx_metodo, stuff);
if (res is Return r)
{
return(r.expresionEvaluada);
}
}
if (!m.esVoid)
{
stuff.error("Semántico", "'LLAMADA METODO/FUNCION', la función '" + ob.nombre_clase + "." + ll.id + "' de " + m.cantidad_params + " parametros carece de una instrucción 'RETURN' con expresion.", ll.getLinea(), ll.getColumna(), ctx);
return(null);
}
return(new lang.engine.Void(ob.nombre_clase, ll.id, m.cantidad_params));
}
}
else if (exp2 is Operacion)
{
Operacion op = (Operacion)exp2;
Objeto ob = (Objeto)resExp1;
Simbolo s = ob.atributos.findAttribute(op.value.ToString());
if (s == null)
{
stuff.error("Semántico", "'ACCESO PROPIEDAD', la variable '" + op.value.ToString() + "' no existe como propiedad de la clase '" + ob.nombre_clase + "'.", op.getLinea(), op.getColumna(), ctx);
return(null);
}
return(s.value);
}
}
else
{
stuff.error("Semántico", "'ACCESO PROPIEDAD', el tipo del operando es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(resExp1) + ", Esperado: 'OBJETO'.", exp1.getLinea(), exp1.getColumna(), ctx);
}
return(null);
}
public object ejecutar(Entorno.Entorno ent)
{
bool entro = false;
bool encontro = false;
foreach (Case caso in this.casos)
{
Operacion operacion = new Operacion(this.expresion, caso.getExpresion(), Operador.IGUAL_IGUAL, fila, columna);
Object re = operacion.getValor(ent);
if (re is Boolean)
{
if ((bool)re || encontro)
{
entro = true;
encontro = true;
foreach (NodoAST nodo in caso.getSentencias())
{
Entorno.Entorno local = new Entorno.Entorno(ent);
if (nodo is Instruccion)
{
Instruccion ins = (Instruccion)nodo;
Object result = ins.ejecutar(local);
if (result is Break)
{
return(null);
}
else if (result != null)
{
return(result);
}
}
else if (nodo is Expresion)
{
Expresion expr = (Expresion)nodo;
Object ret = expr.getValor(local);
if (ret is Return)
{
return(ret);
}
}
}
}
}
}
if (!entro)
{
if (this.defecto != null)
{
Case caso = this.defecto;
foreach (NodoAST nodo in caso.getSentencias())
{
Entorno.Entorno local = new Entorno.Entorno(ent);
if (nodo is Instruccion)
{
Instruccion ins = (Instruccion)nodo;
Object result = ins.ejecutar(local);
if (result is Break)
{
return(null);
}
else if (result != null)
{
return(result);
}
}
else if (nodo is Expresion)
{
Expresion expr = (Expresion)nodo;
Object ret = expr.getValor(local);
if (ret is Return)
{
return(ret);
}
}
}
}
}
return(null);
}
public object ejecutar(Contexto ctx, Stuff stuff)
{
exp.ejecutar(ctx, stuff);
return(null);
}
public object ejecutar(Contexto ctx, Stuff stuff)
{
if (op is Operacion)
{
Operacion op1 = (Operacion)op;
if (op1.tipo == Operacion.Tipo.IDENTIFICADOR)
{
Simbolo s = ctx.findSymbol(op1.value.ToString());
if (s == null)
{
stuff.error("Semántico", "'AUMENTO', la variable '" + op1.value.ToString() + "' no existe.", op1.getLinea(), op1.getColumna(), ctx);
return(null);
}
if (s.value is BigInteger)
{
BigInteger r1 = (BigInteger)s.value;
s.value = Operacion.Validar(r1 + 1, ctx, stuff, op1.getLinea(), op1.getColumna());
return(r1);
}
if (s.value is double)
{
double r1 = (double)s.value;
s.value = Operacion.Validar(r1 + 1.0, ctx, stuff, op1.getLinea(), op1.getColumna());
return(r1);
}
if (s.value is char)
{
BigInteger r1 = (char)s.value;
s.value = Operacion.Validar(r1 + 1, ctx, stuff, op1.getLinea(), op1.getColumna());
return(r1);
}
stuff.error("Semántico", "'AUMENTO', el tipo del operando es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(s.value) + ", Esperado: 'ENTERO', 'DOUBLE', 'CHAR'.", fila, columna, ctx);
return(null);
}
else
{
object resOp = Operacion.Validar(op.ejecutar(ctx, stuff), ctx, stuff, fila, columna);
if (resOp == null)
{
return(null);
}
if (resOp is BigInteger)
{
BigInteger r1 = (BigInteger)resOp + 1;
return(r1);
}
if (resOp is double)
{
double r1 = (double)resOp + 1.0;
return(r1);
}
if (resOp is char)
{
BigInteger r1 = ((char)resOp + 1);
return(r1);
}
stuff.error("Semántico", "'AUMENTO', el tipo del operando es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(resOp) + ", Esperado: 'ENTERO', 'DOUBLE', 'CHAR'.", fila, columna, ctx);
return(null);
}
}
else if (op is AccesoArreglo)
{
AccesoArreglo aa = (AccesoArreglo)op;
object resEx = Operacion.Validar(aa.exp.ejecutar(ctx, stuff), ctx, stuff, aa.exp.getLinea(), aa.exp.getColumna());
if (resEx == null)
{
return(null);
}
if (resEx is Arreglo)
{
object resIndice = Operacion.Validar(aa.indice.ejecutar(ctx, stuff), ctx, stuff, aa.indice.getLinea(), aa.indice.getColumna());
if (resIndice == null)
{
return(null);
}
if (resIndice is BigInteger index)
{
Arreglo arr = (Arreglo)resEx;
if (index < 0)
{
stuff.error("Semántico", "'ACCESO ARREGLO', el valor del indice es demasiado pequeño. Encontrado: " + index + ", Minimo: 0.", aa.indice.getLinea(), aa.indice.getColumna(), ctx);
return(null);
}
if (index >= arr.val.Count)
{
stuff.error("Semántico", "'ACCESO ARREGLO', el valor del indice es demasiado grande. Encontrado: " + index + ", Maximo: " + (arr.val.Count - 1) + ".", aa.indice.getLinea(), aa.indice.getColumna(), ctx);
return(null);
}
if (arr.val.ElementAt((int)index) is BigInteger)
{
BigInteger r1 = (BigInteger)arr.val.ElementAt((int)index);
arr.val.RemoveAt((int)index);
arr.val.Insert((int)index, Operacion.Validar(r1 + 1, ctx, stuff, aa.indice.getLinea(), aa.indice.getColumna()));
return(r1);
}
if (arr.val.ElementAt((int)index) is double)
{
double r1 = (double)arr.val.ElementAt((int)index);
arr.val.RemoveAt((int)index);
arr.val.Insert((int)index, Operacion.Validar(r1 + 1.0, ctx, stuff, aa.indice.getLinea(), aa.indice.getColumna()));
return(r1);
}
if (arr.val.ElementAt((int)index) is char)
{
BigInteger r1 = (char)arr.val.ElementAt((int)index);
arr.val.RemoveAt((int)index);
arr.val.Insert((int)index, Operacion.Validar(r1 + 1, ctx, stuff, aa.indice.getLinea(), aa.indice.getColumna()));
return(r1);
}
stuff.error("Semántico", "'AUMENTO', el tipo del elemento indizado es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(arr.val.ElementAt((int)index)) + ", Esperado: 'ENTERO', 'DOUBLE', 'CHAR'.", fila, columna, ctx);
return(null);
}
stuff.error("Semántico", "'ACCESO ARREGLO', el tipo del indice es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(resIndice) + ", Esperado: 'ENTERO'.", aa.indice.getLinea(), aa.indice.getColumna(), ctx);
return(null);
}
stuff.error("Semántico", "'ACCESO ARREGLO', el tipo del operando es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(resEx) + ", Esperado: 'ARREGLO'.", aa.exp.getLinea(), aa.exp.getColumna(), ctx);
return(null);
}
else if (op is AccesoPropiedad)
{
AccesoPropiedad ap = (AccesoPropiedad)op;
object resExp1 = Operacion.Validar(ap.exp1.ejecutar(ctx, stuff), ctx, stuff, ap.exp1.getLinea(), ap.exp1.getColumna());
if (resExp1 == null)
{
return(null);
}
if (resExp1 is Objeto)
{
if (ap.exp2 is LlamadaMetodo)
{
LlamadaMetodo ll = (LlamadaMetodo)ap.exp2;
Objeto ob = (Objeto)resExp1;
Metodo m = ob.atributos.findLocalMethod(ll.id, ll.expresiones_params.Count);
if (m == null)
{
stuff.error("Semántico", "'LLAMADA METODO/FUNCION', el método o función '" + ll.id + "' no está definido dentro de la clase '" + ob.nombre_clase + "', o no tiene '" + ll.expresiones_params.Count + "' parametros.", ll.getLinea(), ll.getColumna(), ctx);
return(null);
}
else
{
Contexto ctx_metodo = new Contexto();
ctx_metodo.otrosArchivos = ob.atributos.otrosArchivos;
ctx_metodo.currentFile = ob.atributos.currentFile;
ctx_metodo.globales = ob.atributos.globales;
ctx_metodo.atributos = ob.atributos.atributos;
ctx_metodo.clases = ob.atributos.clases;
ctx_metodo.metodos = ob.atributos.metodos;
ctx_metodo.metodos_globales = ob.atributos.metodos_globales;
ctx_metodo.terminable = false;
ctx_metodo.continuable = false;
ctx_metodo.retornable = true;
ctx_metodo.esVoid = m.esVoid;
if (m.decl_params != null)
{
m.decl_params.ejecutar(ctx_metodo, stuff);
}
for (int j = 0; j < m.cantidad_params; j++)
{
Simbolo s = ctx_metodo.locales_mismo_nivel.ElementAt(j);
Instruccion i = ll.expresiones_params.ElementAt(j);
object resIns = Operacion.Validar(i.ejecutar(ctx, stuff), ctx, stuff, i.getLinea(), i.getColumna());
if (resIns == null)
{
resIns = Simbolo.NULL;
}
s.value = resIns;
}
foreach (Instruccion i in m.listaInstrucciones)
{
object res = i.ejecutar(ctx_metodo, stuff);
if (res is Return r)
{
if (r.expresionEvaluada is BigInteger)
{
BigInteger r1 = (BigInteger)r.expresionEvaluada + 1;
return(r1);
}
if (r.expresionEvaluada is double)
{
double r1 = (double)r.expresionEvaluada + 1.0;
return(r1);
}
if (r.expresionEvaluada is char)
{
BigInteger r1 = ((char)r.expresionEvaluada + 1);
return(r1);
}
stuff.error("Semántico", "'AUMENTO', el tipo del operando es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(r.expresionEvaluada) + ", Esperado: 'ENTERO', 'DOUBLE', 'CHAR'.", fila, columna, ctx);
return(null);
}
}
if (!m.esVoid)
{
stuff.error("Semántico", "'LLAMADA METODO/FUNCION', la función '" + ob.nombre_clase + "." + ll.id + "' de " + m.cantidad_params + " parametros carece de una instrucción 'RETURN' con expresion.", ll.getLinea(), ll.getColumna(), ctx);
return(null);
}
return(new lang.engine.Void(ob.nombre_clase, ll.id, m.cantidad_params));
}
}
else if (ap.exp2 is Operacion)
{
Operacion op = (Operacion)ap.exp2;
Objeto ob = (Objeto)resExp1;
Simbolo s = ob.atributos.findAttribute(op.value.ToString());
if (s == null)
{
stuff.error("Semántico", "'ACCESO PROPIEDAD', la variable '" + op.value.ToString() + "' no existe como propiedad de la clase '" + ob.nombre_clase + "'.", op.getLinea(), op.getColumna(), ctx);
return(null);
}
if (s.value is BigInteger)
{
BigInteger r1 = (BigInteger)s.value;
s.value = Operacion.Validar(r1 + 1, ctx, stuff, op.getLinea(), op.getColumna());
return(r1);
}
if (s.value is double)
{
double r1 = (double)s.value;
s.value = Operacion.Validar(r1 + 1.0, ctx, stuff, op.getLinea(), op.getColumna());
return(r1);
}
if (s.value is char)
{
BigInteger r1 = (char)s.value;
s.value = Operacion.Validar(r1 + 1, ctx, stuff, op.getLinea(), op.getColumna());
return(r1);
}
stuff.error("Semántico", "'AUMENTO', el tipo del operando es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(s.value) + ", Esperado: 'ENTERO', 'DOUBLE', 'CHAR'.", fila, columna, ctx);
return(null);
}
}
else
{
stuff.error("Semántico", "'ACCESO PROPIEDAD', el tipo del operando es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(resExp1) + ", Esperado: 'OBJETO'.", ap.exp1.getLinea(), ap.exp1.getColumna(), ctx);
}
return(null);
}
else if (op is LlamadaMetodo)
{
object resOp = Operacion.Validar(op.ejecutar(ctx, stuff), ctx, stuff, fila, columna);
if (resOp == null)
{
return(null);
}
if (resOp is BigInteger)
{
BigInteger r1 = (BigInteger)resOp + 1;
return(r1);
}
if (resOp is double)
{
double r1 = (double)resOp + 1.0;
return(r1);
}
if (resOp is char)
{
BigInteger r1 = ((char)resOp + 1);
return(r1);
}
stuff.error("Semántico", "'AUMENTO', el tipo del operando es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(resOp) + ", Esperado: 'ENTERO', 'DOUBLE', 'CHAR'.", fila, columna, ctx);
return(null);
}
else
{
stuff.error("Semántico", "'AUMENTO', el tipo del operando es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(op) + ", Esperado: 'EXPRESION', 'LLAMADA METODO', 'VARIABLE', 'PROPIEDAD' , 'INDIZADOR'.", fila, columna, ctx);
}
return(null);
}
public override Simbolo evaluar(Entorno entorno, Reporte reporte)
{
return((Simbolo)llamada.ejecutar(entorno, reporte));
}
public void Analizar(String entrada)
{
GramaticaCQL gramatica = new GramaticaCQL();
LanguageData lenguaje = new LanguageData(gramatica);
Parser parser = new Parser(lenguaje);
ParseTree arbol = parser.Parse(entrada);
ParseTreeNode raiz = arbol.Root;
Estatico.errores = new List <ErrorCQL>();
Estatico.mensajes = new List <String>();
Estatico.servidor = new Servidor();
obteErroes(arbol);
if (raiz != null)
{
Graficador.Graficador grafo = new Graficador.Graficador();
grafo.graficar(raiz);
ConstruirAST constructor = new ConstruirAST(raiz);
AST arbolAst = constructor.generarAst();
Entorno ent = new Entorno(null);
//-------- Prueba;
BaseDatos prueba = new BaseDatos("prueba");
Estatico.servidor.nuevaBase("prueba", prueba);
Usuario admin = new Usuario("admin", "admin");
Estatico.actualUsuario = admin;
foreach (NodoAST sentencia in arbolAst.arbol)
{
if (sentencia is Instruccion)
{
if (sentencia is Funcion)
{
Funcion fun = (Funcion)sentencia;
ent.agregar(fun.identificador, fun);
}
}
else if (sentencia is Expresion)
{
}
}
foreach (NodoAST sentencia in arbolAst.arbol)
{
if (sentencia is Instruccion)
{
if (!(sentencia is Funcion))
{
Instruccion ins = (Instruccion)sentencia;
object valor = ins.ejecutar(ent);
}
}
else if (sentencia is Expresion)
{
Expresion exp = (Expresion)sentencia;
object valor = exp.getValor(ent);
}
}
//por el momento modificar al final
ReporteErrores reporte = new ReporteErrores(Estatico.errores);
reporte.writeReport();
}
else
{
Estatico.agregarMensaje("[+MESSAGE]raiz nula[-MESSAGE]");
//MessageBox.Show("raiznula");
}
}
public override object ejecutarSinposicion(ZContenedor e)
{
var algo1 = i1.ejecutar(e);
var algo2 = i2.ejecutar(e);
var valor1 = Utilidades.desenvolver(algo1);
var valor2 = Utilidades.desenvolver(algo2);
if (valor1 is ZLista zLista1 && valor2 is ZLista zLista2 && zLista1.Origen == zLista2.Origen)
{
return(ZLista.crearLista(zLista1.Elementos.Concat(zLista2.Elementos).ToList()));
}
if (valor1 is ZCadena c1 && valor2 is ZCadena c2)
{
return(new ZCadena(c1.obtenerValor() + c2.obtenerValor()));
}
if (valor1 is ZCadena c3 && valor2 is ZNumero n1)
{
return(new ZCadena(c3.obtenerValor() + n1.obtenerValor()));
}
if (valor1 is ZNumero n2 && valor2 is ZCadena c4)
{
return(new ZCadena(n2.obtenerValor() + c4.obtenerValor()));
}
if (valor1 is ZCadena c5 && valor2 is ZBool b1)
{
return(new ZCadena(c5.obtenerValor() + b1.obtenerValor()));
}
if (valor1 is ZBool b2 && valor2 is ZCadena c6)
{
return(new ZCadena(b2.obtenerValor() + c6.obtenerValor()));
}
if (valor1 is ZCadena c7 && valor2 is ZDecimal d1)
{
return(new ZCadena(c7.obtenerValor() + d1.obtenerValor()));
}
if (valor1 is ZDecimal d3 && valor2 is ZCadena c8)
{
return(new ZCadena(d3.obtenerValor() + c8.obtenerValor()));
}
if (valor1 is ZNumero n3 && valor2 is ZNumero n4)
{
return(new ZNumero(n3.obtenerValor() + n4.obtenerValor()));
}
if (valor1 is ZDecimal n5 && valor2 is ZDecimal n6)
{
return(new ZDecimal(n5.obtenerValor() + n6.obtenerValor()));
}
if (valor1 is ZNumero n7 && valor2 is ZDecimal d2)
{
return(new ZDecimal(n7.obtenerValor() + d2.obtenerValor()));
}
if (valor1 is ZDecimal n8 && valor2 is ZNumero n9)
{
return(new ZDecimal(n8.obtenerValor() + n9.obtenerValor()));
}
if ((valor1 is ZDate || valor1 is ZTiempo) && valor2 is ZCadena n11)
{
return(new ZCadena(valor1.stringBonito() + n11.obtenerValor()));
}
if (valor1 is ZCadena n12 && (valor2 is ZDate || valor2 is ZTiempo))
{
return(new ZCadena(n12.obtenerValor() + valor2.stringBonito()));
}
throw new SemanticError("Error; operacion + no compatible con tipos");
}
/**
* Método que ejecuta la accion de imprimir un valor, es una sobreescritura del
* método ejecutar que se debe programar por la implementación de la interfaz
* instrucción
* @param ts Tabla de símbolos del ámbito padre de la sentencia.
* @return Esta instrucción retorna nulo porque no produce ningun valor al ser
* ejecutada.
*/
public Object ejecutar(TablaDeSimbolos ts)
{
String impresion = contenido.ejecutar(ts).ToString();
System.Diagnostics.Debug.WriteLine(impresion);
return null;
}
public object ejecutar(Contexto ctx, Stuff stuff)
{
if (exp1 is Operacion)
{
Operacion op1 = (Operacion)exp1;
if (op1.tipo == Operacion.Tipo.IDENTIFICADOR)
{
Simbolo s = ctx.findSymbol(op1.value.ToString());
if (s == null)
{
stuff.error("Semántico", "'ASIGNACION', la variable '" + op1.value.ToString() + "' no existe.", exp1.getLinea(), exp1.getColumna(), ctx);
return(null);
}
object resOp = Operacion.Validar(exp2.ejecutar(ctx, stuff), ctx, stuff, exp2.getLinea(), exp2.getColumna());
if (resOp == null)
{
resOp = Simbolo.NULL;
}
s.value = resOp;
return(null);
}
else
{
stuff.error("Semántico", "'ASIGNACION', El lado izquierdo de una asignación debe ser una variable, propiedad o indizador.", exp1.getLinea(), exp1.getColumna(), ctx);
return(null);
}
}
else if (exp1 is AccesoArreglo)
{
AccesoArreglo aa = (AccesoArreglo)exp1;
object resEx = Operacion.Validar(aa.exp.ejecutar(ctx, stuff), ctx, stuff, aa.exp.getLinea(), aa.exp.getColumna());
if (resEx == null)
{
return(null);
}
if (resEx is Arreglo)
{
object resIndice = Operacion.Validar(aa.indice.ejecutar(ctx, stuff), ctx, stuff, aa.indice.getLinea(), aa.indice.getColumna());
if (resIndice == null)
{
return(null);
}
if (resIndice is BigInteger index)
{
Arreglo arr = (Arreglo)resEx;
if (index < 0)
{
stuff.error("Semántico", "'ACCESO ARREGLO', el valor del indice es demasiado pequeño. Encontrado: " + index + ", Minimo: 0.", aa.indice.getLinea(), aa.indice.getColumna(), ctx);
return(null);
}
if (index >= arr.val.Count)
{
stuff.error("Semántico", "'ACCESO ARREGLO', el valor del indice es demasiado grande. Encontrado: " + index + ", Maximo: " + (arr.val.Count - 1) + ".", aa.indice.getLinea(), aa.indice.getColumna(), ctx);
return(null);
}
object resOp = Operacion.Validar(exp2.ejecutar(ctx, stuff), ctx, stuff, exp2.getLinea(), exp2.getColumna());
if (resOp == null)
{
resOp = Simbolo.NULL;
}
arr.val.RemoveAt((int)index);
arr.val.Insert((int)index, resOp);
return(null);
}
stuff.error("Semántico", "'ACCESO ARREGLO', el tipo del indice es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(resIndice) + ", Esperado: 'ENTERO'.", aa.indice.getLinea(), aa.indice.getColumna(), ctx);
return(null);
}
stuff.error("Semántico", "'ACCESO ARREGLO', el tipo del operando es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(resEx) + ", Esperado: 'ARREGLO'.", aa.exp.getLinea(), aa.exp.getColumna(), ctx);
return(null);
}
else if (exp1 is AccesoPropiedad)
{
AccesoPropiedad ap = (AccesoPropiedad)exp1;
object resExp1 = Operacion.Validar(ap.exp1.ejecutar(ctx, stuff), ctx, stuff, ap.exp1.getLinea(), ap.exp1.getColumna());
if (resExp1 == null)
{
return(null);
}
if (resExp1 is Objeto)
{
if (ap.exp2 is LlamadaMetodo)
{
stuff.error("Semántico", "'ASIGNACION', El lado izquierdo de una asignación debe ser una variable, propiedad o indizador.", exp1.getLinea(), exp1.getColumna(), ctx);
return(null);
}
else if (ap.exp2 is Operacion)
{
Operacion op = (Operacion)ap.exp2;
Objeto ob = (Objeto)resExp1;
Simbolo s = ob.atributos.findAttribute(op.value.ToString());
if (s == null)
{
stuff.error("Semántico", "'ACCESO PROPIEDAD', la variable '" + op.value.ToString() + "' no existe como propiedad de la clase '" + ob.nombre_clase + "'.", op.getLinea(), op.getColumna(), ctx);
return(null);
}
object resOp = Operacion.Validar(exp2.ejecutar(ctx, stuff), ctx, stuff, exp2.getLinea(), exp2.getColumna());
if (resOp == null)
{
resOp = Simbolo.NULL;
}
s.value = resOp;
return(null);
}
}
else
{
stuff.error("Semántico", "'ACCESO PROPIEDAD', el tipo del operando es incompatible con esta instruccion. Encontrado: " + Operacion.getTipo(resExp1) + ", Esperado: 'OBJETO'.", ap.exp1.getLinea(), ap.exp1.getColumna(), ctx);
}
return(null);
}
else if (exp1 is LlamadaMetodo)
{
stuff.error("Semántico", "'ASIGNACION', El lado izquierdo de una asignación debe ser una variable, propiedad o indizador.", exp1.getLinea(), exp1.getColumna(), ctx);
return(null);
}
return(null);
}
public object ejecutar(Contexto ctx, Stuff stuff)
{
Metodo m = ctx.findLocalMethod(id, expresiones_params.Count);
if (m == null)
{
m = ctx.findGlobalFilesMethod(id, expresiones_params.Count);
if (m == null)
{
stuff.error("Semántico", "'LLAMADA METODO/FUNCION', el método o función '" + id + "' no está definido, o no tiene '" + expresiones_params.Count + "' parametros.", fila, columna, ctx);
return(null);
}
Contexto otroGlobal = ctx.findGlobalContextMethod(m);
Contexto ctx_metodo = new Contexto();
ctx_metodo.otrosArchivos = otroGlobal.otrosArchivos;
ctx_metodo.currentFile = otroGlobal.currentFile;
ctx_metodo.globales = otroGlobal.globales;
ctx_metodo.clases = otroGlobal.clases;
ctx_metodo.metodos_globales = otroGlobal.metodos_globales;
ctx_metodo.terminable = false;
ctx_metodo.continuable = false;
ctx_metodo.retornable = true;
ctx_metodo.esVoid = m.esVoid;
if (m.decl_params != null)
{
m.decl_params.ejecutar(ctx_metodo, stuff);
}
for (int j = 0; j < m.cantidad_params; j++)
{
Simbolo s = ctx_metodo.locales_mismo_nivel.ElementAt(j);
Instruccion i = expresiones_params.ElementAt(j);
object resIns = Operacion.Validar(i.ejecutar(ctx, stuff), ctx, stuff, i.getLinea(), i.getColumna());
if (resIns == null)
{
resIns = Simbolo.NULL;
}
s.value = resIns;
}
foreach (Instruccion i in m.listaInstrucciones)
{
object res = i.ejecutar(ctx_metodo, stuff);
if (res is Return r)
{
return(r.expresionEvaluada);
}
}
if (!m.esVoid)
{
stuff.error("Semántico", "'LLAMADA METODO/FUNCION', la función '" + id + "' de " + m.cantidad_params + " parametros carece de una instrucción 'RETURN' con expresion.", fila, columna, ctx);
return(null);
}
return(new lang.engine.Void(id, m.cantidad_params));
}
else
{
Contexto ctx_metodo = new Contexto();
ctx_metodo.otrosArchivos = ctx.otrosArchivos;
ctx_metodo.currentFile = ctx.currentFile;
ctx_metodo.globales = ctx.globales;
ctx_metodo.atributos = ctx.atributos;
ctx_metodo.clases = ctx.clases;
ctx_metodo.metodos = ctx.metodos;
ctx_metodo.metodos_globales = ctx.metodos_globales;
ctx_metodo.terminable = false;
ctx_metodo.continuable = false;
ctx_metodo.retornable = true;
ctx_metodo.esVoid = m.esVoid;
if (m.decl_params != null)
{
m.decl_params.ejecutar(ctx_metodo, stuff);
}
for (int j = 0; j < m.cantidad_params; j++)
{
Simbolo s = ctx_metodo.locales_mismo_nivel.ElementAt(j);
Instruccion i = expresiones_params.ElementAt(j);
object resIns = Operacion.Validar(i.ejecutar(ctx, stuff), ctx, stuff, i.getLinea(), i.getColumna());
if (resIns == null)
{
resIns = Simbolo.NULL;
}
s.value = resIns;
}
foreach (Instruccion i in m.listaInstrucciones)
{
object res = i.ejecutar(ctx_metodo, stuff);
if (res is Return r)
{
return(r.expresionEvaluada);
}
}
if (!m.esVoid)
{
stuff.error("Semántico", "'LLAMADA METODO/FUNCION', la función '" + id + "' de " + m.cantidad_params + " parametros carece de una instrucción 'RETURN' con expresion.", fila, columna, ctx);
return(null);
}
return(new lang.engine.Void(id, m.cantidad_params));
}
}
public object ejecutar(Entorno ent)
{
foreach (NodoAST nodo in this.instrucciones)
{
if (nodo is Instruccion)
{
Instruccion ins = (Instruccion)nodo;
Object result = ins.ejecutar(ent);
if (result is Break)
{
Estatico.errores.Add(new ErrorCQL("Semantico", "Error break en funcion ", this.fila, this.columna));
}
else if (result is Continue)
{
Estatico.errores.Add(new ErrorCQL("Semantico", "Error continue en funcion ", this.fila, this.columna));
}
else if (result is Return)
{
Return ret = (Return)result;
if (ret.retorno != null)
{
if (verificarTipo(this.tipo, ret.retorno))
{
return(ret.retorno);
}
else
{
Estatico.errores.Add(new ErrorCQL("Semantico", "Error retorno no es del mismo tipo que la funcion en funcion ", this.fila, this.columna));
return(null);
}
}
}
}
else if (nodo is Expresion)
{
Expresion exp = (Expresion)nodo;
Object result = exp.getValor(ent);
if (result is Return)
{
Return ret = (Return)result;
if (ret.retorno != null)
{
if (verificarTipo(this.tipo, ret.retorno))
{
return(ret.retorno);
}
else
{
Estatico.errores.Add(new ErrorCQL("Semantico", "Error retorno no es del mismo tipo que la funcion en funcion ", this.fila, this.columna));
return(null);
}
}
}
else if (result is Break)
{
Estatico.errores.Add(new ErrorCQL("Semantico", "Error break en funcion ", this.fila, this.columna));
}
else if (result is Continue)
{
Estatico.errores.Add(new ErrorCQL("Semantico", "Error continue en funcion ", this.fila, this.columna));
}
}
}
return(null);
}
public object ejecutar(Entorno.Entorno ent)
{
Object condicion_si = this.condicion.getValor(ent);
if (condicion_si is Boolean)
{
if ((Boolean)(condicion_si))
{
Entorno.Entorno local = new Entorno.Entorno(ent);
foreach (NodoAST nodo in this.getIntrucciones())
{
if (nodo is Instruccion)
{
Instruccion ins = (Instruccion)nodo;
Object result = ins.ejecutar(local);
if (result != null)
{
return(result);
}
}
else if (nodo is Expresion)
{
Expresion expr = (Expresion)nodo;
Object ret = expr.getValor(local);
if (ret is Return)
{
return(ret);
}
}
}
}
else
{
if (this.instruccionesElse != null)
{
Entorno.Entorno local = new Entorno.Entorno(ent);
foreach (NodoAST nodo in this.instruccionesElse)
{
if (nodo is Instruccion)
{
Instruccion ins = (Instruccion)nodo;
Object result = ins.ejecutar(local);
if (result != null)
{
return(result);
}
}
else if (nodo is Expresion)
{
Expresion expr = (Expresion)nodo;
Object ret = expr.getValor(local);
if (ret is Return)
{
return(ret);
}
}
}
}
}
}
else
{
Estatico.errores.Add(new ErrorCQL("Semantico", "La expresion del If no es booleana ", fila, columna));
}
return(null);
}