/*
|-------------------------------------------------------------------------------------------------------------------
| FORMULARiO
|-------------------------------------------------------------------------------------------------------------------
|
*/
public elementoPolimorfo getPolimorfo()
{
elementoPolimorfo retorno = null;
if (hayErrores())
{
return(retorno);
}
nodoModelo tempNodo = getNodo("TIPO");
if (tempNodo != null)
{
_TIPO temp = (_TIPO)tempNodo;
nodoModelo temp2 = getNodo("VAR_ARREGLO");
if (temp2 != null)
{
_VAR_ARREGLO tempVar = (_VAR_ARREGLO)temp2;
token visibilidad = new token("publico");
token tipo = temp.getTipo();
token nombre = tempVar.getIdentificador();
int dimensiones = tempVar.getDimensiones();
retorno = new elementoPolimorfo(visibilidad, tablaSimbolos, tipo, nombre, new _LST_CUERPO("LST_CUERPO", tablaSimbolos), dimensiones);
return(retorno);
}
}
return(retorno);
}
public token getIdentificador()
{
token retorno = new token("--");
nodoModelo temp2 = getNodo("VAR_ARREGLO");
if (temp2 != null)
{
_VAR_ARREGLO tempVar = (_VAR_ARREGLO)temp2;
retorno = tempVar.getIdentificador();
}
return(retorno);
}
public int getDimensiones()
{
int retorno = 0;
nodoModelo temp2 = getNodo("VAR_ARREGLO");
if (temp2 != null)
{
_VAR_ARREGLO tempVar = (_VAR_ARREGLO)temp2;
retorno = tempVar.getDimensiones();
}
return(retorno);
}
public _VAL getNodoVAL()
{
nodoModelo temp = getNodo("VAL");
if (temp != null)
{
return((_VAL)temp);
}
else
{
return(null);
}
}
public nodoModelo getLST_CUERPO()
{
nodoModelo tempNodo = getNodo("LST_CUERPO");
if (tempNodo != null)
{
return(tempNodo);
}
else
{
return(new nodoModelo("---", tablaSimbolos));
}
}
public nodoModelo getVAL()
{
nodoModelo tempNodo = getNodo("VAL");
if (tempNodo != null)
{
return(tempNodo);
}
else
{
return(new nodoModelo("---", tablaSimbolos));
}
}
public int getDimensiones()
{
int retorno = 0;
nodoModelo tempNodo = getNodo("LST_CORCHETES");
if (tempNodo != null)
{
_LST_CORCHETES temp = (_LST_CORCHETES)tempNodo;
return(temp.getDimension());
}
return(retorno);
}
public token getTipo()
{
nodoModelo tempNodo = getNodo("TIPO");
if (tempNodo != null)
{
_TIPO tipo = (_TIPO)tempNodo;
return(tipo.getTipo());
}
else
{
return(new token("vacio"));
}
}
public nodoModelo getNodo(String nombre)
{
nodoModelo retorno = null;
foreach (nodoModelo temp in hijos)
{
if (temp.nombre.Equals(nombre))
{
retorno = temp;
break;
}
}
return(retorno);
}
public token getVisibilidad(elementoClase elem)
{
nodoModelo tempNodo = getNodo("VISIBILIDAD");
if (tempNodo != null)
{
_VISIBILIDAD visi = (_VISIBILIDAD)tempNodo;
return(visi.getVisibilidad());
}
else
{
//Si no tiene visibilidad retorno la visibilidad de la clase, jake mate ateo!
return(elem.visibilidad);
}
}
public override void ejecutar(elementoClase simbolo)
{
if (hayErrores())
{
return;
}
token tipo = new token("vacio");
token nombre = new token("principal");
nodoModelo LST_CUERPO = getLST_CUERPO();
elementoPolimorfo element = new elementoPolimorfo(new token("publico"), tablaSimbolos, tipo, nombre, LST_CUERPO, 0);
simbolo.lstPrincipal.insertarElemento(element);
}
public override void ejecutar(elementoClase simbolo)
{
if (hayErrores())
{
return;
}
token tipo = new token("vacio");
token nombre = getIdentificador(simbolo.nombreClase);
nodoModelo LST_CUERPO = getLST_CUERPO();
elementoPolimorfo element = new elementoPolimorfo(new token("publico"), tablaSimbolos, tipo, nombre, LST_CUERPO, 0);
cargarPolimorfismoHijos(element);
simbolo.lstConstructores.insertarElemento(element);
}
public Boolean hay_DECLARAR_VARIABLE_SINVISIBI(elementoClase simbolo)
{
nodoModelo tempNodo = getNodo("DECLARAR_VARIABLE_SINVISIBI");
if (tempNodo != null)
{
_DECLARAR_VARIABLE_SINVISIBI var = (_DECLARAR_VARIABLE_SINVISIBI)tempNodo;
var.cargarVariableGlobal(simbolo);
return(true);
}
else
{
return(false);
}
}
public override void ejecutar(elementoClase simbolo)
{
if (hayErrores())
{
return;
}
// println("llego al contructor");
token tipo = getTipo();
token nombre = getIdentificador();
nodoModelo LST_CUERPO = getLST_CUERPO();
token visbilidad = getVisibilidad(simbolo);
int dimension = getDimensiones();
elementoPolimorfo element = new elementoPolimorfo(visbilidad, tablaSimbolos, tipo, nombre, LST_CUERPO, dimension);
cargarPolimorfismoHijos(element);
simbolo.lstMetodo_funcion.insertarElemento(element);
}
public token getExtender()
{
token retorno = new token();
nodoModelo tempNodo = getNodo("EXTENDER");
if (tempNodo != null)
{
_EXTENDER temp = (_EXTENDER)tempNodo;
retorno = temp.getExtender();
}
else
{
retorno = new token("");
}
return(retorno);
}
public override void cargarPolimorfismo(elementoPolimorfo elem)
{
if (hayErrores())
{
return;
}
nodoModelo tempNodo = getNodo("TIPO");
if (tempNodo != null)
{
_TIPO temp = (_TIPO)tempNodo;
nodoModelo temp2 = getNodo("VAR_ARREGLO");
if (temp2 != null)
{
_VAR_ARREGLO tempVar = (_VAR_ARREGLO)temp2;
elem.insertarParametro(tempVar.getIdentificador(), temp.getTipo(), tempVar.getDimensiones());
}
}
}
public token getVisibilidad()
{
token retorno = new token();
nodoModelo tempNodo = getNodo("VISIBILIDAD");
if (tempNodo != null)
{
_VISIBILIDAD temp = (_VISIBILIDAD)tempNodo;
retorno = temp.getVisibilidad();
}
else
{
retorno = new token("privado");
}
return(retorno);
}
public itemValor getValor(elementoEntorno elemento, token tipo)
{
itemValor retorno = new itemValor();
retorno.setTypeNulo();
if (hayErrores())
{
return(retorno);
}
if (hijos.Count > 0)
{
nodoModelo hijo = hijos[0];
_VALOR ope = (_VALOR)hijo;
return(ope.getValor(elemento, tipo));
}
return(retorno);
}
public List <int> getDimensiones()
{
List <int> retorno = new List <int>();
nodoModelo temp2 = getNodo("VAR_ARREGLO");
if (temp2 != null)
{
_VAR_ARREGLO tempVar = (_VAR_ARREGLO)temp2;
int el = tempVar.getDimensiones();
for (int i = 0; i < el; i++)
{
//lo lleno de menos uno para indicar que no se ha establecido el limite
retorno.Add(-1);
}
}
return(retorno);
}
public token getTipo()
{
nodoModelo tempNodo = getNodo("TIPO");
if (tempNodo != null)
{
_TIPO tipo = (_TIPO)tempNodo;
token retorno = tipo.getTipo();
if (retorno.valLower.Equals("vacio"))
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede declarar una variable de tipo vacio:" + retorno.val, retorno);
}
return(retorno);
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede declarar una variable de tipo vacio:", new token("vacio"));
return(new token("vacio"));
}
}
public itemValor getValor(elementoEntorno elmen)
{
itemValor ob = new itemValor();
ob.setTypeNulo();
if (hayErrores())
{
return(ob);
}
switch (hijos.Count)
{
case 0:
if (lstAtributos.listaAtributos.Count > 0)
{
return(parseandoDato(lstAtributos.listaAtributos[0]));
}
else
{
tablaSimbolos.tablaErrores.insertErrorSyntax("[E] Se esperaba un valor ", new token());
return(ob);
//hay un error
}
case 1:
if (hijos[0].nombre.Equals("OPE_ARITME"))
{
return(hijos[0].ope_tipo(elmen));
}
else if (hijos[0].nombre.Equals("OPE_TIPO"))
{
return(hijos[0].ope_tipo(elmen));
}
else if (hijos[0].nombre.Equals("SI_SIMPLIFICADO"))
{
_SI_SIMPLIFICADO simplif = (_SI_SIMPLIFICADO)hijos[0];
return(simplif.getValor(elmen));
}
else if (hijos[0].nombre.Equals("LEN"))
{
_LEN len = (_LEN)hijos[0];
return(len.getValor(elmen));
}
//operador unario
else if (lstAtributos.listaAtributos.Count > 0)
{
String signo = lstAtributos.getValItem(0);
switch (signo)
{
//Logico
case "-":
negativo opNeg = new negativo(hijos[0], tablaSimbolos, lstAtributos.getToken(0));
return(opNeg.opNot(" Asignando valor Negativo", elmen));
case "!":
Not opeNot = new Not(hijos[0], tablaSimbolos, lstAtributos.getToken(0));
return(opeNot.opNot("Not", elmen));
case "(":
_E ope = (_E)hijos[0];
itemValor te = ope.getValor(elmen);
return(te);
default:
tablaSimbolos.tablaErrores.insertErrorSyntax("[E]No se reconoció el signo", lstAtributos.getToken(0));
return(ob);
}
}
else
//ID_VAR_FUNC
{
nodoModelo busq = getNodo("ID_VAR_FUNC");
if (busq != null)
{
_ID_VAR_FUNC idFunc = (_ID_VAR_FUNC)busq;
return(idFunc.getValor(elmen));
}
tablaSimbolos.tablaErrores.insertErrorSyntax("[E]Se esperaba un signo para operación unaria", new token());
return(ob);
}
case 2:
//operador binario
if (lstAtributos.listaAtributos.Count > 0)
{
String signo = lstAtributos.getValItem(0);
switch (signo)
{
//Aritmetica
case "+":
suma ope = new suma(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0));
return(ope.opSuma(elmen));
case "-":
resta opeRes = new resta(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0));
return(opeRes.opResta(elmen));
case "*":
multiplicacion opeMul = new multiplicacion(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0));
return(opeMul.opMultiplicacion(elmen));
case "/":
division opeDiv = new division(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0));
return(opeDiv.opDivision(elmen));
case "^":
potencia opePot = new potencia(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0));
return(opePot.opPotencia(elmen));
case "%":
modulo opeModulo = new modulo(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0));
return(opeModulo.opModulo(elmen));
//Relacional
case "==":
IgualQue opeIgualacion = new IgualQue(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0));
return(opeIgualacion.opIgualacion("Igualación", elmen));
case "!=":
DiferenteQue opeDiferenciacion = new DiferenteQue(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0));
return(opeDiferenciacion.opDiferenciacion("Diferenciación", elmen));
case ">":
MayorQue opeMayor = new MayorQue(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0));
return(opeMayor.opMayorQue("Mayor Que", elmen));
case ">=":
MayorIgualQue opeMayorIgual = new MayorIgualQue(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0));
return(opeMayorIgual.opMayorIgualQue("Mayor o Igual Que", elmen));
case "<":
MenorQue opeMenor = new MenorQue(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0));
return(opeMenor.opMenorQue("Menor Que", elmen));
case "<=":
MenorIgualQue opeMenorIgual = new MenorIgualQue(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0));
return(opeMenorIgual.opMenorIgualQue("Menor o Igual Que", elmen));
//logicas
case "&&":
And opeAnd = new And(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0));
return(opeAnd.opAnd("And", elmen));
case "||":
Or opeOr = new Or(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0));
return(opeOr.opOr("Or", elmen));
default:
tablaSimbolos.tablaErrores.insertErrorSyntax("[E]No se reconoció el sigono", lstAtributos.getToken(0));
return(ob);
}
}
else
{
tablaSimbolos.tablaErrores.insertErrorSyntax("[E]Se esperaba un signo para operación binaria", new token());
return(ob);
}
default:
return(ob);
}
}
public void insertar(nodoModelo hijo)
{
hijos.Add(hijo);
}
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 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;
}
