public override void ejecutar(elementoEntorno elem)
{
foreach (elementoPolimorfo temp in listaPolimorfa)
{
if (temp.LST_CUERPO.nombre.Equals("VAL"))
{
if (tabla.hayErrores("lstVariablesGlobales_ejecutar"))
{
return;
}
_VAL val = (_VAL)temp.LST_CUERPO;
itemEntorno it = new itemEntorno(temp.nombre, temp.tipo, val.getValor(elem, temp.tipo), temp.visibilidad, temp.getDimension(), tabla);
elem.insertarEntorno(it);
}
else
{
println("vienen nulos");
itemEntorno it = new itemEntorno(temp.nombre, temp.tipo, new itemValor(), temp.visibilidad, temp.getDimension(), tabla);
elem.insertarEntorno(it);
//hay que asignarle el valor nulo
//println("la variable no tiene valor");
}
}
}
/*
|-------------------------------------------------------------------------------------------------------------------
| 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);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN DE PRINCIPAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public void guardarParametrosEnLaTabla(Dictionary <llaveParametro, elementoParametro> lstParametros, lstValores lstParametros2, elementoEntorno elementoEntor)
{
if (lstParametros.Count == lstParametros2.listaValores.Count)
{
int i = 0;
foreach (var dic in lstParametros)
{
itemValor parametro2 = lstParametros2.getItemValor(i);
//Console.WriteLine("------------------------");
//Console.WriteLine("dic.key.dimension-> " + dic.Key.dimension);
//Console.WriteLine("parametro2.dimensiones->" + parametro2.dimensiones.Count);
if ((dic.Key.dimension == parametro2.dimensiones.Count) && (itemEntorno.validandoTipo(dic.Value.tipo.valLower, parametro2)))
{
token tNombre = new token(dic.Key.nombre);
token tTipo = new token(dic.Value.tipo.valLower);
//println("guardarParametrosEnLaTabla_ tipo->" + tTipo.valLower);
token tVisibilidad = new token("privado");
//listado de enteros
List <int> listaEntero = new List <int>();
for (int j = 0; i < dic.Key.dimension; i++)
{
listaEntero.Add(-1);
}
itemEntorno varParametro = new itemEntorno(tNombre, tTipo, parametro2, tVisibilidad, listaEntero, tabla);
elementoEntor.insertarEntorno(varParametro);
}
else
{
Console.WriteLine("[lstPolimorfismo]guardarParametrosEnLaTabla_Son de diferentes en tipo, o en dimensiones, aunque esto ya se tuvo que validar :/");
}
i++;
}
}
else
{
Console.WriteLine("[lstPolimorfismo]guardarParametrosEnLaTabla_Son de diferentes dimensiones, aunque esto ya se tuvo que validar :/");
}
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public itemValor getValor(elementoEntorno elementoEntorno)
{
itemValor retorno = new itemValor();
retorno.setTypeVacio();
retorno.setTypeVacio(); //no puede retornar nada, es un metodo mahe
if (hayErrores())
{
return(retorno);
}
if (lstAtributos.listaAtributos.Count == 0)
/*
|----------------------------
| ID_VAR_FUNC + LST_PUNTOSP
*/
{
#region reg1
nodoModelo idVar = getNodo("ID_VAR_FUNC");
if (idVar != null)
{
nodoModelo lstPuntos = getNodo("LST_PUNTOSP");
if (lstPuntos != null)
{
_ID_VAR_FUNC temp1 = (_ID_VAR_FUNC)idVar;
_LST_PUNTOSP puntos = (_LST_PUNTOSP)lstPuntos;
itemValor te1 = temp1.getValor(elementoEntorno);
itemValor te2 = puntos.getValor(elementoEntorno, te1);
//aquí puedo revisar si fue una pregunta para poder guardarla en el entorno
/* if (te2.isTypeObjeto())
* {
* if (te2.nombreObjeto.Equals("form"))
* {
*
* //guardando la pregunta dentro de la tabla de simbolos, jejejejejejejejejejejejejeje
* itemEntorno sim = new itemEntorno(te1.nombrePregunta, te1.nombrePregunta, te1, new token("publico"), new List<int>(), tablaSimbolos);
* elementoEntorno.insertarEntorno(sim);
*
*
* ///ejecuto el metodo ejecutar final, es el que muestra las preguntas
* //elementoEntorno.este.ejecutarMetodoFuncion(new token("ejecutarfinal"), new lstValores(), sim.valor.getObjeto().tablaEntorno.raiz);
* //println("entorno de ejecutar final ===================================0");
*
* // sim.valor.getObjeto().tablaEntorno.raiz.este.ejecutarMetodoFuncion(new token("ejecutarfinal"), new lstValores(), sim.valor.getObjeto().tablaEntorno.raiz);
*
*
* }
* }
*
* if(te1.nombrePregunta.esPregunta)
* {
*
* if (temp1.lstAtributos.listaAtributos.Count > 0)
* {
* String nombreToken = temp1.lstAtributos.listaAtributos[0].nombretoken;
*
* if (nombreToken.Equals("valId"))
* {
* //ahora ya que revisar que se encuentre entre la lsita de preguntas.
* // elementoEntorno.este.cuerpoClase.ls
* if (tablaSimbolos.esPregunta(temp1.lstAtributos.getToken(0).valLower))
* {
* //es pregunta
* itemEntorno sim = new itemEntorno(te1.nombrePregunta, te1.nombrePregunta, te1, new token("publico"), new List<int>(), tablaSimbolos);
* elementoEntorno.insertarEntorno(sim);
*
* }
*
* }
*
* }
*
*
* }
*/
return(te2);
//tengo que obtener el objeto de id_var_func
}
}
#endregion
}
else if (lstAtributos.listaAtributos.Count == 1)
{
if (hijos.Count > 0)
/*
|----------------------------
| valId + LST_CORCHETES_VAL
|------------
| Lst_Corchtes tiene que retornar una lista de tipo entero
|
*/
{
#region reg2
token nombreVar = lstAtributos.getToken(0);
nodoModelo nodoLstCor = getNodo("LST_CORCHETES_VAL");
if (nodoLstCor != null)
{
_LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)nodoLstCor;
List <int> listaEntero = lstCorchetes.getLstInt(elementoEntorno, nombreVar);
String item1 = lstAtributos.listaAtributos[0].nombretoken;
//mapeando el indice
if (item1.Equals("valId"))
{
return(getValIdCorchetes(lstAtributos.listaAtributos[0].tok, elementoEntorno, listaEntero));
}
else
{
println(" valId + LST_CORCHETES_VAL -> No viene val id");
}
}
#endregion
}
else
/*
|----------------------------
| valId
*/
{
#region reg3
String item1 = lstAtributos.listaAtributos[0].nombretoken;
if (item1.Equals("valId"))
{
return(getValId(lstAtributos.listaAtributos[0].tok, elementoEntorno));
}
#endregion
}
}
else if (lstAtributos.listaAtributos.Count == 3)
{
String item1 = lstAtributos.listaAtributos[0].nombretoken;
String item2 = lstAtributos.listaAtributos[1].nombretoken;
String item3 = lstAtributos.listaAtributos[2].nombretoken;
if (item1.Equals("este") && item2.Equals(".") && item3.Equals("valId"))
{
if (hijos.Count > 0)
/*
|----------------------------
| tEste + sPunto + valId + LST_CORCHETES_VAL
*/
{
#region reg4
token nombreVar = lstAtributos.getToken(2);
nodoModelo nodoLstCor = getNodo("LST_CORCHETES_VAL");
if (nodoLstCor != null)
{
_LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)nodoLstCor;
List <int> listaEntero = lstCorchetes.getLstInt(elementoEntorno, nombreVar);
String item11 = lstAtributos.listaAtributos[2].nombretoken;
//mapeando el indice
if (item11.Equals("valId"))
{
return(getValIdCorchetes(lstAtributos.listaAtributos[2].tok, elementoEntorno.este.tablaEntorno.raiz, listaEntero));
}
else
{
println(" tEste + sPunto + valId + LST_CORCHETES_VAL -> No viene val id");
}
}
#endregion
}
else
/*
|----------------------------
| tEste + sPunto + valId
*/
{
#region cuerpo
String esteId = lstAtributos.listaAtributos[2].nombretoken;
if (esteId.Equals("valId"))
{
return(getValId(lstAtributos.listaAtributos[2].tok, elementoEntorno.este.tablaEntorno.raiz));
}
else
{
println("(tEste + sPunto + valId) No se encontró valId");
}
#endregion
}
}
if (item1.Equals("valId") && item2.Equals("(") && item3.Equals(")"))
{
if (hijos.Count == 2)
/*
|----------------------------
| valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL;
|------------------------
* Primero ejecuto el metodo que me tiene que retornar siempre dimension>0
* luego enviarle ese valor, para extraer lo que se quiere
*/
{
#region cuerpo
if (hayErrores())
{
return(retorno);
}
String esteId = lstAtributos.listaAtributos[0].nombretoken;
if (esteId.Equals("valId"))
{
//esto es del metodo
nodoModelo nodoTemp = getNodo("LST_VAL");
_LST_VAL lstParametros = (_LST_VAL)nodoTemp;
itemValor itemValorRetornoMetodo = elementoEntorno.este.ejecutarMetodoFuncion(lstAtributos.getToken(0), lstParametros.getLstValores(elementoEntorno), elementoEntorno.este.tablaEntorno.raiz);
//esto es de la parte del arreglo
nodoModelo nodoLstCorchetes = getNodo("LST_CORCHETES_VAL");
_LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)nodoLstCorchetes;
List <int> listaEntero = lstCorchetes.getLstInt(elementoEntorno, lstAtributos.listaAtributos[0].tok);
if (itemValorRetornoMetodo.dimensiones.Count == listaEntero.Count)
//tienen la misma dimension
{
println("getValCorchetes");
return(getValCorchetes(lstAtributos.getToken(0), elementoEntorno, listaEntero, itemValorRetornoMetodo));
}
else
//no tienen la misma dimensión.
{
tablaSimbolos.tablaErrores.insertErrorSemantic("El metodo: " + lstAtributos.getToken(0).val + " no devuelve la misma cantidad de dimensiones que a las que se quiere acceder", lstAtributos.getToken(0));
return(retorno);
}
}
else
{
println("valId + sAbreParent + LST_VAL + sCierraParent; -> no viene valId");
return(retorno);
}
#endregion
}
if (hijos.Count == 1)
{
String nombreHijo = hijos[0].nombre;
if (nombreHijo.Equals("LST_CORCHETES_VAL"))
/*
|----------------------------
| valId + sAbreParent + sCierraParent + LST_CORCHETES_VAL;
*/
{
#region cuerpo
if (hayErrores())
{
return(retorno);
}
String esteId = lstAtributos.listaAtributos[0].nombretoken;
if (esteId.Equals("valId"))
{
//esto es del metodo
nodoModelo nodoTemp = getNodo("LST_VAL");
lstValores sinParametros = new lstValores();
itemValor itemValorRetornoMetodo = elementoEntorno.este.ejecutarMetodoFuncion(lstAtributos.getToken(0), sinParametros, elementoEntorno.este.tablaEntorno.raiz);
//esto es de la parte del arreglo
nodoModelo nodoLstCorchetes = getNodo("LST_CORCHETES_VAL");
_LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)nodoLstCorchetes;
List <int> listaEntero = lstCorchetes.getLstInt(elementoEntorno, lstAtributos.listaAtributos[0].tok);
if (itemValorRetornoMetodo.dimensiones.Count == listaEntero.Count)
//tienen la misma dimension
{
println("getValCorchetes");
return(getValCorchetes(lstAtributos.getToken(0), elementoEntorno, listaEntero, itemValorRetornoMetodo));
}
else
//no tienen la misma dimensión.
{
tablaSimbolos.tablaErrores.insertErrorSemantic("El metodo: " + lstAtributos.getToken(0).val + " no devuelve la misma cantidad de dimensiones que a las que se quiere acceder", lstAtributos.getToken(0));
return(retorno);
}
}
else
{
println("valId + sAbreParent + LST_VAL + sCierraParent; -> no viene valId");
return(retorno);
}
#endregion
}
else if (nombreHijo.Equals("LST_VAL"))
/*
|----------------------------
| valId + sAbreParent + LST_VAL + sCierraParent;
|-------------
| Esto es un metodo
| Desde aquí puedo llamar a las preguntas, y tiene mayor prioridad
| si me encuentro dentro de un entorno de nombre, formulario, o de nombre grupo
*/
{
#region cuerpo
String esteId = lstAtributos.listaAtributos[0].nombretoken;
/*if (elementoEntorno.nombre.Equals("formulario") || elementoEntorno.nombre.Equals("grupo"))
*
* Esto es como el constructor nuevo pregunta()
*
* {
* }*/
//primero busco en las preguntas, luego en los metodos, jejejejeje
itemValor ret = crearPregunta(elementoEntorno);
if (ret != null)
{
//eso quiere decir que es una pregunta
ret.nombrePregunta = lstAtributos.getToken(0);
ret.nombrePregunta.esPregunta = true;
itemEntorno sim = new itemEntorno(ret.nombrePregunta, ret.nombrePregunta, ret, new token("publico"), new List <int>(), tablaSimbolos);
elementoEntorno.insertarEntorno(sim);
return(ret);
}
//si no lo encuentro como pregunta, sigo la ejecución en busca de un metodo.
if (esteId.Equals("valId"))
{
nodoModelo nodoTemp = getNodo("LST_VAL");
_LST_VAL lstParametros = (_LST_VAL)nodoTemp;
return(elementoEntorno.este.ejecutarMetodoFuncion(lstAtributos.getToken(0), lstParametros.getLstValores(elementoEntorno), elementoEntorno.este.tablaEntorno.raiz));
}
else
{
println("valId + sAbreParent + LST_VAL + sCierraParent; -> no viene valId");
}
#endregion
}
}
if (hijos.Count == 0)
/*
|----------------------------
| valId + sAbreParent + sCierraParent;
|-------------
| Esto es un metodo sin parámetros
| hay que buscarlo entre la lista de metodos
*/
{
#region cuerpo
String esteId = lstAtributos.listaAtributos[0].nombretoken;
if (esteId.Equals("valId"))
{
lstValores sinParametros = new lstValores();
return(elementoEntorno.este.ejecutarMetodoFuncion(lstAtributos.getToken(0), sinParametros, elementoEntorno.este.tablaEntorno.raiz));
}
else
{
println("valId + sAbreParent + sCierraParent -> no viene valId");
}
#endregion
}
}
}
else if (lstAtributos.listaAtributos.Count == 5)
{
String item1 = lstAtributos.listaAtributos[0].nombretoken;
String item2 = lstAtributos.listaAtributos[1].nombretoken;
String item3 = lstAtributos.listaAtributos[2].nombretoken;
if (item1.Equals("este") && item2.Equals(".") && item3.Equals("valId"))
{
if (hijos.Count == 2)
/*
|----------------------------
| tEste + sPunto + valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL;
*/
{
#region cuerpo
if (hayErrores())
{
return(retorno);
}
String esteId = lstAtributos.listaAtributos[2].nombretoken;
if (esteId.Equals("valId"))
{
//esto es del metodo
nodoModelo nodoTemp = getNodo("LST_VAL");
_LST_VAL lstParametros = (_LST_VAL)nodoTemp;
itemValor itemValorRetornoMetodo = elementoEntorno.este.ejecutarMetodoFuncion(lstAtributos.getToken(2), lstParametros.getLstValores(elementoEntorno), elementoEntorno.este.tablaEntorno.raiz);
//esto es de la parte del arreglo
nodoModelo nodoLstCorchetes = getNodo("LST_CORCHETES_VAL");
_LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)nodoLstCorchetes;
List <int> listaEntero = lstCorchetes.getLstInt(elementoEntorno, lstAtributos.listaAtributos[2].tok);
if (itemValorRetornoMetodo.dimensiones.Count == listaEntero.Count)
//tienen la misma dimension
{
println("getValCorchetes");
return(getValCorchetes(lstAtributos.getToken(2), elementoEntorno, listaEntero, itemValorRetornoMetodo));
}
else
//no tienen la misma dimensión.
{
tablaSimbolos.tablaErrores.insertErrorSemantic("El metodo: " + lstAtributos.getToken(2).val + " no devuelve la misma cantidad de dimensiones que a las que se quiere acceder", lstAtributos.getToken(2));
return(retorno);
}
}
else
{
println("tEste + sPunto + valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL;");
}
#endregion
}
else if (hijos.Count == 1)
{
if (hijos[0].nombre.Equals("LST_CORCHETES_VAL"))
/*
|----------------------------
| tEste + sPunto + valId + sAbreParent + sCierraParent + LST_CORCHETES_VAL;
*/
{
#region cuerpo
if (hayErrores())
{
return(retorno);
}
String esteId = lstAtributos.listaAtributos[2].nombretoken;
if (esteId.Equals("valId"))
{
//esto es del metodo
nodoModelo nodoTemp = getNodo("LST_VAL");
lstValores sinParametros = new lstValores();
itemValor itemValorRetornoMetodo = elementoEntorno.este.ejecutarMetodoFuncion(lstAtributos.getToken(2), sinParametros, elementoEntorno.este.tablaEntorno.raiz);
//esto es de la parte del arreglo
nodoModelo nodoLstCorchetes = getNodo("LST_CORCHETES_VAL");
_LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)nodoLstCorchetes;
List <int> listaEntero = lstCorchetes.getLstInt(elementoEntorno, lstAtributos.listaAtributos[2].tok);
if (itemValorRetornoMetodo.dimensiones.Count == listaEntero.Count)
//tienen la misma dimension
{
println("getValCorchetes");
return(getValCorchetes(lstAtributos.getToken(2), elementoEntorno, listaEntero, itemValorRetornoMetodo));
}
else
//no tienen la misma dimensión.
{
tablaSimbolos.tablaErrores.insertErrorSemantic("El metodo: " + lstAtributos.getToken(2).val + " no devuelve la misma cantidad de dimensiones que a las que se quiere acceder", lstAtributos.getToken(2));
return(retorno);
}
}
else
{
println("tEste + sPunto + valId + sAbreParent + sCierraParent + LST_CORCHETES_VAL");
}
#endregion
}
else if (hijos[0].nombre.Equals("LST_VAL"))
/*
|----------------------------
| tEste + sPunto + valId + sAbreParent + LST_VAL + sCierraParent
*/
{
#region cuerpo
print("tEste + sPunto + valId + sAbreParent + LST_VAL + sCierraParent");
String esteId = lstAtributos.listaAtributos[2].nombretoken;
if (esteId.Equals("valId"))
{
nodoModelo nodoTemp = getNodo("LST_VAL");
_LST_VAL lstParametros = (_LST_VAL)nodoTemp;
return(elementoEntorno.este.ejecutarMetodoFuncion(lstAtributos.getToken(2), lstParametros.getLstValores(elementoEntorno), elementoEntorno.este.tablaEntorno.raiz));
}
else
{
println("valId + sAbreParent + LST_VAL + sCierraParent; -> no viene valId");
}
}
#endregion
}
else if (hijos.Count == 0)
/*
|----------------------------
| tEste + sPunto + valId + sAbreParent + sCierraParent
*/
{
#region cuerpo
print("tEste + sPunto + valId + sAbreParent + sCierraParent");
String esteId = lstAtributos.listaAtributos[2].nombretoken;
if (esteId.Equals("valId"))
{
nodoModelo nodoTemp = getNodo("LST_VAL");
lstValores sinParametros = new lstValores();
return(elementoEntorno.este.ejecutarMetodoFuncion(lstAtributos.getToken(2), sinParametros, elementoEntorno.este.tablaEntorno.raiz));
}
else
{
println("valId + sAbreParent + LST_VAL + sCierraParent; -> no viene valId");
}
#endregion
}
}
}
return(retorno);
}