public Boolean compararParametros(lstValores lsParametros)
{
Boolean retorno = false;
if (lstParametros.Count == lsParametros.listaValores.Count)
{
retorno = true;
for (int i = 0; i < lstParametros.Count; i++)
{
llaveParametro lst1 = getListaLlaves()[i];
itemValor lst2 = lsParametros.getItemValor(i);
//El priemro es para comprobar los tipos
//el segundo es para comparar objetos
if (lst1.tipo.Equals(lst2.getTipo()) || lst1.tipo.Equals(lst2.nombreObjeto))
{
if (lst1.dimension != lst2.dimensiones.Count)
{
return(false);
}
}
else
{
return(false);
}
}
return(retorno);
}
else
{
return(false);
}
}
/*
|-------------------------------------------------------------------------------------------------------------------
| 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 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);
}
}
/*
|----------------------------------------------
| Ejecutando el constructor
|----------------------------------------------
*/
public void ejecutarConstructor(token nombre, int dimension, lstValores parametros, elementoEntorno tablaEntorno)
{
/*
* Console.WriteLine("-------------");
* foreach (itemValor tmp in parametros.listaValores)
* {
* Console.WriteLine("[ObjetoClase]->");
*
* tmp.imprimirVariable();
* }
*/
cuerpoClase.lstConstructores.ejecutarMetodo(nombre, parametros, tablaEntorno);
}
/*
|----------------------------------------------
| Ejecutando Forulario.
|----------------------------------------------
*/
public itemValor ejecutarFormulario(token nombre, lstValores parametros, elementoEntorno entorno)
{
/*foreach (itemValor tmp in parametros.listaValores)
* {
*
*
*
* Console.WriteLine("[ObjetoClase]->");
* Console.WriteLine("tipo->"+tmp.getTipo());
* Console.WriteLine("nombreObjeto->" + tmp.nombreObjeto);
* tmp.imprimirVariable();
* }*/
return(cuerpoClase.lstFormularios.getMetodoFuncion(nombre, parametros, entorno, "formulario"));
}
public lstValores getLstValores(elementoEntorno elemento)
{
lstValores retorno = new lstValores();
foreach (nodoModelo hijo in hijos)
{
_VALOR temp = (_VALOR)hijo;
itemValor temporal1 = temp.getValor(elemento, new token());
retorno.insertar(temporal1);
}
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Comparando los parametros con una lista de valores de entrada
|-------------------------------------------------------------------------------------------------------------------
|
*/
public Boolean compararParametrosLstValores(lstValores lst2Parametros)
{
if (lstParametros.Count == lst2Parametros.listaValores.Count)
{
int i = 0;
foreach (var dic in lstParametros)
{
//tiene que ser del mismo tipo y dimension
itemValor parametro2 = lst2Parametros.getItemValor(i);
Console.WriteLine("------------------------");
Console.WriteLine("dic.key.dimension-> " + dic.Key.dimension);
Console.WriteLine("parametro2.dimensiones->" + parametro2.dimensiones.Count);
/* if (parametro2.isTypeObjeto()&&)
* {
*
* }*/
//if ((dic.Key.dimension == parametro2.dimensiones.Count) && (dic.Value.tipo.valLower.Equals(parametro2.getTipo())))
if ((dic.Key.dimension == parametro2.dimensiones.Count) && itemEntorno.validandoTipo(dic.Value.tipo.valLower, parametro2))
{
}
else
{
return(false);
}
i++;
}
}
else
{
return(false);
}
return(true);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| 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 void getArray(Dictionary <int, itemValor> diccionario, List <int> dimensioenes, token tipo, int dimensionActual, elementoEntorno elemEntor)
{
if (hayErrores())
{
return;
}
if (hijos.Count > 0)
{
nodoModelo temp = hijos[0];
if (temp.nombre.Equals("LST_LLAVES_VAL"))
{
_LST_LLAVES_VAL lstLlaves = (_LST_LLAVES_VAL)temp;
dimensionActual++; //incremento la dimensio
lstLlaves.getArray2(diccionario, dimensioenes, tipo, dimensionActual, elemEntor);
return;
}
else if (temp.nombre.Equals("LST_VAL"))
{
dimensionActual++;
_LST_VAL lstVal = (_LST_VAL)temp;
lstValores lstVals = lstVal.getLstValores(elemEntor);
if (dimensionActual > dimensioenes.Count)
{
dimensioenes.Add(lstVals.listaValores.Count);
}
else
{
if (dimensioenes[dimensionActual - 1] != lstVals.listaValores.Count)
//hay problema con la cantidad de hijos
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No coincide el tamaño de la matriz: " + dimensionActual, tipo);
}
}
foreach (itemValor it in lstVals.listaValores)
{
//validando los tipos
if (it.dimensiones.Count > 0)
{
tablaSimbolos.tablaErrores.insertErrorSemantic("El lenguaje no soporta variables, o nuevos arreglos anidados de una forma diferente de {{E,E},{E,E}}: Error en matriz de tipo:" + tipo.val, tipo);
return;
}
object objeto = it.getValorParseado(tipo.valLower);
if (it.isTypeNulo())
{
itemValor item = new itemValor();
item.setTypeNulo();
int dimensionArray = diccionario.Count;
diccionario.Add(dimensionArray, item);
}
else if (it.isTypeObjeto())
{
if (objeto == null)
//no se pudo parsear
{
println("Es de tipo objeto, pero no coincidieron los nombres");
//retorno un error
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede introducir un tipo : " + it.getTipo() + " a una matriz de tipo : " + tipo.val, tipo);
return;
}
else
//si se pudo parsear
{
itemValor item = new itemValor();
item.setValue(objeto, tipo.valLower);
//hay que insertarlo al diccionario
int dimensionArray = diccionario.Count;
diccionario.Add(dimensionArray, item);
}
//hay que validar si son los mismos tipos de objeto
}
else
{
if (objeto == null)
//no se pudo parsear
{
/*if (tipo.val.Equals("--")) //no indicaron el tipo, asi que se vaya alv
* {
*
* itemValor item = new itemValor();
* item.setType(it.getTipo());
* item.valor = objeto;
*
* //hay que insertarlo al diccionario
* int dimensionArray = diccionario.Count;
* diccionario.Add(dimensionArray, item);
*
* }
* else
* {
*
* //retorno un error
* tablaSimbolos.tablaErrores.insertErrorSemantic("NO se puede introducir un tipo : " + it.getTipo() + " a una matriz de tipo : " + tipo.val, tipo);
* return;
* }*/
//retorno un error
tablaSimbolos.tablaErrores.insertErrorSemantic("NO se puede introducir un tipo : " + it.getTipo() + " a una matriz de tipo : " + tipo.val, tipo);
return;
}
else
//si se pudo parsear
{
itemValor item = new itemValor();
item.setType(tipo.valLower);
item.valor = objeto;
//hay que insertarlo al diccionario
int dimensionArray = diccionario.Count;
diccionario.Add(dimensionArray, item);
}
}
}
int listaFinal = getDimensionMapeada(dimensioenes, tipo);
// println("la lista mapeada es de longitud->" + listaFinal.ToString());
}
}
else
{
//tiene que ser error, ya que no se apceta si trae cer en una dimension
}
return;
}
public itemValor getValor(elementoEntorno elementoEntor, token tipo)
{
itemValor retorno = new itemValor();
retorno.setTypeNulo();
if (hayErrores())
{
return(retorno);
}
if (lstAtributos.listaAtributos.Count == 4)
{
String item1 = lstAtributos.listaAtributos[0].nombretoken;
String item2 = lstAtributos.listaAtributos[1].nombretoken;
if (item1.Equals("nuevo") && item2.Equals("valId"))
/*
|----------------------------
| tNuevo + valId + sAbreParent + LST_VAL + sCierraParent
*/
{
/*
|--------------------------------------------------------------------------
| nuevo Objeto()
| nuevo valId()
|--------------------------------------------------------------------------
| 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
|
*/
//token tokId = lstAtributos.getToken(1);
token tokInstancia = lstAtributos.getToken(1);
elementoClase temp = tablaSimbolos.getClase(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.ejecutarGlobales(); //cargando sus valores globales
// jlk
ObjClase.ejecutarConstructor(lstAtributos.getToken(1), 0, lstValores2, ObjClase.tablaEntorno.raiz);
//println("ejecutando constructor de la claes, new objeto()");
retorno.setValue(ObjClase, lstAtributos.getToken(1).valLower);
retorno.setTypeObjeto(tokInstancia.valLower);
//println("Es un objeto");
return(retorno);
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede instanaciar la clase:" + tokInstancia.valLower + ", para crear el objeto, debido a que no se existe la clase ", tokInstancia);
}
return(retorno);
}
}
if (hijos.Count > 0)
{
nodoModelo hijo = hijos[0];
switch (hijo.nombre)
{
case "PREGUNTA_NATIVA":
_PREGUNTA_NATIVA preg = (_PREGUNTA_NATIVA)hijo;
return(preg.getValor(elementoEntor));
case "TIPO":
if (hayErrores())
{
return(retorno);
}
/*
|--------------------------------------------------------------------------
| ARREGLO
|--------------------------------------------------------------------------
| Hay que mapear las variables para inicializar el array valores de item
| Estoy definiendo las dimensiones del arreglo
| tNuevo + TIPO + LST_CORCHETES_VAL
|
|
| String[][] hola = new String[3][2];
|
| String[] jejej = new String[12];
| int[][] jeje = { new int[12], { 2, 2 } };
|
| int[][][] numeros = {{3,3,3},{2,2,2},{1,1,1}, {4,4,4},{5,5,5},{6,6,6}};
| hola = jejej;*/
nodoModelo tempTipo = getNodo("TIPO");
_TIPO nodoTipo = (_TIPO)tempTipo;
retorno.setType(nodoTipo.getTipo().valLower);
token item1 = lstAtributos.listaAtributos[0].tok;
nodoModelo temp1 = getNodo("LST_CORCHETES_VAL");
if (temp1 != null)
{
_LST_CORCHETES_VAL lstVal = (_LST_CORCHETES_VAL)temp1;
List <int> tempLstInt = lstVal.getLstInt(elementoEntor, item1);
int dimensionMaxima = 1;
foreach (int elemento in tempLstInt)
{
// println("dimen: " + elemento);
if (elemento != 0)
{
dimensionMaxima = dimensionMaxima * elemento;
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede inicializar una matriz con tamaño 0", item1);
}
}
//llenando la lista de nulos
Dictionary <int, itemValor> diccionario = new Dictionary <int, itemValor>();
for (int i = 0; i < dimensionMaxima; i++)
{
diccionario.Add(i, new itemValor());
}
retorno.setArrayTipo(tempLstInt, diccionario, tipo.valLower);
//println("La dimensión mapeada -> indice máximo es " + retorno.arrayValores.Count);
//tengo que mapear
// sf
}
//println(itEntorno.nombre.valLower + "-> tNuevo + TIPO + LST_CORCHETES_VAL");
return(retorno);
case "LST_LLAVES_VAL":
/*
|--------------------------------------------------------------------------
| ARREGLO
|--------------------------------------------------------------------------
| Le estoy enviando directamente los valores al arreglo
| LST_LLAVES_VAL esto retorna=Dictionary<int, itemValor>
|
*/
nodoModelo tempLstLlaves = getNodo("LST_LLAVES_VAL");
_LST_LLAVES_VAL nodoLstLlaves = (_LST_LLAVES_VAL)tempLstLlaves;
nodoLstLlaves.getArray(tipo, elementoEntor);
int arrayLengthMapeado = getDimensionMapeada(nodoLstLlaves.lstDimensiones, tipo);
if (arrayLengthMapeado == nodoLstLlaves.diccionario.Count)
//se puede agregar correctamente
{
itemValor retorno2 = new itemValor();
retorno2.setType(tipo.valLower);
retorno2.arrayValores = nodoLstLlaves.diccionario;
retorno2.dimensiones = nodoLstLlaves.lstDimensiones;
return(retorno2);
}
else
{
println("Hay problema en las dimensiones del arreglo" + tipo.linea);
}
return(retorno);
case "E":
/*
|--------------------------------------------------------------------------
| E
|--------------------------------------------------------------------------
*/
_E ope = (_E)hijo;
return(ope.getValor(elementoEntor));
default:
println(hijo.nombre + "->No se reconoció la producción :(");
return(retorno);
}
}
else
/*
|----------------------------
| tNulo
| tEste
*/
{
String item1 = lstAtributos.listaAtributos[0].nombretoken;
if (item1.Equals("tEste"))
{
itemValor it = new itemValor();
it.setTypeObjeto(elementoEntor.este.cuerpoClase.nombreClase.valLower);
it.setValue(elementoEntor.este, elementoEntor.este.cuerpoClase.nombreClase.valLower);
return(it);
}
else
{
/*
|--------------------------------------------------------------------------
| return nulo
|--------------------------------------------------------------------------
| tNulo
*/
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);
}
/*
|----------------------------------------------
| Ejecutando Constructor Heredado
|----------------------------------------------
*/
public void ejecutarConstructorHeredado(lstValores parametros, elementoEntorno tablaEntorno, token linea)
{
cuerpoClase.lstConstructoresHeredados.ejecutarConstructorHeredad(parametros, tablaEntorno, linea);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| 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);
}
