/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN DE METODO CONSTRUCTOR Heredado
|-------------------------------------------------------------------------------------------------------------------
|
*/
public void ejecutarConstructorHeredad(lstValores parametros, elementoEntorno tablaEntorno, token mensaje)
{
//aqui es donde tengo que buscar si existe
Console.WriteLine("ejecutando Constructor Heredado:");
elementoPolimorfo temp = getConstructoHeredado(parametros, mensaje);
if (temp != null)
//neuvo entorno
{
elementoEntorno hijo1 = new elementoEntorno(tablaEntorno, tabla, "main", tablaEntorno.este);
guardarParametrosEnLaTabla(temp.lstParametros, parametros, hijo1);
if (temp.LST_CUERPO.nombre.Equals("LST_CUERPO"))
/*
|----------------------------
| Ejecutando el cuerpo del metodo
|-----------------------
| Los constructores no retornan nada
*/
{
_LST_CUERPO val = (_LST_CUERPO)temp.LST_CUERPO;
val.ejecutar(hijo1);
}
}
}
public override void ejecutar(elementoEntorno elem)
{
if (tabla.hayErrores("lstPrincipal_ejecutar"))
{
return;
}
if (listaPolimorfa.Count > 0)
{
elementoPolimorfo temp = listaPolimorfa[0];
if (temp.LST_CUERPO.nombre.Equals("LST_CUERPO"))
{
_LST_CUERPO val = (_LST_CUERPO)temp.LST_CUERPO;
itemValor retornoFuncion = new itemValor();
retornoFuncion.setTypeVacio();
val.ejecutar(elem);
imprimir(elem);
}
}
else
{
tabla.tablaErrores.insertErrorSemantic("No se encuentra el main", new token());
}
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN DE METODO CONSTRUCTOR
|-------------------------------------------------------------------------------------------------------------------
|
*/
public void ejecutarMetodo(token nombre, lstValores parametros, elementoEntorno tablaEntorno)
{
//aqui es donde tengo que buscar si existe
Console.WriteLine("ejecutando Metodo:" + nombre.val);
elementoPolimorfo temp = getElementoPolimorfo2(nombre, parametros);
if (temp != null)
//neuvo entorno
{
elementoEntorno hijo1 = new elementoEntorno(tablaEntorno, tabla, "main", tablaEntorno.este);
if (temp.LST_CUERPO.nombre.Equals("LST_CUERPO"))
/*
|----------------------------
| Ejecutando el cuerpo del metodo
|-----------------------
| Los constructores no retornan nada
*/
{
guardarParametrosEnLaTabla(temp.lstParametros, parametros, hijo1);
_LST_CUERPO val = (_LST_CUERPO)temp.LST_CUERPO;
val.ejecutar(hijo1);
}
else if (temp.LST_CUERPO.nombre.Equals("LST_CUERPO2"))
/*
|----------------------------
| Ejecutando el cuerpo del metodo
|-----------------------
| Los constructores no retornan nada
*/
{
//cargo los parametros en el ambito global, jejejejeje
guardarParametrosEnLaTabla(temp.lstParametros, parametros, tablaEntorno);
//_LST_CUERPO2 val = (_LST_CUERPO2)temp.LST_CUERPO;
//val.ejecutarConstructor(hijo1, parametros);
}
}
}
public override itemRetorno ejecutar(elementoEntorno elementoEntor)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0 = normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
itemRetorno retorno = new itemRetorno(0);
if (hayErrores())
{
return(retorno);
}
_E nodoE = (_E)getNodo("E");
itemValor valE = nodoE.getValor(elementoEntor);
Object objetoValor = valE.getValorParseado("booleano");
Boolean condicion = false;
if (objetoValor != null)
{
condicion = (Boolean)objetoValor;
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("La condición devulelta no es de tipo booleano,es de tipo:" + valE.getTipo(), lstAtributos.getToken(0));
return(retorno);
}
while (condicion)
{
_LST_CUERPO nodoCuerpo = (_LST_CUERPO)getNodo("LST_CUERPO");
elementoEntorno entornoWhile = new elementoEntorno(elementoEntor, tablaSimbolos, "While", elementoEntor.este);
retorno = nodoCuerpo.ejecutar(entornoWhile);
//analizando el continue, el break, y el return
if (retorno.isRomper())
//este codigo sirve para eliminar el romper en los nodos, más arriba, y solo se quede en el case
{
return(new itemRetorno(0));
}
else if (retorno.isRetorno())
{
return(retorno);
}
else if (retorno.isContinuar())
{
return(new itemRetorno(0));
//retorno = new itemRetorno(0);
}
else if (hayErrores())
{
return(retorno);
}
//volviendo analizar el while
nodoE = (_E)getNodo("E");
valE = nodoE.getValor(elementoEntor);
objetoValor = valE.getValorParseado("booleano");
condicion = (Boolean)objetoValor;
}
if (retorno.isContinuar())
{
return(new itemRetorno(0));
}
return(retorno);
}
public itemRetorno ejecutar(elementoEntorno elementoEntor, itemValor expresion)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0 = normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
itemRetorno retorno = new itemRetorno(0);
if (hayErrores())
{
return(retorno);
}
if (hijos.Count == 3)
/*
|----------------------------
| E + sDosPuntos + sAbreLlave + LST_CUERPO + sCierraLlave + CUERPO_CASE
*/
{
_E nodoE = (_E)getNodo("E");
itemValor valE = nodoE.getValor(elementoEntor);
IgualQue igual = new IgualQue(new _E("temp1", tablaSimbolos), new _E("temp2", tablaSimbolos), tablaSimbolos, new token("="));
itemValor resultado = igual.opIgualacion(expresion, valE, "IGUALACION", elementoEntor);
Object objetoValor = resultado.getValorParseado("booleano");
Boolean condicion = false;
if (objetoValor != null)
{
condicion = (Boolean)objetoValor;
if (condicion)
{
_LST_CUERPO nodoCuerpo = (_LST_CUERPO)getNodo("LST_CUERPO");
itemRetorno break1 = nodoCuerpo.ejecutar(elementoEntor);
//voy a revisar si no hay break prro
if (break1.isRomper())
{
println("es romper");
itemRetorno ret2 = new itemRetorno(0);
//asi retorno un normal
return(ret2);
//aquí rompo prro
}
else
{
println("no es romper");
_CUERPO_CASE cuerpoCase = (_CUERPO_CASE)getNodo("CUERPO_CASE");
return(cuerpoCase.ejecutar(elementoEntor, expresion));
}
}
else
{
println("ejecutando cuerpo clase");
_CUERPO_CASE sino_si = (_CUERPO_CASE)getNodo("CUERPO_CASE");
return(sino_si.ejecutar(elementoEntor, expresion));
}
}
else
{
println("E + sDosPuntos + sAbreLlave + LST_CUERPO + sCierraLlave + CUERPO_CASE-> No se retorno un boolenano en la igualación");
return(retorno);
}
}
else if (hijos.Count == 2)
/*
|----------------------------
| E + sDosPuntos + sAbreLlave + LST_CUERPO + sCierraLlave
*/
{
_E nodoE = (_E)getNodo("E");
itemValor valE = nodoE.getValor(elementoEntor);
IgualQue igual = new IgualQue(new _E("temp1", tablaSimbolos), new _E("temp2", tablaSimbolos), tablaSimbolos, new token("="));
itemValor resultado = igual.opIgualacion(expresion, valE, "IGUALACION", elementoEntor);
Object objetoValor = resultado.getValorParseado("booleano");
Boolean condicion = false;
if (objetoValor != null)
{
condicion = (Boolean)objetoValor;
if (condicion)
{
_LST_CUERPO nodoCuerpo = (_LST_CUERPO)getNodo("LST_CUERPO");
return(nodoCuerpo.ejecutar(elementoEntor));
}
else
{
return(retorno);
}
}
else
{
println(" E + sDosPuntos + sAbreLlave + LST_CUERPO + sCierraLlave -> No se retorno un boolenano en la igualación");
return(retorno);
}
}
else if (hijos.Count == 1)
/*
|----------------------------
| tDefecto + sDosPuntos + sAbreLlave + LST_CUERPO + sCierraLlave;
*/
{
_LST_CUERPO nodoCuerpo = (_LST_CUERPO)getNodo("LST_CUERPO");
return(nodoCuerpo.ejecutar(elementoEntor));
}
else
{
return(retorno);
}
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN DE METODO
|-------------------------------------------------------------------------------------------------------------------
|
*/
public itemValor getMetodoFuncion(token nombre, lstValores parametros, elementoEntorno tablaEntorno, String nombreAmbitoEntorno)
{
itemValor retorno = new itemValor();
retorno.setTypeVacio();
//aqui es donde tengo que buscar si existe
Console.WriteLine("ejecutando Metodo:" + nombre.val);
elementoPolimorfo temp = getElementoPolimorfo2(nombre, parametros);
if (temp != null)
//neuvo entorno
{
elementoEntorno hijo1 = new elementoEntorno(tablaEntorno, tabla, nombreAmbitoEntorno, tablaEntorno.este);
guardarParametrosEnLaTabla(temp.lstParametros, parametros, hijo1);
if (temp.LST_CUERPO.nombre.Equals("LST_CUERPO"))
/*
|----------------------------
| Ejecutando el cuerpo del metodo
*/
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0 = normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
_LST_CUERPO val = (_LST_CUERPO)temp.LST_CUERPO;
itemRetorno result = val.ejecutar(hijo1);
if (temp.tipo.valLower.Equals("vacio"))
{
if (result.isNormal())//que es el normal
{
}
else if (result.isRetorno())
{
if (result.valor.isTypeVacio())
//fue el return normla, sin expresion
{
}
else
{
tabla.tablaErrores.insertErrorSemantic("El metodo :" + temp.nombre.val + " está declarado como vacio, pero se retorno una expresión", temp.nombre);
}
}
else
{
}
}
else
/*
| 0 = normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
if (result.isNormal())
{
tabla.tablaErrores.insertErrorSemantic("El metodo :" + temp.nombre.val + " debe de retorar un valor", temp.nombre);
}
else if (result.isRetorno())
{
if (temp.dimension == result.valor.dimensiones.Count)
{
//para los tipos
if (itemEntorno.validandoTipo(temp.tipo.valLower, result.valor))
{
return(result.valor);
}
else
{
tabla.tablaErrores.insertErrorSemantic("El metodo :" + temp.nombre.val + " es de tipo :" + temp.tipo.val + " sin embargo tiene un retorno de tipo: " + result.valor.getTipo(), temp.nombre);
return(retorno);
}
}
else
{
tabla.tablaErrores.insertErrorSemantic("El metodo :" + temp.nombre.val + " es de dimensión :" + temp.dimension + " sin embargo tiene un retorno de dimensión: " + result.valor.dimensiones.Count, temp.nombre);
return(retorno);
}
}
else
{
}
}
///hay que comparar el retorno con el tipo definido
}
//Console.WriteLine("---------------------------Imprimiendo el metodo Funcion-------------------------");
//hijo1.imprimir();
}
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemRetorno ejecutar(elementoEntorno elementoEntor)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0 = normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
itemRetorno retorno = new itemRetorno(0);
if (hayErrores())
{
return(retorno);
}
_E nodoE = (_E)getNodo("E");
itemValor valE = nodoE.getValor(elementoEntor);
Object objetoValor = valE.getValorParseado("booleano");
Boolean condicion = false;
if (objetoValor != null)
{
condicion = (Boolean)objetoValor;
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("La condición devulelta no es de tipo booleano,es de tipo:" + valE.getTipo(), lstAtributos.getToken(0));
return(retorno);
}
if (hijos.Count == 2)
/*
|----------------------------
| tSino + tSi + sAbreParent + E + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave
*/
{
if (condicion)
{
_LST_CUERPO nodoCuerpo = (_LST_CUERPO)getNodo("LST_CUERPO");
elementoEntorno entornoIf = new elementoEntorno(elementoEntor, tablaSimbolos, "Sino_Si", elementoEntor.este);
return(nodoCuerpo.ejecutar(entornoIf));
}
}
else if (hijos.Count == 3)
{
string caso = hijos[2].nombre;
if (caso.Equals("SINO_SI"))
/*
|----------------------------
| tSino + tSi + sAbreParent + E + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave + SINO_SI
*/
{
if (condicion)
{
_LST_CUERPO nodoCuerpo = (_LST_CUERPO)getNodo("LST_CUERPO");
elementoEntorno entornoIf = new elementoEntorno(elementoEntor, tablaSimbolos, "Sino_Si", elementoEntor.este);
return(nodoCuerpo.ejecutar(entornoIf));
}
else
{
_SINO_SI sino_si = (_SINO_SI)getNodo("SINO_SI");
return(sino_si.ejecutar(elementoEntor));
}
}
else if (caso.Equals("SINO"))
/*
|----------------------------
| tSino + tSi + sAbreParent + E + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave + SINO;
*/
{
if (condicion)
{
_LST_CUERPO nodoCuerpo = (_LST_CUERPO)getNodo("LST_CUERPO");
elementoEntorno entornoIf = new elementoEntorno(elementoEntor, tablaSimbolos, "Sino_si", elementoEntor.este);
return(nodoCuerpo.ejecutar(entornoIf));
}
else
{
_SINO nodoSINO = (_SINO)getNodo("SINO");
elementoEntorno entornoSino = new elementoEntorno(elementoEntor, tablaSimbolos, "Sino", elementoEntor.este);
return(nodoSINO.ejecutar(entornoSino));
}
}
}
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemRetorno ejecutar(elementoEntorno elementoEntor)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0= normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
itemRetorno retorno = new itemRetorno(0);
if (hayErrores())
{
return(retorno);
}
if (hijos[0].nombre.Equals("DECLARAR_VARIABLE_SINVISIBI"))
/*
|----------------------------
| tPara + sAbreParent + DECLARAR_VARIABLE_SINVISIBI + sPuntoComa + E + sPuntoComa + ASIG_VALOR+ sCierraParent+ sAbreLlave+ LST_CUERPO + sCierraLlave
*/
{
nodoModelo nodotemp = getNodo("DECLARAR_VARIABLE_SINVISIBI");
if (nodotemp == null)
{
return(retorno);
}
_DECLARAR_VARIABLE_SINVISIBI decla = (_DECLARAR_VARIABLE_SINVISIBI)nodotemp;
decla.ejecutar(elementoEntor);
_E nodoE = (_E)getNodo("E");
itemValor valE = nodoE.getValor(elementoEntor);
Object objetoValor = valE.getValorParseado("booleano");
Boolean condicion = false;
if (objetoValor != null)
{
condicion = (Boolean)objetoValor;
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("La condición devulelta no es de tipo booleano,es de tipo:" + valE.getTipo(), lstAtributos.getToken(0));
return(retorno);
}
while (condicion)
{
elementoEntorno entornoFor = new elementoEntorno(elementoEntor, tablaSimbolos, "para", elementoEntor.este);
_LST_CUERPO nodoCuerpo = (_LST_CUERPO)getNodo("LST_CUERPO");
retorno = nodoCuerpo.ejecutar(entornoFor);
//analizando el continue, el break, y el return
if (retorno.isRomper())
//este codigo sirve para eliminar el romper en los nodos, más arriba, y solo se quede en el case
{
return(new itemRetorno(0));
}
else if (retorno.isRetorno())
{
return(retorno);
}
else if (retorno.isContinuar())
{
return(new itemRetorno(0));
//retorno = new itemRetorno(0);
}
else if (hayErrores())
{
return(retorno);
}
//i++
_ASIG_VALOR asig = (_ASIG_VALOR)getNodo("ASIG_VALOR");
asig.ejecutar(entornoFor);
//volviendo analizar el while
nodoE = (_E)getNodo("E");
valE = nodoE.getValor(entornoFor);
objetoValor = valE.getValorParseado("booleano");
condicion = (Boolean)objetoValor;
}
if (retorno.isContinuar())
{
return(new itemRetorno(0));
}
}
else if (hijos[0].nombre.Equals("ASIG_VALOR"))
/*
|----------------------------
| tPara + sAbreParent + ASIG_VALOR + sPuntoComa + E + sPuntoComa + ASIG_VALOR + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave;
*/
{
nodoModelo nodotemp = getNodo("ASIG_VALOR");
if (nodotemp == null)
{
return(retorno);
}
_ASIG_VALOR decla = (_ASIG_VALOR)hijos[0];
decla.ejecutar(elementoEntor);
_E nodoE = (_E)getNodo("E");
itemValor valE = nodoE.getValor(elementoEntor);
Object objetoValor = valE.getValorParseado("booleano");
Boolean condicion = false;
if (objetoValor != null)
{
condicion = (Boolean)objetoValor;
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("La condición devulelta no es de tipo booleano,es de tipo:" + valE.getTipo(), lstAtributos.getToken(0));
return(retorno);
}
while (condicion)
{
elementoEntorno entornoFor = new elementoEntorno(elementoEntor, tablaSimbolos, "para", elementoEntor.este);
_LST_CUERPO nodoCuerpo = (_LST_CUERPO)getNodo("LST_CUERPO");
retorno = nodoCuerpo.ejecutar(entornoFor);
//analizando el continue, el break, y el return
if (retorno.isRomper())
//este codigo sirve para eliminar el romper en los nodos, más arriba, y solo se quede en el case
{
return(new itemRetorno(0));
}
else if (retorno.isRetorno())
{
return(retorno);
}
else if (retorno.isContinuar())
{
return(new itemRetorno(0));
//retorno = new itemRetorno(0);
}
else if (hayErrores())
{
return(retorno);
}
//i++
_ASIG_VALOR asig = (_ASIG_VALOR)hijos[2];
asig.ejecutar(entornoFor);
//volviendo analizar el while
nodoE = (_E)getNodo("E");
valE = nodoE.getValor(entornoFor);
objetoValor = valE.getValorParseado("booleano");
condicion = (Boolean)objetoValor;
}
if (retorno.isContinuar())
{
return(new itemRetorno(0));
}
}
return(retorno);
}