public objetoClase este; //sirve para guardar el puntero de la misma clase
public elementoEntorno(elementoEntorno anterior, tablaSimbolos tabla, String nombre, objetoClase este)
{
this.este = este;
this.nombre = nombre;
this.tabla = tabla;
this.anterior = anterior;
lstEntorno = new Dictionary <string, itemEntorno>();
}
public void ejecutandoClase(elementoClase clase)
{
///hay que crear una instancia al objeto
println("Ejecutando el main de " + clase.nombreClase.valLower);
objetoClase ObjClase = new objetoClase(clase, this);
ObjClase.ejecutarGlobales();
ObjClase.ejecutarPrincipal();
//ObjClase.imprimirTablaEntornos();
}
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
|-------------------------------------------------------------------------------------------------------------------
| 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);
}
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);
}
public tablaEntornos(tablaSimbolos tabla, objetoClase este)
{
raiz = new elementoEntorno(null, tabla, "global", este);
}