/*
|-------------------------------------------------------------------------------------------------------------------
| 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 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;
}
/*
|-------------------------------------------------------------------------------------------------------------------
| 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);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones ope Tipo
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemValor ope_tipo(elementoEntorno elem)
{
itemValor retorno = new itemValor();
retorno.setTypeNulo();
if (hayErrores())
{
return(retorno);
}
if (hijos.Count != 1)
{
return(retorno);
}
_LST_VAL nodoVals = (_LST_VAL)getNodo("LST_VAL");
if (nodoVals == null)
{
return(retorno);
}
lstValores listaValroes = nodoVals.getLstValores(elem);
Random rnd = new Random();
if (listaValroes.listaValores.Count > 0)
{
int month = rnd.Next(0, listaValroes.listaValores.Count);
itemValor item = listaValroes.getItemValor(month);
if (item.isTypeNulo())
{
retorno.setValue(0);
return(retorno);
}
else
{
return(item);
}
}
else
{
int dice = rnd.Next(0, 2);
retorno.setValue(dice);
return(retorno);
}
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones ope Tipo
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemValor ope_tipo(elementoEntorno elem)
{
itemValor retorno = new itemValor();
retorno.setTypeNulo();
if (hayErrores())
{
return(retorno);
}
if (hijos.Count != 1)
{
return(retorno);
}
_LST_VAL nodoVals = (_LST_VAL)getNodo("LST_VAL");
if (nodoVals == null)
{
return(retorno);
}
_TAM taman = new _TAM("TAM", tablaSimbolos);
lstValores listaValroes = nodoVals.getLstValores(elem);
if (listaValroes.listaValores.Count > 0)
{
int minimo = 0;
int i = 0;
foreach (itemValor itemVal in listaValroes.listaValores)
{
if (i == 0)
{
itemValor minimoItem = taman.calcularTamanio(itemVal, elem);
if (hayErrores())
{
return(retorno);
}
minimo = (int)minimoItem.getValorParseado("entero");
}
else
{
itemValor minimoItem = taman.calcularTamanio(itemVal, elem);
if (hayErrores())
{
return(retorno);
}
int enteroAnterio = (int)minimoItem.getValorParseado("entero");
if (enteroAnterio < minimo)
{
minimo = enteroAnterio;
}
}
i++;
}
retorno.setValue(minimo);
return(retorno);
}
else
{
retorno.setValue(0);
return(retorno);
}
}
public itemValor crearPregunta(elementoEntorno elementoEntor)
/*
|--------------------------------------------------------------------------
| valId + sAbreParent + LST_VAL + sCierraParent;
| tNuevo + valId + sAbreParent + LST_VAL + sCierraParent
|--------------------------------------------------------------------------
|
| tengo que crear una nueva clase y cargar los valores globales con sus metdos, funciones, y validar constructores
| hay que buscar la clase primero
|
*/
{
itemValor retorno = new itemValor();
retorno.setTypeVacio();
if (hayErrores())
{
return(null);
}
//token tokId = lstAtributos.getToken(1);
token tokInstancia = lstAtributos.getToken(0);
elementoClase temp = tablaSimbolos.getPregunta(tokInstancia);
if (temp != null)
{
objetoClase ObjClase = new objetoClase(temp, tablaSimbolos);
lstValores lstValores2 = new lstValores();
//ahora tengo que llamar al constructor, pero digamos que no tiene, jejejeje
if (hijos.Count > 0)
{
nodoModelo hijo = hijos[0];
_LST_VAL lstval = (_LST_VAL)hijo;
lstValores2 = lstval.getLstValores(elementoEntor);
//me tiene que devolver una lista de valores,
}
ObjClase.ejecutarConstructor(lstAtributos.getToken(0), 0, lstValores2, ObjClase.tablaEntorno.raiz);
ObjClase.ejecutarGlobales(); //cargando sus valores globales
// jlk
// println("========================00 imprimir lo que contiene la pregunta 00 ==================");
// elementoEntor.imprimir();
//println("ejecutando constructor de la claes, new objeto()");
retorno.setValue(ObjClase, lstAtributos.getToken(0).valLower);
retorno.setTypeObjeto(tokInstancia.valLower);
//println("Es un objeto");
return(retorno);
}
else
{
return(null);
}
}
/*
|-------------------------------------------------------------------------------------------------------------------
| 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);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public itemValor getValor(elementoEntorno tablaEntornos)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0 = _entero
| 1 = _cadena;
| 2 = _decimal
| 3 = _rango
| 4 = _fecha
| 5 = _hora
| 6 = _fechaHOra
| 7 = _seleccionar_1
| 8 = _seleccionar
| 9 = _nota
*/
{
itemValor retorno = new itemValor();
retorno.setTypeNulo();
if (hayErrores())
{
return(retorno);
}
itemValorPregunta param = new itemValorPregunta();
param.respuesta = retorno;
String tipo = lstAtributos.getToken(1).valLower;
if (tipo.Equals("_entero"))
{
_LST_VAL temp = (_LST_VAL)getNodo("LST_VAL");
lstValores listaValores = temp.getLstValores(tablaEntornos);
if (listaValores.listaValores.Count != 2)
{
tablaSimbolos.tablaErrores.insertErrorSemantic("Se estan esperando dos parametros, limite inferior, y limite superior", lstAtributos.getToken(0));
return(retorno);
}
itemValor limitInf = listaValores.listaValores[0];
itemValor limitSup = listaValores.listaValores[1];
Object obj = limitInf.getValorParseado("entero");
Object obj2 = limitSup.getValorParseado("entero");
if (obj == null || obj2 == null)
{
frmEntero fdecimal = new frmEntero(param, tablaEntornos, -1, -1);
fdecimal.ShowDialog();
return(retorno);
}
else
{
frmEntero fdecimal = new frmEntero(param, tablaEntornos, (int)obj, (int)obj2);
fdecimal.ShowDialog();
return(retorno);
}
}
else if (tipo.Equals("_cadena"))
{
frmCadena fCadena = new frmCadena(param, tablaEntornos);
fCadena.ShowDialog();
return(retorno);
}
else if (tipo.Equals("_decimal"))
{
_LST_VAL temp = (_LST_VAL)getNodo("LST_VAL");
lstValores listaValores = temp.getLstValores(tablaEntornos);
if (listaValores.listaValores.Count != 2)
{
tablaSimbolos.tablaErrores.insertErrorSemantic("Se estan esperando dos parametros, limite inferior, y limite superior", lstAtributos.getToken(0));
return(retorno);
}
itemValor limitInf = listaValores.listaValores[0];
itemValor limitSup = listaValores.listaValores[1];
Object obj = limitInf.getValorParseado("entero");
Object obj2 = limitSup.getValorParseado("entero");
if (obj == null || obj2 == null)
{
frmDecimal fdecimal = new frmDecimal(param, tablaEntornos, -1, -1);
fdecimal.ShowDialog();
return(retorno);
}
else
{
frmDecimal fdecimal = new frmDecimal(param, tablaEntornos, (int)obj, (int)obj2);
fdecimal.ShowDialog();
return(retorno);
}
}
else if (tipo.Equals("_booleano"))
{
_LST_VAL temp = (_LST_VAL)getNodo("LST_VAL");
lstValores listaValores = temp.getLstValores(tablaEntornos);
if (listaValores.listaValores.Count != 2)
{
tablaSimbolos.tablaErrores.insertErrorSemantic("Se estan esperando dos parametros, uno verdadero, y otro falso", lstAtributos.getToken(0));
return(retorno);
}
itemValor valVerdadero = listaValores.listaValores[0];
itemValor valFalso = listaValores.listaValores[1];
if (!(valVerdadero.isTypeCadena() && valFalso.isTypeCadena()))
{
valVerdadero.setValue("Si");
valFalso.setValue("No");
}
frmBooleano fCadena = new frmBooleano(param, tablaEntornos, valVerdadero.getCadena(), valFalso.getCadena());
fCadena.ShowDialog();
return(retorno);
//aquí espero dos parametros de tipo cadena
}
else if (tipo.Equals("_nota"))
{
frmNota fCadena = new frmNota(param, tablaEntornos);
fCadena.ShowDialog();
retorno.setValue("cadena");
return(retorno);
}
else if (tipo.Equals("_fecha"))
{
frmFecha fFecha = new frmFecha(param, tablaEntornos);
fFecha.ShowDialog();
return(retorno);
}
else if (tipo.Equals("_hora"))
{
frmHora fFecha = new frmHora(param, tablaEntornos);
fFecha.ShowDialog();
return(retorno);
}
else if (tipo.Equals("_fechahora"))
{
frmFechaHora fFecha = new frmFechaHora(param, tablaEntornos);
fFecha.ShowDialog();
return(retorno);
}
else if (tipo.Equals("_seleccionaruno"))
{
_LST_VAL temp = (_LST_VAL)getNodo("LST_VAL");
lstValores listaValores = temp.getLstValores(tablaEntornos);
if (listaValores.listaValores.Count != 1)
{
tablaSimbolos.tablaErrores.insertErrorSemantic("Se estan esperando una lista como parametro,pero se recibieron más o menos", lstAtributos.getToken(0));
return(retorno);
}
itemValor itemArreglo = listaValores.listaValores[0];
if (itemArreglo.dimensiones.Count != 1)
{
tablaSimbolos.tablaErrores.insertErrorSemantic("Se estan esperando un arreglo de una dimensión como parametro,pero se recibieron de dimensión diferente de uno.", lstAtributos.getToken(0));
return(retorno);
}
List <String> lstStringEnviar = new List <string>();
for (int i = 0; i < itemArreglo.dimensiones[0]; i++)
{
Object ol = itemArreglo.arrayValores[i].getValorParseado("cadena");
if (ol != null)
{
lstStringEnviar.Add((String)ol);
}
}
frmSeleccionarUno fCadena = new frmSeleccionarUno(param, tablaEntornos, lstStringEnviar);
fCadena.ShowDialog();
return(retorno);
}
else if (tipo.Equals("_seleccionarvarios"))
{
_LST_VAL temp = (_LST_VAL)getNodo("LST_VAL");
lstValores listaValores = temp.getLstValores(tablaEntornos);
if (listaValores.listaValores.Count != 1)
{
tablaSimbolos.tablaErrores.insertErrorSemantic("Se estan esperando una lista como parametro,pero se recibieron más o menos", lstAtributos.getToken(0));
return(retorno);
}
itemValor itemArreglo = listaValores.listaValores[0];
if (itemArreglo.dimensiones.Count != 1)
{
tablaSimbolos.tablaErrores.insertErrorSemantic("Se estan esperando un arreglo de una dimensión como parametro,pero se recibieron de dimensión diferente de uno.", lstAtributos.getToken(0));
return(retorno);
}
List <String> lstStringEnviar = new List <string>();
for (int i = 0; i < itemArreglo.dimensiones[0]; i++)
{
Object ol = itemArreglo.arrayValores[i].getValorParseado("cadena");
if (ol != null)
{
lstStringEnviar.Add((String)ol);
}
}
frmSeleccionarVarios fCadena = new frmSeleccionarVarios(param, tablaEntornos, lstStringEnviar);
fCadena.ShowDialog();
return(retorno);
}
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
| elementoEntorno,es el ambito actual
| itemValor es el objeto donde voy a seguir buscandos
| solo puedo recibir item de tipo objeto
*/
public itemValor getValor(elementoEntorno elementoEntorno, itemValor item)
{
itemValor retorno = new itemValor();
retorno.setTypeVacio();
if (hayErrores())
{
return(retorno);
}
if (item.isTypeObjeto())
{
if (lstAtributos.listaAtributos.Count == 2)
{
if (hijos.Count > 0)
/*
|----------------------------
| sPunto + valId + LST_CORCHETES_VAL
*/
{
token nombreVar = lstAtributos.getToken(1);
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[1].nombretoken;
//mapeando el indice
if (item1.Equals("valId"))
{
objetoClase tempObjeto = item.getObjeto();
if (tempObjeto != null)
{
return(getValIdCorchetes(lstAtributos.listaAtributos[1].tok, tempObjeto.tablaEntorno.raiz, listaEntero));
//return getValId(lstAtributos.listaAtributos[1].tok, tempObjeto.tablaEntorno.raiz);
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se pudo parsear el objeto", lstAtributos.listaAtributos[1].tok);
return(retorno);
}
}
else
{
println("sPunto + valId + LST_CORCHETES_VAL -> No viene val id");
}
}
}
else
/*
|----------------------------
| sPunto + valId
*/
{
String item1 = lstAtributos.listaAtributos[1].nombretoken;
if (item1.Equals("valId"))
{
objetoClase tempObjeto = item.getObjeto();
if (tempObjeto != null)
{
return(getValId(lstAtributos.listaAtributos[1].tok, tempObjeto.tablaEntorno.raiz));
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se pudo parsear el objeto", lstAtributos.listaAtributos[1].tok);
return(retorno);
}
}
}
}
else if (lstAtributos.listaAtributos.Count == 4)
{
if (hijos.Count == 2)
/*
|----------------------------
| sPunto + valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL
*/
{
if (hayErrores())
{
return(retorno);
}
String esteId = lstAtributos.listaAtributos[1].nombretoken;
if (esteId.Equals("valId"))
{
objetoClase tempObjeto = item.getObjeto();
//esto es del metodo
nodoModelo nodoTemp = getNodo("LST_VAL");
_LST_VAL lstParametros = (_LST_VAL)nodoTemp;
itemValor itemValorRetornoMetodo = tempObjeto.ejecutarMetodoFuncion(lstAtributos.getToken(1), lstParametros.getLstValores(elementoEntorno), tempObjeto.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[1].tok);
if (itemValorRetornoMetodo.dimensiones.Count == listaEntero.Count)
//tienen la misma dimension
{
return(getValCorchetes(lstAtributos.getToken(1), elementoEntorno, listaEntero, itemValorRetornoMetodo));
}
else
//no tienen la misma dimensión.
{
tablaSimbolos.tablaErrores.insertErrorSemantic("El metodo: " + lstAtributos.getToken(1).val + " no devuelve la misma cantidad de dimensiones que a las que se quiere acceder", lstAtributos.getToken(1));
return(retorno);
}
}
else
{
println(" sPunto + valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL -> no viene valId");
return(retorno);
}
}
else if (hijos.Count == 1)
{
if (hijos[0].nombre.Equals("LST_CORCHETES_VAL"))
/*
|----------------------------
| sPunto + valId + sAbreParent + sCierraParent + LST_CORCHETES_VAL
*/
{
if (hayErrores())
{
return(retorno);
}
String esteId = lstAtributos.listaAtributos[1].nombretoken;
if (esteId.Equals("valId"))
{
objetoClase tempObjeto = item.getObjeto();
//esto es del metodo
nodoModelo nodoTemp = getNodo("LST_VAL");
lstValores sinParametros = new lstValores();
//elementoEntorno.este.tablaEntorno.raiz
itemValor itemValorRetornoMetodo = tempObjeto.ejecutarMetodoFuncion(lstAtributos.getToken(1), sinParametros, tempObjeto.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[1].tok);
if (itemValorRetornoMetodo.dimensiones.Count == listaEntero.Count)
//tienen la misma dimension
{
return(getValCorchetes(lstAtributos.getToken(1), elementoEntorno, listaEntero, itemValorRetornoMetodo));
}
else
//no tienen la misma dimensión.
{
tablaSimbolos.tablaErrores.insertErrorSemantic("El metodo: " + lstAtributos.getToken(1).val + " no devuelve la misma cantidad de dimensiones que a las que se quiere acceder", lstAtributos.getToken(1));
return(retorno);
}
}
else
{
println(" sPunto + valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL -> no viene valId");
return(retorno);
}
}
else if (hijos[0].nombre.Equals("LST_VAL"))
/*
|----------------------------
| sPunto + valId + sAbreParent + LST_VAL + sCierraParent
*/
{
#region cuerpo
String esteId = lstAtributos.listaAtributos[1].nombretoken;
objetoClase tempObjeto = item.getObjeto();
if (esteId.Equals("valId"))
{
nodoModelo nodoTemp = getNodo("LST_VAL");
_LST_VAL lstParametros = (_LST_VAL)nodoTemp;
itemValor reto = tempObjeto.ejecutarMetodoFuncion(lstAtributos.getToken(1), lstParametros.getLstValores(elementoEntorno), tempObjeto.tablaEntorno.raiz);
reto.nombrePregunta = item.nombrePregunta;
return(reto);
}
else
{
println("sPunto + valId + sAbreParent + LST_VAL + sCierraParent ");
}
#endregion
}
}
else if (hijos.Count == 0)
/*
|----------------------------
| sPunto + valId + sAbreParent + sCierraParent
*/
{
#region cuerpo
String esteId = lstAtributos.listaAtributos[1].nombretoken;
objetoClase tempObjeto = item.getObjeto();
println("el nombre del objeto es " + tempObjeto.cuerpoClase.nombreClase.val);
if (esteId.Equals("valId"))
{
nodoModelo nodoTemp = getNodo("LST_VAL");
lstValores sinParametros = new lstValores();
return(tempObjeto.ejecutarMetodoFuncion(lstAtributos.getToken(1), sinParametros, tempObjeto.tablaEntorno.raiz));
}
else
{
println("sPunto + valId + sAbreParent + sCierraParent ");
}
#endregion
}
}
}
else
{
tablaSimbolos.tablaErrores.insertErrorSyntax("[objeto.objeto]El atributo/arreglo/metodo al que se quiere acceder no es de tipo objeto", new token());
}
return(retorno);
}