/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemRetorno ejecutar(elementoEntorno tablaEntornos)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0= normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
itemRetorno retorno = new itemRetorno(0);
//ya estoy recibiendo la tabla donde debo trabajar prro
if (hayErrores())
{
return(retorno);
}
nodoModelo nodoTemp = getNodo("LST_VAL");
_LST_VAL lstParametros = (_LST_VAL)nodoTemp;
// lstValores parametros, elementoEntorno tablaEntorno, token linea
tablaEntornos.este.ejecutarConstructorHeredado(lstParametros.getLstValores(tablaEntornos), tablaEntornos, lstAtributos.getToken(0));
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public itemRetorno ejecutarConstructor(elementoEntorno tablaEntornos, lstValores parametros)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0= normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
itemRetorno retorno = new itemRetorno(2);
println("ejecutnando el constructor que hice de pregunta ========#/(&/$$$$$$$$$$$$$$");
foreach (itemValor tem in parametros.listaValores)
{
println("--------");
tem.imprimirVariable();
}
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemRetorno ejecutar(elementoEntorno elementoEntorno)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0= normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
itemRetorno retorno = new itemRetorno(0);
if (hayErrores())
return retorno;
nodoModelo nodoTemp = getNodo("LST_VAL");
_LST_VAL lstParametros = (_LST_VAL)nodoTemp;
token nombre = lstAtributos.getToken(1);
_ESCRIBIR_ARCHIVO.resetVariables(nombre.val);
elementoEntorno.este.ejecutarFormulario(nombre, lstParametros.getLstValores(elementoEntorno), elementoEntorno.este.tablaEntorno.raiz);
return retorno;
}
public itemRetorno ejecutarHijos(elementoEntorno elem)
{
itemRetorno retorno = new itemRetorno(0);
if (hayErrores())
{
return(retorno);
}
foreach (nodoModelo temp in hijos)
{
itemRetorno resultado = temp.ejecutar(elem);
if (resultado.isNormal())
{
//continua normal
}
else
{
return(resultado);
}
}
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemRetorno ejecutar(elementoEntorno tablaEntornos)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0 = normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
itemRetorno retorno = new itemRetorno(0);
if (hayErrores())
{
return(retorno);
}
_LST_VAL temp = (_LST_VAL)getNodo("LST_VAL");
lstValores listaValores = temp.getLstValores(tablaEntornos);
if (listaValores.listaValores.Count == 2)
/*
|----------------------------
| NOMBRE, TEXTO
*/
{
}
else if (listaValores.listaValores.Count == 1)
/*
|----------------------------
| TEXTO
*/
{
itemValor limitInf = listaValores.listaValores[0];
Object obj = limitInf.getValorParseado("cadena");
if (obj != null)
{
String contenido = (String)obj;
contenido = "\n < tr > " +
"\n <td>" + numPregunta + "</td>" + contenido;
numPregunta++;
_ESCRIBIR_ARCHIVO.contenido = _ESCRIBIR_ARCHIVO.contenido + contenido;
escribirArchivo(_ESCRIBIR_ARCHIVO.contenido, _ESCRIBIR_ARCHIVO.nombreArchivo);
return(retorno);
}
}
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemRetorno ejecutar(elementoEntorno tablaEntornos)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0= normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
itemRetorno retorno = new itemRetorno(0);
if (hayErrores())
{
return(retorno);
}
if (hijos.Count != 2)
{
tablaSimbolos.tablaErrores.insertErrorSemantic("Se estan esperando dos parametros, ruta de audio, y valor booleano", lstAtributos.getToken(0));
return(retorno);
}
_E nodo1 = (_E)hijos[0];
_E nodo2 = (_E)hijos[1];
itemValor itRuta = nodo1.getValor(tablaEntornos);
itemValor itBoolean = nodo2.getValor(tablaEntornos);
Object objRuta = itRuta.getValorParseado("cadena");
Object objBool = itBoolean.getValorParseado("booleano");
if (objRuta == null || objBool == null)
{
tablaSimbolos.tablaErrores.insertErrorSemantic("Uno de los parámetros no fue cadena y/o booleano", lstAtributos.getToken(0));
return(retorno);
}
else
{
string ruta = (string)objRuta;
ruta = tablaSimbolos.getRutaProyecto() + "\\" + ruta;
Boolean booleano = (Boolean)objBool;
frmAudio fdecimal = new frmAudio(tablaEntornos, ruta, booleano);
fdecimal.ShowDialog();
return(retorno);
}
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemRetorno ejecutar(elementoEntorno tablaEntornos)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0= normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
itemRetorno retorno = new itemRetorno(1);
if (hayErrores())
{
return(retorno);
}
if (hijos.Count > 0)
/*
|----------------------------
| tRetorno + VALOR + sPuntoComa;
*/
{
nodoModelo nodoTemp = getNodo("VALOR");
if (nodoTemp != null)
{
_VALOR val = (_VALOR)nodoTemp;
itemValor tempValor = val.getValor(tablaEntornos, new token(""));
retorno.setValueRetorno(tempValor);
return(retorno);
}
else
{
return(retorno);
}
}
else
/*
|----------------------------
| RETORNO.Rule = tRetorno + sPuntoComa
|------------------------------
| Desde aquí ya no sigue la ejecución.
*/
{
return(retorno);
}
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemRetorno ejecutar(elementoEntorno tablaEntornos)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0= normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
itemRetorno retorno = new itemRetorno(2);
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemRetorno ejecutar(elementoEntorno tablaEntornos)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0= normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
itemRetorno retorno = new itemRetorno(0);
//ya estoy recibiendo la tabla donde debo trabajar prro
if (hayErrores())
{
return(retorno);
}
token tipo = getTipo();
token nombre = getIdentificador();
//nodoModelo LST_CUERPO = getLST_CUERPO();
token visbilidad = new token("privado");
List <int> dimension = getDimensiones();
_VAL val = getNodoVAL();
if (val != null)
{
//se estan guardando valores en la variable
itemEntorno it = new itemEntorno(nombre, tipo, val.getValor(tablaEntornos, tipo), visbilidad, dimension, tablaSimbolos);
tablaEntornos.insertarEntorno(it);
}
else
{
//Se declaro la variable pero el valor es nulo
itemEntorno it = new itemEntorno(nombre, tipo, new itemValor(), visbilidad, dimension, tablaSimbolos);
tablaEntornos.insertarEntorno(it);
}
return(retorno);
}
/*
*
* ID_VAR_FUNC.Rule = ID_VAR_FUNC + LST_PUNTOSP
| tEste + sPunto + valId
| valId
| tEste + sPunto + valId + sAbreParent + LST_VAL + sCierraParent
| valId + sAbreParent + LST_VAL + sCierraParent
|
|
#para los corchetes
|
| tEste + sPunto + valId + LST_CORCHETES_VAL
| valId + LST_CORCHETES_VAL
| tEste + sPunto + valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL
| valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL;
| ;
*/
//elementoEntorno elementoEntorno;
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN DESDE EL CUERPO DEL METODO
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemRetorno ejecutar(elementoEntorno tablaEntornos)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0= normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
itemRetorno retorno = new itemRetorno(0);
itemValor te2 = getValor(tablaEntornos);
//println(te2.getTipo() + "|" + te2.nombrePregunta.valLower + "|entorno de ejecutar final ===================================0");
//if (!(te2.nombrePregunta.valLower.Equals("---") && te2.nombrePregunta.valLower.Equals("") && te2.nombrePregunta.valLower.Equals("--")))
if (te2.nombrePregunta.esPregunta)
{
//println("Estoy ejecutando");
if (te2 != null)
{
//ahora hay que buscarl la pregunta en la tabla de simbolos prro.
itemValor te3 = getValId(te2.nombrePregunta, tablaEntornos);
if (te3.isTypeObjeto())
{
elementoEntorno entor = te3.getObjeto().tablaEntorno.raiz;
entor.este.ejecutarMetodoFuncion(new token("ejecutarfinal"), new lstValores(), entor);
}
else
{
println("no me retorno un objeto");
}
}
else
{
println("[Error]sin mvalor fue nulo");
}
}
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemRetorno ejecutar(elementoEntorno elementoEntor)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0 = normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
/*
|----------------------------
| tCaso + sAbreParent + E + sCierraParent + tDe + sAbreLlave + CUERPO_CASE + sCierraLlave;
*/
itemRetorno retorno = new itemRetorno(0);
if (hayErrores())
{
return(retorno);
}
_E nodoE = (_E)getNodo("E");
itemValor valE = nodoE.getValor(elementoEntor);
_CUERPO_CASE nodoCuerpo = (_CUERPO_CASE)hijos[1];
elementoEntorno entornoIf = new elementoEntorno(elementoEntor, tablaSimbolos, "case", elementoEntor.este);
itemRetorno cuerpoCase = nodoCuerpo.ejecutar(entornoIf, valE);
if (cuerpoCase.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
{
return(retorno);
}
}
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);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| 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);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemRetorno ejecutar(elementoEntorno tablaEntornos)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0= normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
itemRetorno retorno = new itemRetorno(0);
if (hayErrores())
{
return(retorno);
}
if (hijos.Count == 2)
/*
|----------------------------
| ID_VAR_FUNC + VAL
*/
{
//PUNTERO DONDE VOY A GUARDAR EL VALOR
_ID_VAR_FUNC nodoFunc = (_ID_VAR_FUNC)getNodo("ID_VAR_FUNC");
itemEntorno destino = nodoFunc.getDestino(tablaEntornos);
//AHORA OBTENGO EL VALOR
_VAL nodoVal = (_VAL)getNodo("VAL");
if (nodoVal != null)
{
if (destino != null)
{
itemValor valor = nodoVal.getValor(tablaEntornos, destino.tipo);
if (destino.lstDimensionesAcceso.Count > 0)
//viene la posición de un arreglo
{
asignarValorMatriz(destino, valor);
}
else
{
asignarValor(destino, valor);
}
}
else
{
println("Me retorno un itemEntorno vacio, no podré asignar la variable prro");
}
}
else
{
println("no tiene nodo VAl");
}
}
else if (hijos.Count == 1)
{
if (lstAtributos.getToken(0).valLower.Equals("+"))
/*
|----------------------------
| ID_VAR_FUNC + sMas + sMas
*/
{
if (hayErrores())
{
return(retorno);
}
_ID_VAR_FUNC nodoFunc = (_ID_VAR_FUNC)getNodo("ID_VAR_FUNC");
itemEntorno destino = nodoFunc.getDestino(tablaEntornos);
if (destino.lstDimensionesAcceso.Count > 0)
//viene la posición de un arreglo
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede incrementar la matriz " + destino.nombre.val + " de tipo: " + destino.tipo.valLower, destino.nombre);
}
else
{
itemValor valor = nodoFunc.getValor(tablaEntornos);
itemValor valor2 = new itemValor();
valor2.setValue(1);
suma sumatoria = new suma(new _E("hijo1", tablaSimbolos), new _E("hijo2", tablaSimbolos), tablaSimbolos, lstAtributos.getToken(0));
itemValor resultado = sumatoria.opSumaExterna(tablaEntornos, valor, valor2);
Object ObjParseado = resultado.getValorParseado(destino.tipo.valLower);
if (ObjParseado != null)
{
destino.valor.valor = ObjParseado;
return(retorno);
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede asignar un tipo :" + sumatoria.GetType() + " a la variable " + destino.nombre.val + " de tipo: " + destino.tipo.valLower, destino.nombre);
return(retorno);
}
}
}
else
/*
|----------------------------
| ID_VAR_FUNC + smenos + smenos
*/
{
if (hayErrores())
{
return(retorno);
}
_ID_VAR_FUNC nodoFunc = (_ID_VAR_FUNC)getNodo("ID_VAR_FUNC");
itemEntorno destino = nodoFunc.getDestino(tablaEntornos);
if (destino.lstDimensionesAcceso.Count > 0)
//viene la posición de un arreglo
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede incrementar la matriz " + destino.nombre.val + " de tipo: " + destino.tipo.valLower, destino.nombre);
}
else
{
itemValor valor = nodoFunc.getValor(tablaEntornos);
itemValor valor2 = new itemValor();
valor2.setValue(1);
resta sumatoria = new resta(new _E("hijo1", tablaSimbolos), new _E("hijo2", tablaSimbolos), tablaSimbolos, lstAtributos.getToken(0));
itemValor resultado = sumatoria.opRestaExterna(tablaEntornos, valor, valor2);
Object ObjParseado = resultado.getValorParseado(destino.tipo.valLower);
if (ObjParseado != null)
{
destino.valor.valor = ObjParseado;
return(retorno);
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede asignar un tipo :" + sumatoria.GetType() + " a la variable " + destino.nombre.val + " de tipo: " + destino.tipo.valLower, destino.nombre);
return(retorno);
}
}
}
}
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 FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemRetorno ejecutar(elementoEntorno elementoEntor)
{
itemRetorno retorno = new itemRetorno(0);
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);
}
/*
|--------------------------------------------------------------------------
| La ejecución FINAL con ITem entorno
|--------------------------------------------------------------------------
|
|
|
| public virtual void ejecutar(elementoEntorno elem, itemEntorno item)
| {
| ejecutarHijos(elem, item);
| }
|
| public void ejecutarHijos(elementoEntorno elem, itemEntorno item)
| {
|
| if (hayErrores())
| return;
|
| foreach (nodoModelo temp in hijos)
| {
| temp.ejecutar(elem, item);
| }
| }*/
/*
|--------------------------------------------------------------------------
| La ejecución FINAL
|--------------------------------------------------------------------------
| 0= normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
public virtual itemRetorno ejecutar(elementoEntorno tablaEntornos)
{
itemRetorno resultado = ejecutarHijos(tablaEntornos);
return(resultado);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemRetorno ejecutar(elementoEntorno tablaEntornos)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0= normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
itemRetorno retorno = new itemRetorno(0);
//ya estoy recibiendo la tabla donde debo trabajar prro
if (hayErrores())
{
return(retorno);
}
_VALOR val = getNodoVALOR();
if (val != null)
{
//se estan guardando valores en la variable
// println("Ejecutando el imprimir que tiene un hijo de valore ejejejejejejejejej");
itemValor temp = val.getValor(tablaEntornos, new token());
if (temp.isTypeNulo())
{
tablaSimbolos.consola.insertar("nulo");
}
else
{
if (tablaSimbolos.consola != null)
{
if (temp.valor != null)
{
try
{
tablaSimbolos.consola.insertar(temp.valor.ToString());
}
catch (Exception e)
{
tablaSimbolos.consola.insertar(e.ToString());
}
}
//tablaSimbolos.consola.insertar("imprimiendo");
}
else
{
println("tablaSimblo.consola is null");
}
//
}
}
else
{
tablaSimbolos.consola.insertar("");
}
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);
}
