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 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 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);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones
|-------------------------------------------------------------------------------------------------------------------
|
*/
/* public void asignarValor(itemValor destino, itemValor valor, token tokIgual)
* {
*
* if (destino.dimensiones.Count > 0)
* {
* if (destino.dimensiones.Count == valor.dimensiones.Count)
* {
* if (validandoTipo(destino.getTipo(), valor.getTipo()))
* {
*
* //aquí se hace la asignación
* destino = valor;
* }
* {
* tablaSimbolos.tablaErrores.insertErrorSemantic("Se está intentando guardar en una variable de tipo " + destino.getTipo() + ", un valor de tipo " + valor.getTipo(), tokIgual);
*
* }
* }
* else
* {
* tablaSimbolos.tablaErrores.insertErrorSemantic("Se esta recibiendo una dimensión :" + valor.dimensiones.Count + " para asignarlo a la matriz : de dimension:" + destino.dimensiones.Count, tokIgual);
* }
* }
* else
* {
* if (valor.dimensiones.Count != 0)
* {
* tablaSimbolos.tablaErrores.insertErrorSemantic("Se está intentando guardar en la variable de tipo " + destino.getTipo() + ", una matriz de dimension : " + valor.dimensiones.Count, tokIgual);
* }
* else if (validandoTipo(destino.getTipo(), valor.getTipo()))
* {
*
* //aquí se hace la asignación
* destino = valor;
* }
* else
* {
* tablaSimbolos.tablaErrores.insertErrorSemantic("Se está intentando guardar en una variable de tipo " + destino.getTipo() + ", un valor de tipo " + valor.getTipo(), tokIgual);
* }
* }
*
* }*/
public void asignarValor(itemEntorno destino, itemValor valor)
{
//validando si lo que estoy esperando es un arreglo
if (destino.dimension.Count > 0)
{
if (destino.dimension.Count == valor.dimensiones.Count)
{
if (validandoTipo(destino.tipo.valLower, valor.getTipo()))
{
//aquí le asigno el valor
destino.valor = valor;
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("Se está intentando guardar en :" + destino.nombre.val + " de tipo " + destino.tipo.valLower + ", un valor de tipo " + valor.getTipo(), destino.nombre);
}
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("Se esta recibiendo :" + valor.dimensiones.Count + " en la matriz : " + destino.nombre.val + " de dimension:" + destino.dimension.Count, destino.nombre);
}
}
else
{
if (valor.dimensiones.Count != 0)
{
tablaSimbolos.tablaErrores.insertErrorSemantic("Se está intentando guardar en la variable :" + destino.nombre.val + " de tipo " + destino.tipo.valLower + ", una matriz de dimension : " + valor.dimensiones.Count, destino.nombre);
}
else if (validandoTipo(destino.tipo.valLower, valor.getTipo()))
{
//aquí le asigno el valor
destino.valor = valor;
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("Se está intentando guardar en :" + destino.nombre.val + " de tipo " + destino.tipo.valLower + ", un valor de tipo " + valor.getTipo(), destino.nombre);
//error semantico, se está intentando asiganar un valor diferente al declarado por la variable
}
}
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones
|-------------------------------------------------------------------------------------------------------------------
|
*/
public itemValor getValId(token idVal, elementoEntorno elem)
// aquí hay que buscar dentro de la tabla de simbolos y devoler el valor, e ir buscando
// hacia atraás para encontral el id
{
itemValor retorno = new itemValor();
retorno.setTypeNulo();
itemEntorno et = elem.getItemValor(idVal.valLower);
if (et != null)
{
return(et.valor);
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("La variable : " + idVal.val + "no se encuentra en el ambito correcto para su acceso, no se ha declarado o no tiene permisos para acceder a ella", idVal);
}
return(retorno);
}
public void asignarValorMatriz(itemEntorno destino, itemValor valor)
{
//validando si lo que estoy esperando es un arreglo
if (destino.dimension.Count > 0)
{
if (destino.dimension.Count == destino.lstDimensionesAcceso.Count)
{
if (validandoTipo(destino.tipo.valLower, valor.getTipo()))
{
int indiceFinal = indiceMapeado(destino.dimension, destino.lstDimensionesAcceso, destino.nombre);
if (indiceFinal > -1)
{
if (indiceFinal < destino.valor.arrayValores.Count)
{
destino.valor.arrayValores[indiceFinal] = valor;
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede acceder a la posición de la matriz: " + destino.nombre.val, destino.nombre);
}
}
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("Se está intentando guardar en :" + destino.nombre.val + " de tipo " + destino.tipo.valLower + ", un valor de tipo " + valor.getTipo(), destino.nombre);
}
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("Se esta recibiendo :" + valor.dimensiones.Count + " en la matriz : " + destino.nombre.val + " de dimension:" + destino.dimension.Count, destino.nombre);
}
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("Se está intentando acceder a una matriz en una variable :" + destino.nombre.val + "que no lo es.", destino.nombre);
}
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemRetorno ejecutar(elementoEntorno tablaEntornos)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0= normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
itemRetorno retorno = new itemRetorno(0);
if (hayErrores())
{
return(retorno);
}
if (hijos.Count == 2)
/*
|----------------------------
| ID_VAR_FUNC + VAL
*/
{
//PUNTERO DONDE VOY A GUARDAR EL VALOR
_ID_VAR_FUNC nodoFunc = (_ID_VAR_FUNC)getNodo("ID_VAR_FUNC");
itemEntorno destino = nodoFunc.getDestino(tablaEntornos);
//AHORA OBTENGO EL VALOR
_VAL nodoVal = (_VAL)getNodo("VAL");
if (nodoVal != null)
{
if (destino != null)
{
itemValor valor = nodoVal.getValor(tablaEntornos, destino.tipo);
if (destino.lstDimensionesAcceso.Count > 0)
//viene la posición de un arreglo
{
asignarValorMatriz(destino, valor);
}
else
{
asignarValor(destino, valor);
}
}
else
{
println("Me retorno un itemEntorno vacio, no podré asignar la variable prro");
}
}
else
{
println("no tiene nodo VAl");
}
}
else if (hijos.Count == 1)
{
if (lstAtributos.getToken(0).valLower.Equals("+"))
/*
|----------------------------
| ID_VAR_FUNC + sMas + sMas
*/
{
if (hayErrores())
{
return(retorno);
}
_ID_VAR_FUNC nodoFunc = (_ID_VAR_FUNC)getNodo("ID_VAR_FUNC");
itemEntorno destino = nodoFunc.getDestino(tablaEntornos);
if (destino.lstDimensionesAcceso.Count > 0)
//viene la posición de un arreglo
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede incrementar la matriz " + destino.nombre.val + " de tipo: " + destino.tipo.valLower, destino.nombre);
}
else
{
itemValor valor = nodoFunc.getValor(tablaEntornos);
itemValor valor2 = new itemValor();
valor2.setValue(1);
suma sumatoria = new suma(new _E("hijo1", tablaSimbolos), new _E("hijo2", tablaSimbolos), tablaSimbolos, lstAtributos.getToken(0));
itemValor resultado = sumatoria.opSumaExterna(tablaEntornos, valor, valor2);
Object ObjParseado = resultado.getValorParseado(destino.tipo.valLower);
if (ObjParseado != null)
{
destino.valor.valor = ObjParseado;
return(retorno);
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede asignar un tipo :" + sumatoria.GetType() + " a la variable " + destino.nombre.val + " de tipo: " + destino.tipo.valLower, destino.nombre);
return(retorno);
}
}
}
else
/*
|----------------------------
| ID_VAR_FUNC + smenos + smenos
*/
{
if (hayErrores())
{
return(retorno);
}
_ID_VAR_FUNC nodoFunc = (_ID_VAR_FUNC)getNodo("ID_VAR_FUNC");
itemEntorno destino = nodoFunc.getDestino(tablaEntornos);
if (destino.lstDimensionesAcceso.Count > 0)
//viene la posición de un arreglo
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede incrementar la matriz " + destino.nombre.val + " de tipo: " + destino.tipo.valLower, destino.nombre);
}
else
{
itemValor valor = nodoFunc.getValor(tablaEntornos);
itemValor valor2 = new itemValor();
valor2.setValue(1);
resta sumatoria = new resta(new _E("hijo1", tablaSimbolos), new _E("hijo2", tablaSimbolos), tablaSimbolos, lstAtributos.getToken(0));
itemValor resultado = sumatoria.opRestaExterna(tablaEntornos, valor, valor2);
Object ObjParseado = resultado.getValorParseado(destino.tipo.valLower);
if (ObjParseado != null)
{
destino.valor.valor = ObjParseado;
return(retorno);
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede asignar un tipo :" + sumatoria.GetType() + " a la variable " + destino.nombre.val + " de tipo: " + destino.tipo.valLower, destino.nombre);
return(retorno);
}
}
}
}
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public itemEntorno getDestino(elementoEntorno elementoEntorno)
{
itemEntorno retorno = null;
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);
itemEntorno te2 = puntos.getDestino(elementoEntorno, te1);
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
String item1 = lstAtributos.listaAtributos[0].nombretoken;
token nombreVar = lstAtributos.getToken(0);
if (item1.Equals("valId"))
{
_LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)getNodo("LST_CORCHETES_VAL");
return(getEntornoId(lstAtributos.listaAtributos[0].tok, elementoEntorno, lstCorchetes.getLstInt(elementoEntorno, nombreVar)));
}
#endregion
}
else
/*
|----------------------------
| valId
*/
{
String item1 = lstAtributos.listaAtributos[0].nombretoken;
if (item1.Equals("valId"))
{
return(getEntornoId(lstAtributos.listaAtributos[0].tok, elementoEntorno, new List <int>()));
}
}
}
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
String valId = lstAtributos.listaAtributos[2].nombretoken;
token nombreVar = lstAtributos.getToken(2);
if (valId.Equals("valId"))
{
_LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)getNodo("LST_CORCHETES_VAL");
return(getEntornoId(lstAtributos.listaAtributos[2].tok, elementoEntorno.este.tablaEntorno.raiz, lstCorchetes.getLstInt(elementoEntorno, nombreVar)));
}
#endregion
}
else
/*
|----------------------------
| tEste + sPunto + valId
*/
{
String valId = lstAtributos.listaAtributos[2].nombretoken;
if (valId.Equals("valId"))
{
return(getEntornoId(lstAtributos.listaAtributos[2].tok, elementoEntorno.este.tablaEntorno.raiz, new List <int>()));
}
}
}
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
*/
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se le puede asignar un valor a la expresión metodo" + lstAtributos.getToken(0).val + "()[] ", lstAtributos.getToken(0));
}
if (hijos.Count == 1)
{
String nombreHijo = hijos[0].nombre;
if (nombreHijo.Equals("LST_VAL"))
/*
|----------------------------
| valId + sAbreParent + LST_VAL + sCierraParent;
|-------------
| Esto es un metodo
*/
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se le puede asignar un valor a la expresión metodo" + lstAtributos.getToken(0).val + "()", lstAtributos.getToken(0));
}
}
}
}
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;
*/
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se le puede asignar un valor a la expresión metodo este." + lstAtributos.getToken(0).val + "()[] ", lstAtributos.getToken(0));
}
else if (hijos.Count == 1)
{
if (hijos[0].nombre.Equals("LST_VAL"))
/*
|----------------------------
| tEste + sPunto + valId + sAbreParent + LST_VAL + sCierraParent
*/
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se le puede asignar un valor a la expresión metodo este." + lstAtributos.getToken(0).val + "() ", lstAtributos.getToken(0));
}
}
}
}
return(retorno);
}
public itemValor getValIdCorchetes(token idVal, elementoEntorno elem, List <int> lstIndex)
/*
|----------------------------
| getValIdCorchetes
*/
{
itemValor retorno = new itemValor();
retorno.setTypeNulo();
itemEntorno et = elem.getItemValor(idVal.valLower);
if (et != null)
{
if (et.dimension.Count == lstIndex.Count)
{
int indiceFinal = 1;
//validando si no se salió de los indices
for (int i = 0; i < et.dimension.Count; i++)
{
if (lstIndex[i] < et.dimension[i])
{
if (i == 0)
//inicilizo la lista
{
indiceFinal = lstIndex[i];
}
else
{
indiceFinal = indiceFinal * et.dimension[i] + lstIndex[i];
}
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("El índice está fuera de rango de la matriz: " + idVal.val + " , rango máximo permitido para la dimensión:" + i + " es " + (et.dimension[i] - 1), idVal);
return(retorno);
}
}
//validando que no salga del arreglo de adentro
if (indiceFinal < et.valor.arrayValores.Count)
{
return(et.valor.arrayValores[indiceFinal]);
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede acceder a la posición de la matriz: " + idVal.val, idVal);
return(retorno);
}
//println("El indice al que quiero acceder es al indice :" + indiceFinal + " de la matriz :" + idVal.val);
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No coinciden las dimensiones en la matriz: " + idVal.val + " para acceder a ella", idVal);
return(retorno);
}
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("La variable : " + idVal.val + "no se encuentra en el ambito correcto para su acceso, no se ha declarado o no tiene permisos para acceder a ella", idVal);
}
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| 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);
}
public itemEntorno getDestino(elementoEntorno elementoEntorno, itemValor item)
{
itemEntorno retorno = null;
if (hayErrores())
{
return(retorno);
}
if (item.isTypeObjeto())
{
if (lstAtributos.listaAtributos.Count == 2)
{
if (hijos.Count > 0)
/*
|----------------------------
| sPunto + valId + LST_CORCHETES_VAL
*/
{
objetoClase tempObjeto = item.getObjeto();
String item1 = lstAtributos.listaAtributos[1].nombretoken;
token nombreVar = lstAtributos.getToken(1);
if (item1.Equals("valId"))
{
_LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)getNodo("LST_CORCHETES_VAL");
return(getEntornoId(lstAtributos.listaAtributos[1].tok, tempObjeto.tablaEntorno.raiz, lstCorchetes.getLstInt(elementoEntorno, nombreVar)));
}
}
else
/*
|----------------------------
| sPunto + valId
*/
{
objetoClase tempObjeto = item.getObjeto();
String item1 = lstAtributos.listaAtributos[1].nombretoken;
token nombreVar = lstAtributos.getToken(1);
if (item1.Equals("valId"))
{
_LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)getNodo("LST_CORCHETES_VAL");
return(getEntornoId(lstAtributos.listaAtributos[1].tok, tempObjeto.tablaEntorno.raiz, new List <int>()));
}
}
}
else if (lstAtributos.listaAtributos.Count == 4)
{
if (hijos.Count == 2)
/*
|----------------------------
| sPunto + valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL
*/
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se le puede asignar un valor a la expresión metodo" + lstAtributos.getToken(1).val + "()[]", lstAtributos.getToken(1));
}
else if (hijos.Count == 1)
{
if (hijos[0].nombre.Equals("LST_VAL"))
/*
|----------------------------
| sPunto + valId + sAbreParent + LST_VAL + sCierraParent
*/
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se le puede asignar un valor a la expresión metodo" + lstAtributos.getToken(1).val + "()", lstAtributos.getToken(1));
}
}
}
}
else
{
tablaSimbolos.tablaErrores.insertErrorSyntax("[objeto.objeto]El atributo/arreglo/metodo al que se quiere acceder no es de tipo objeto", new token());
}
return(null);
}
