/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemRetorno ejecutar(elementoEntorno elementoEntor)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0 = normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
/*
|----------------------------
| tCaso + sAbreParent + E + sCierraParent + tDe + sAbreLlave + CUERPO_CASE + sCierraLlave;
*/
itemRetorno retorno = new itemRetorno(0);
if (hayErrores())
{
return(retorno);
}
_E nodoE = (_E)getNodo("E");
itemValor valE = nodoE.getValor(elementoEntor);
_CUERPO_CASE nodoCuerpo = (_CUERPO_CASE)hijos[1];
elementoEntorno entornoIf = new elementoEntorno(elementoEntor, tablaSimbolos, "case", elementoEntor.este);
itemRetorno cuerpoCase = nodoCuerpo.ejecutar(entornoIf, valE);
if (cuerpoCase.isRomper())
//este codigo sirve para eliminar el romper en los nodos, más arriba, y solo se quede en el case
{
return(new itemRetorno(0));
}
else
{
return(retorno);
}
}
public frmCadena(itemValorPregunta valor, elementoEntorno parametros)
{
InitializeComponent();
this.valor = valor;
elementoEntorno carg = parametros.getGlobal();
if (carg != null)
{
SetValores(carg.getEtiqueta(), carg.getSugerir(), carg.getRequerido());
}
else
{
println("no se encontro el global");
SetValores("", "", "");
}
//solo tengo que traer los que estan globales, jejejejejejeje
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones ope Tipo
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemValor ope_tipo(elementoEntorno elem)
{
itemValor retorno = new itemValor();
retorno.setTypeNulo();
if (hayErrores())
{
return(retorno);
}
String temP = DateTime.Now.ToString("dd/MM/yyyy");
retorno.convertirCadena(temP);
println(temP);
return(retorno);
}
public frmSeleccionarUno(itemValorPregunta valor, elementoEntorno parametros, List <String> lstString)
{
InitializeComponent();
this.valor = valor;
elementoEntorno carg = parametros.getGlobal();
if (carg != null)
{
SetValores(carg.getEtiqueta(), carg.getSugerir(), carg.getRequerido());
}
else
{
println("no se encontro el global");
SetValores("", "", "");
}
int i = 0;
foreach (String strTemp in lstString)
{
println(strTemp);
RadioButton rad = new RadioButton();
rad.Text = strTemp;
rad.Location = new Point(10, i * 20);
lstButons.Add(rad);
i++;
grupoBox.Controls.Add(rad);
}
//cargando los elementos al panel
//solo tengo que traer los que estan globales, jejejejejejeje
}
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 frmEntero(itemValorPregunta valor, elementoEntorno parametros, int limiteInferior, int limiteSuperior)
{
InitializeComponent();
this.limiteInferior = limiteInferior;
this.limiteSuperior = limiteSuperior;
this.valor = valor;
elementoEntorno carg = parametros.getGlobal();
if (carg != null)
{
SetValores(carg.getEtiqueta(), carg.getSugerir(), carg.getRequerido());
}
else
{
SetValores("", "", "");
}
numericUpDown1.Maximum = decimal.MaxValue;
numericUpDown1.Minimum = decimal.MinValue;
}
/*
|-------------------------------------------------------------------------------------------------------------------
| 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 itemValor getValor(elementoEntorno elementoEntor, token tipo)
{
itemValor retorno = new itemValor();
if (hayErrores())
{
return(retorno);
}
//println(hijos[0].nombre);
nodoModelo temp = getNodo("E");
if (temp != null)
/*
|----------------------------
| PAR_CORCHETES_VAL.Rule = sAbreCorchete + E + sCierraCorchete;
*/
{
_E ret = (_E)temp;
// ret.getValor(elementoEntor).imprimirVariable();
///return ret.getValor(elementoEntor);
itemValor temporal = ret.getValor(elementoEntor);
if (temporal.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", tipo);
return(retorno);
}
else
{
//temporal.imprimirVariable();
return(temporal);
}
}
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones ope Tipo
|-------------------------------------------------------------------------------------------------------------------
|
*/
public itemValor getValor(elementoEntorno elem)
{
itemValor retorno = new itemValor();
retorno.setTypeNulo();
if (hayErrores())
{
return(retorno);
}
if (hijos.Count != 1)
{
return(retorno);
}
_E nodoE2 = (_E)hijos[0];
if (hayErrores())
{
return(retorno);
}
itemValor itVal = nodoE2.getValor(elem);
if (itVal.dimensiones.Count <= 0)
{
retorno.setValue(0);
}
else
{
retorno.setValue(itVal.dimensiones[0]);
}
return(retorno);
}
public void getArray(token tipo, elementoEntorno elemEntor)
{
if (hayErrores())
{
return;
}
Dictionary <int, itemValor> diccionario = new Dictionary <int, itemValor>();
List <int> dimensioenes = new List <int>();
int dimensionActual = 0;
foreach (nodoModelo temp in hijos)
{
_LLAVES_VAL_P llaves = (_LLAVES_VAL_P)temp;
llaves.getArray(diccionario, dimensioenes, tipo, dimensionActual, elemEntor);
}
//this.imprimiendoLstInt(dimensioenes);
this.diccionario = diccionario;
this.lstDimensiones = dimensioenes;
}
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 List <int> getLstInt(elementoEntorno tablaEntor, token nombreVar)
{
List <int> retorno = new List <int>();
foreach (nodoModelo temp in hijos)
{
//tiene que ser de dimensión cero prro
if (hayErrores())
{
return(retorno);
}
_PAR_CORCHETES_VAL par = (_PAR_CORCHETES_VAL)temp;
itemValor te = par.getValor(tablaEntor, nombreVar);
if (te.isTypeBooleano())
{
if (te.getBooleano())
{
retorno.Add(1);
}
else
{
retorno.Add(0);
}
}
else if (te.isTypeDecimal())
{
int valor = Convert.ToInt32(te.getDecimal());
if (valor >= 0)
{
retorno.Add(valor);
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede crear una matriz con tamaño negativo", nombreVar);
return(retorno);
}
}
else if (te.isTypeEntero())
{
if (te.getEntero() >= 0)
{
// println("Agreando:" + te.getEntero());
retorno.Add(te.getEntero());
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede crear una matriz con tamaño negativo", nombreVar);
return(retorno);
}
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede crear una matriz con tamaño de tipo : " + te.getTipo(), nombreVar);
return(retorno);
}
}
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemRetorno ejecutar(elementoEntorno elementoEntor)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0 = normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
itemRetorno retorno = new itemRetorno(0);
if (hayErrores())
{
return(retorno);
}
_E nodoE = (_E)getNodo("E");
itemValor valE = nodoE.getValor(elementoEntor);
Object objetoValor = valE.getValorParseado("booleano");
Boolean condicion = false;
if (objetoValor != null)
{
condicion = (Boolean)objetoValor;
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("La condición devulelta no es de tipo booleano,es de tipo:" + valE.getTipo(), lstAtributos.getToken(0));
return(retorno);
}
if (hijos.Count == 2)
/*
|----------------------------
| tSino + tSi + sAbreParent + E + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave
*/
{
if (condicion)
{
_LST_CUERPO nodoCuerpo = (_LST_CUERPO)getNodo("LST_CUERPO");
elementoEntorno entornoIf = new elementoEntorno(elementoEntor, tablaSimbolos, "Sino_Si", elementoEntor.este);
return(nodoCuerpo.ejecutar(entornoIf));
}
}
else if (hijos.Count == 3)
{
string caso = hijos[2].nombre;
if (caso.Equals("SINO_SI"))
/*
|----------------------------
| tSino + tSi + sAbreParent + E + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave + SINO_SI
*/
{
if (condicion)
{
_LST_CUERPO nodoCuerpo = (_LST_CUERPO)getNodo("LST_CUERPO");
elementoEntorno entornoIf = new elementoEntorno(elementoEntor, tablaSimbolos, "Sino_Si", elementoEntor.este);
return(nodoCuerpo.ejecutar(entornoIf));
}
else
{
_SINO_SI sino_si = (_SINO_SI)getNodo("SINO_SI");
return(sino_si.ejecutar(elementoEntor));
}
}
else if (caso.Equals("SINO"))
/*
|----------------------------
| tSino + tSi + sAbreParent + E + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave + SINO;
*/
{
if (condicion)
{
_LST_CUERPO nodoCuerpo = (_LST_CUERPO)getNodo("LST_CUERPO");
elementoEntorno entornoIf = new elementoEntorno(elementoEntor, tablaSimbolos, "Sino_si", elementoEntor.este);
return(nodoCuerpo.ejecutar(entornoIf));
}
else
{
_SINO nodoSINO = (_SINO)getNodo("SINO");
elementoEntorno entornoSino = new elementoEntorno(elementoEntor, tablaSimbolos, "Sino", elementoEntor.este);
return(nodoSINO.ejecutar(entornoSino));
}
}
}
return(retorno);
}
public void getArray2(Dictionary <int, itemValor> diccionario, List <int> dimensioenes, token tipo, int dimensionActual, elementoEntorno elemEntor)
{
if (hayErrores())
{
return;
}
//hay que contar cuántos hijos tiene, esa es una dimensión
foreach (nodoModelo temp in hijos)
{
_LLAVES_VAL_P llaves = (_LLAVES_VAL_P)temp;
if (dimensionActual > dimensioenes.Count)
//voy a corroborar si ya hay un indice ingresado
{
dimensioenes.Add(hijos.Count);
}
else
//indica que el indice ya esta, hay que corroborar si tiene la misma cantidad de hijos
// dimensionActual-1
{
if (dimensioenes[dimensionActual - 1] != hijos.Count)
//hay problema con la cantidad de hijos
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No coincide el tamaño de la dimension: " + dimensionActual + " en la matriz de tipo: " + tipo.val, tipo);
}
}
llaves.getArray(diccionario, dimensioenes, tipo, dimensionActual, elemEntor);
}
return;
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public itemValor opIgualacion(itemValor val1, itemValor val2, String ambito, elementoEntorno elem)
{
itemValor retorno = new itemValor();
if (val1 == null)
{
tabla.tablaErrores.insertErrorSemantic("[opAritmetica]" + ambito + "Hijo1 es null", new token("--"));
return(retorno);
}
if (val2 == null)
{
tabla.tablaErrores.insertErrorSemantic("[opAritmetica]" + ambito + " Hijo1 es null", new token("--"));
return(retorno);
}
println("----al principio---");
println("val1->" + val1.getTipo());
println("val2->" + val2.getTipo());
try
{
/*
|--------------------------------------------------------------------------
| Booleano
|--------------------------------------------------------------------------
*/
/*
* Booleano == Booleano
*/
if (val1.isTypeBooleano() && val2.isTypeBooleano())
{
if (val1.getBooleano() == val2.getBooleano())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Booleano == Entero
*/
else if (val1.isTypeBooleano() && val2.isTypeEntero())
{
int entero1 = 0;
if (val1.getBooleano())
{
entero1 = 1;
}
else
{
entero1 = 0;
}
if (entero1 == val2.getEntero())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Booleano == Decimal
*/
else if (val1.isTypeBooleano() && val2.isTypeDecimal())
{
Double entero1 = 0.0;
if (val1.getBooleano())
{
entero1 = 1.0;
}
else
{
entero1 = 0.0;
}
if (entero1 == val2.getDecimal())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Booleano == Cadena
*/
else if (val1.isTypeBooleano() && val2.isTypeCadena())
{
int entero1 = 0;
if (val1.getBooleano())
{
entero1 = 1;
}
else
{
entero1 = 0;
}
if (entero1 == val2.getCadena().Length)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
|--------------------------------------------------------------------------
| Entero
|--------------------------------------------------------------------------
*/
/*
* Entero == Booleano
*/
else if (val1.isTypeEntero() && val2.isTypeBooleano())
{
int entero2 = 0;
if (val2.getBooleano())
{
entero2 = 1;
}
else
{
entero2 = 0;
}
if (val1.getEntero() == entero2)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Entero == Entero
*/
else if (val1.isTypeEntero() && val2.isTypeEntero())
{
if (val1.getEntero() == val2.getEntero())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Entero == Decimal
*/
else if (val1.isTypeEntero() && val2.isTypeDecimal())
{
Double num2 = val2.getDecimal();
int valInt2 = (int)Math.Truncate(num2);
if (val1.getEntero() == valInt2)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Entero == Cadena
*
*/
else if (val1.isTypeEntero() && val2.isTypeCadena())
{
if (val1.getEntero() == val2.getCadena().Length)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
|--------------------------------------------------------------------------
| Cadena
|--------------------------------------------------------------------------
*/
/*
* Cadena * Booleano = Cadena
*/
else if (val1.isTypeCadena() && val2.isTypeBooleano())
{
int entero2 = 0;
if (val2.getBooleano())
{
entero2 = 1;
}
else
{
entero2 = 0;
}
if (val1.getCadena().Length == entero2)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Cadena == Numerico
*/
else if (val1.isTypeCadena() && val2.isTypeEntero())
{
if (val1.getCadena().Length == val2.getEntero())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Cadena == Decimal
*/
else if (val1.isTypeCadena() && val2.isTypeDecimal())
{
if (val1.getCadena().Length == val2.getDecimal())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Cadena == Cadena
*/
else if (val1.isTypeCadena() && val2.isTypeCadena())
{
if (val1.getCadena().Equals(val2.getCadena()))
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
|--------------------------------------------------------------------------
| Decimal
|--------------------------------------------------------------------------
*/
/*
* Decimal == Booleano
*/
else if (val1.isTypeDecimal() && val2.isTypeBooleano())
{
Double entero2 = 0.0;
if (val2.getBooleano())
{
entero2 = 1.0;
}
else
{
entero2 = 0.0;
}
if (val1.getDecimal() == entero2)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Decimal == Numerico
*/
else if (val1.isTypeDecimal() && val2.isTypeEntero())
{
int valInt1 = (int)Math.Truncate(val1.getDecimal());
if (valInt1 == val2.getEntero())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Decimal == Cadena
*/
else if (val1.isTypeDecimal() && val2.isTypeCadena())
{
if (val1.getDecimal() == val2.getCadena().Length)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Decimal == Decimal
*/
else if (val1.isTypeDecimal() && val2.isTypeDecimal())
{
if (val1.getDecimal() == val2.getDecimal())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
|--------------------------------------------------------------------------
| Comparando tipo date
|--------------------------------------------------------------------------
*/
/*
* FechaHora == Fecha
*/
else if ((val1.isTypeFechaHora() || val1.isTypeFecha() || val1.isTypeHora()) && (val2.isTypeFechaHora() || val2.isTypeFecha() || val2.isTypeHora()))
{
if (val1.getFechaHora() == val2.getFechaHora())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
|--------------------------------------------------------------------------
| NULO
|--------------------------------------------------------------------------
*/
/*
* Nulo == Nulo
*/
else if (val1.isTypeNulo() && val2.isTypeNulo())
{
retorno.setValue(true);
println("Si se recoocieron los tipos");
println("val1->" + val1.getTipo());
println("val2->" + val2.getTipo());
return(retorno);
}
else
{
println("No se recoocieron los tipos");
println("val1->" + val1.getTipo());
println("val2->" + val2.getTipo());
if (val1.valor.Equals(val2.valor))
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
//tabla.tablaErrores.insertErrorSemantic("No se pueden operar [" + ambito + "] " + val1.getTipo() + " con " + val2.getTipo(), signo);
}
}
catch (Exception)
{
tabla.tablaErrores.insertErrorSemantic("[opRelacional]No se pudo efectuar [" + ambito + " ]", signo);
}
return(retorno);
}
public itemValor opPotencia(elementoEntorno elem)
{
itemValor retorno = new itemValor();
itemValor val1 = hijo1.getValor(elem);
itemValor val2 = hijo2.getValor(elem);
if (val1 == null)
{
tabla.tablaErrores.insertErrorSemantic("[opAritmetica]opSuma Hijo1 es null", new token("--"));
return(retorno);
}
if (val2 == null)
{
tabla.tablaErrores.insertErrorSemantic("[opAritmetica]opSuma Hijo1 es null", new token("--"));
return(retorno);
}
try
{
/*
|--------------------------------------------------------------------------
| Booleano
|--------------------------------------------------------------------------
*/
/*
* Booleano ^ Booleano = Booleano
*/
/*
* Booleano ^ Entero = Entero
*/
if (val1.isTypeBooleano() && val2.isTypeEntero())
{
Double entero1 = 0.0;
if (val1.getBooleano())
{
entero1 = 1.0;
}
else
{
entero1 = 0.0;
}
retorno.setTypeDecimal();
retorno.valor = Math.Pow(entero1, (Double)val2.getEntero());
}
/*
* Booleano ^ Decimal = Decimal
*/
else if (val1.isTypeBooleano() && val2.isTypeDecimal())
{
Double entero1 = 0.0;
if (val1.getBooleano())
{
entero1 = 1.0;
}
else
{
entero1 = 0.0;
}
retorno.setTypeDecimal();
retorno.valor = Math.Pow(entero1, val2.getDecimal());
}
/*
* Booleano^ Cadena = Cadena
*/
/*
|--------------------------------------------------------------------------
| Entero
|--------------------------------------------------------------------------
*/
/*
* Entero ^ Booleano = Entero
*/
else if (val1.isTypeEntero() && val2.isTypeBooleano())
{
Double entero2 = 0.0;
if (val2.getBooleano())
{
entero2 = 1.0;
}
else
{
entero2 = 0.0;
}
retorno.setTypeDecimal();
retorno.valor = Math.Pow((Double)val1.getEntero(), entero2);
}
/*
* Entero / Entero = Entero
*/
else if (val1.isTypeEntero() && val2.isTypeEntero())
{
retorno.setTypeDecimal();
retorno.valor = Math.Pow((Double)val1.getEntero(), (Double)val2.getEntero());
}
/*
* Entero / Decimal = Decimal
*/
else if (val1.isTypeEntero() && val2.isTypeDecimal())
{
retorno.setTypeDecimal();
retorno.valor = Math.Pow((Double)val1.getEntero(), val2.getDecimal());
}
/*
* Entero / Cadena = Cadena
*/
/*
|--------------------------------------------------------------------------
| Cadena
|--------------------------------------------------------------------------
*/
/*
* Cadena / Booleano = Cadena
*/
/*
* Cadena / Numerico = Cadena
*/
/*
* Cadena / Decimal = Cadena
*/
/*
* Cadena / Cadena = Cadena
*/
/*
|--------------------------------------------------------------------------
| Decimal
|--------------------------------------------------------------------------
*/
/*
* Decimal / Booleano = Decimal
*/
else if (val1.isTypeDecimal() && val2.isTypeBooleano())
{
Double entero2 = 0.0;
if (val2.getBooleano())
{
entero2 = 1.0;
}
else
{
entero2 = 0.0;
}
retorno.setTypeDecimal();
retorno.valor = Math.Pow(val1.getDecimal(), entero2);
}
/*
* Decimal / Numerico = Decimal
*/
else if (val1.isTypeDecimal() && val2.isTypeEntero())
{
retorno.setTypeDecimal();
retorno.valor = Math.Pow(val1.getDecimal(), (Double)val2.getEntero());
}
/*
* Decimal / Cadena = Cadena
*/
/*
* Decimal / Decimal = Decimal
*/
else if (val1.isTypeDecimal() && val2.isTypeDecimal())
{
if (val2.getDecimal() == 0.0)
{
tabla.tablaErrores.insertErrorSemantic("No puede haber denominador cero", signo);
return(retorno);
}
retorno.setTypeDecimal();
retorno.valor = Math.Pow(val1.getDecimal(), val2.getDecimal());
}
else
{
tabla.tablaErrores.insertErrorSemantic("No se pueden operar la [Potencia] " + val1.getTipo() + " elevado a " + val2.getTipo(), signo);
}
//aquí hay que parsear los objetos
}
catch (Exception e)
{
tabla.tablaErrores.insertErrorSemantic("[opAritmeticaSuma]No se pudo efectuar la potencia", signo);
}
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones ope Tipo
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemValor ope_tipo(elementoEntorno elem)
{
itemValor retorno = new itemValor();
retorno.setTypeNulo();
if (hayErrores())
{
return(retorno);
}
if (hijos.Count != 1)
{
return(retorno);
}
_LST_VAL nodoVals = (_LST_VAL)getNodo("LST_VAL");
if (nodoVals == null)
{
return(retorno);
}
_TAM taman = new _TAM("TAM", tablaSimbolos);
lstValores listaValroes = nodoVals.getLstValores(elem);
if (listaValroes.listaValores.Count > 0)
{
int minimo = 0;
int i = 0;
foreach (itemValor itemVal in listaValroes.listaValores)
{
if (i == 0)
{
itemValor minimoItem = taman.calcularTamanio(itemVal, elem);
if (hayErrores())
{
return(retorno);
}
minimo = (int)minimoItem.getValorParseado("entero");
}
else
{
itemValor minimoItem = taman.calcularTamanio(itemVal, elem);
if (hayErrores())
{
return(retorno);
}
int enteroAnterio = (int)minimoItem.getValorParseado("entero");
if (enteroAnterio < minimo)
{
minimo = enteroAnterio;
}
}
i++;
}
retorno.setValue(minimo);
return(retorno);
}
else
{
retorno.setValue(0);
return(retorno);
}
}
public itemRetorno ejecutar(elementoEntorno elementoEntor, itemValor expresion)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0 = normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
itemRetorno retorno = new itemRetorno(0);
if (hayErrores())
{
return(retorno);
}
if (hijos.Count == 3)
/*
|----------------------------
| E + sDosPuntos + sAbreLlave + LST_CUERPO + sCierraLlave + CUERPO_CASE
*/
{
_E nodoE = (_E)getNodo("E");
itemValor valE = nodoE.getValor(elementoEntor);
IgualQue igual = new IgualQue(new _E("temp1", tablaSimbolos), new _E("temp2", tablaSimbolos), tablaSimbolos, new token("="));
itemValor resultado = igual.opIgualacion(expresion, valE, "IGUALACION", elementoEntor);
Object objetoValor = resultado.getValorParseado("booleano");
Boolean condicion = false;
if (objetoValor != null)
{
condicion = (Boolean)objetoValor;
if (condicion)
{
_LST_CUERPO nodoCuerpo = (_LST_CUERPO)getNodo("LST_CUERPO");
itemRetorno break1 = nodoCuerpo.ejecutar(elementoEntor);
//voy a revisar si no hay break prro
if (break1.isRomper())
{
println("es romper");
itemRetorno ret2 = new itemRetorno(0);
//asi retorno un normal
return(ret2);
//aquí rompo prro
}
else
{
println("no es romper");
_CUERPO_CASE cuerpoCase = (_CUERPO_CASE)getNodo("CUERPO_CASE");
return(cuerpoCase.ejecutar(elementoEntor, expresion));
}
}
else
{
println("ejecutando cuerpo clase");
_CUERPO_CASE sino_si = (_CUERPO_CASE)getNodo("CUERPO_CASE");
return(sino_si.ejecutar(elementoEntor, expresion));
}
}
else
{
println("E + sDosPuntos + sAbreLlave + LST_CUERPO + sCierraLlave + CUERPO_CASE-> No se retorno un boolenano en la igualación");
return(retorno);
}
}
else if (hijos.Count == 2)
/*
|----------------------------
| E + sDosPuntos + sAbreLlave + LST_CUERPO + sCierraLlave
*/
{
_E nodoE = (_E)getNodo("E");
itemValor valE = nodoE.getValor(elementoEntor);
IgualQue igual = new IgualQue(new _E("temp1", tablaSimbolos), new _E("temp2", tablaSimbolos), tablaSimbolos, new token("="));
itemValor resultado = igual.opIgualacion(expresion, valE, "IGUALACION", elementoEntor);
Object objetoValor = resultado.getValorParseado("booleano");
Boolean condicion = false;
if (objetoValor != null)
{
condicion = (Boolean)objetoValor;
if (condicion)
{
_LST_CUERPO nodoCuerpo = (_LST_CUERPO)getNodo("LST_CUERPO");
return(nodoCuerpo.ejecutar(elementoEntor));
}
else
{
return(retorno);
}
}
else
{
println(" E + sDosPuntos + sAbreLlave + LST_CUERPO + sCierraLlave -> No se retorno un boolenano en la igualación");
return(retorno);
}
}
else if (hijos.Count == 1)
/*
|----------------------------
| tDefecto + sDosPuntos + sAbreLlave + LST_CUERPO + sCierraLlave;
*/
{
_LST_CUERPO nodoCuerpo = (_LST_CUERPO)getNodo("LST_CUERPO");
return(nodoCuerpo.ejecutar(elementoEntor));
}
else
{
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 != 2)
{
return(retorno);
}
String tipo2 = "entero";
_E nodoE2 = (_E)hijos[0];
_E nodoE3 = (_E)hijos[1];
if (hayErrores())
{
return(retorno);
}
int inicioVal = 0;
int finalVal = 0;
itemValor itemInicio = nodoE2.getValor(elem);
Object inicioTemp = itemInicio.getValorParseado(tipo2);
itemValor itemFinal = nodoE3.getValor(elem);
Object finalTemp = itemFinal.getValorParseado(tipo2);
if (inicioTemp != null)
{
inicioVal = (int)inicioTemp;
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede parsear a entero el valor", lstAtributos.getToken(0));
return(retorno);
}
if (finalTemp != null)
{
finalVal = (int)finalTemp;
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede parsear a entero el valor", lstAtributos.getToken(0));
return(retorno);
}
if (inicioVal == 0 || finalVal == 0)
{
tablaSimbolos.tablaErrores.insertErrorSemantic("Potencia con base 0 elevado a 0 es indeterminado", lstAtributos.getToken(0));
return(retorno);
}
retorno.setValue(Math.Pow(inicioVal, finalVal));
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemRetorno ejecutar(elementoEntorno elementoEntor)
{
itemRetorno retorno = new itemRetorno(0);
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN DE METODO
|-------------------------------------------------------------------------------------------------------------------
|
*/
public itemValor getMetodoFuncion(token nombre, lstValores parametros, elementoEntorno tablaEntorno, String nombreAmbitoEntorno)
{
itemValor retorno = new itemValor();
retorno.setTypeVacio();
//aqui es donde tengo que buscar si existe
Console.WriteLine("ejecutando Metodo:" + nombre.val);
elementoPolimorfo temp = getElementoPolimorfo2(nombre, parametros);
if (temp != null)
//neuvo entorno
{
elementoEntorno hijo1 = new elementoEntorno(tablaEntorno, tabla, nombreAmbitoEntorno, tablaEntorno.este);
guardarParametrosEnLaTabla(temp.lstParametros, parametros, hijo1);
if (temp.LST_CUERPO.nombre.Equals("LST_CUERPO"))
/*
|----------------------------
| Ejecutando el cuerpo del metodo
*/
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0 = normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
_LST_CUERPO val = (_LST_CUERPO)temp.LST_CUERPO;
itemRetorno result = val.ejecutar(hijo1);
if (temp.tipo.valLower.Equals("vacio"))
{
if (result.isNormal())//que es el normal
{
}
else if (result.isRetorno())
{
if (result.valor.isTypeVacio())
//fue el return normla, sin expresion
{
}
else
{
tabla.tablaErrores.insertErrorSemantic("El metodo :" + temp.nombre.val + " está declarado como vacio, pero se retorno una expresión", temp.nombre);
}
}
else
{
}
}
else
/*
| 0 = normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
if (result.isNormal())
{
tabla.tablaErrores.insertErrorSemantic("El metodo :" + temp.nombre.val + " debe de retorar un valor", temp.nombre);
}
else if (result.isRetorno())
{
if (temp.dimension == result.valor.dimensiones.Count)
{
//para los tipos
if (itemEntorno.validandoTipo(temp.tipo.valLower, result.valor))
{
return(result.valor);
}
else
{
tabla.tablaErrores.insertErrorSemantic("El metodo :" + temp.nombre.val + " es de tipo :" + temp.tipo.val + " sin embargo tiene un retorno de tipo: " + result.valor.getTipo(), temp.nombre);
return(retorno);
}
}
else
{
tabla.tablaErrores.insertErrorSemantic("El metodo :" + temp.nombre.val + " es de dimensión :" + temp.dimension + " sin embargo tiene un retorno de dimensión: " + result.valor.dimensiones.Count, temp.nombre);
return(retorno);
}
}
else
{
}
}
///hay que comparar el retorno con el tipo definido
}
//Console.WriteLine("---------------------------Imprimiendo el metodo Funcion-------------------------");
//hijo1.imprimir();
}
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);
//ya estoy recibiendo la tabla donde debo trabajar prro
if (hayErrores())
{
return(retorno);
}
_VALOR val = getNodoVALOR();
if (val != null)
{
//se estan guardando valores en la variable
// println("Ejecutando el imprimir que tiene un hijo de valore ejejejejejejejejej");
itemValor temp = val.getValor(tablaEntornos, new token());
if (temp.isTypeNulo())
{
tablaSimbolos.consola.insertar("nulo");
}
else
{
if (tablaSimbolos.consola != null)
{
if (temp.valor != null)
{
try
{
tablaSimbolos.consola.insertar(temp.valor.ToString());
}
catch (Exception e)
{
tablaSimbolos.consola.insertar(e.ToString());
}
}
//tablaSimbolos.consola.insertar("imprimiendo");
}
else
{
println("tablaSimblo.consola is null");
}
//
}
}
else
{
tablaSimbolos.consola.insertar("");
}
return(retorno);
}
public itemValor opMayorQue(String ambito, elementoEntorno elem)
{
itemValor retorno = new itemValor();
itemValor val1 = hijo1.getValor(elem);
itemValor val2 = hijo2.getValor(elem);
if (val1 == null)
{
tabla.tablaErrores.insertErrorSemantic("[opAritmetica]" + ambito + "Hijo1 es null", new token("--"));
return(retorno);
}
if (val2 == null)
{
tabla.tablaErrores.insertErrorSemantic("[opAritmetica]" + ambito + " Hijo1 es null", new token("--"));
return(retorno);
}
try
{
/*
|--------------------------------------------------------------------------
| Booleano
|--------------------------------------------------------------------------
*/
/*
* Booleano > Booleano
*/
if (val1.isTypeBooleano() && val2.isTypeBooleano())
{
tabla.tablaErrores.insertErrorSemantic("No se pueden comparar valores booleanos [" + ambito + "] " + val1.getTipo() + " == " + val2.getTipo(), signo);
return(retorno);
}
/*
* Booleano > Entero
*/
else if (val1.isTypeBooleano() && val2.isTypeEntero())
{
int entero1 = 0;
if (val1.getBooleano())
{
entero1 = 1;
}
else
{
entero1 = 0;
}
if (entero1 > val2.getEntero())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Booleano > Decimal
*/
else if (val1.isTypeBooleano() && val2.isTypeDecimal())
{
Double entero1 = 0.0;
if (val1.getBooleano())
{
entero1 = 1.0;
}
else
{
entero1 = 0.0;
}
if (entero1 > val2.getDecimal())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Booleano > Cadena
*/
else if (val1.isTypeBooleano() && val2.isTypeCadena())
{
int entero1 = 0;
if (val1.getBooleano())
{
entero1 = 1;
}
else
{
entero1 = 0;
}
if (entero1 > val2.getCadena().Length)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
|--------------------------------------------------------------------------
| Entero
|--------------------------------------------------------------------------
*/
/*
* Entero > Booleano
*/
else if (val1.isTypeEntero() && val2.isTypeBooleano())
{
int entero2 = 0;
if (val2.getBooleano())
{
entero2 = 1;
}
else
{
entero2 = 0;
}
if (val1.getEntero() > entero2)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Entero > Entero
*/
else if (val1.isTypeEntero() && val2.isTypeEntero())
{
if (val1.getEntero() > val2.getEntero())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Entero > Decimal
*/
else if (val1.isTypeEntero() && val2.isTypeDecimal())
{
Double num2 = val2.getDecimal();
int valInt2 = (int)Math.Truncate(num2);
if (val1.getEntero() > valInt2)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Entero > Cadena
*
*/
else if (val1.isTypeEntero() && val2.isTypeCadena())
{
if (val1.getEntero() > val2.getCadena().Length)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
|--------------------------------------------------------------------------
| Cadena
|--------------------------------------------------------------------------
*/
/*
* Cadena * Booleano = Cadena
*/
else if (val1.isTypeCadena() && val2.isTypeBooleano())
{
int entero2 = 0;
if (val2.getBooleano())
{
entero2 = 1;
}
else
{
entero2 = 0;
}
if (val1.getCadena().Length > entero2)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Cadena > Numerico
*/
else if (val1.isTypeCadena() && val2.isTypeEntero())
{
if (val1.getCadena().Length > val2.getEntero())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Cadena > Decimal
*/
else if (val1.isTypeCadena() && val2.isTypeDecimal())
{
if (val1.getCadena().Length > val2.getDecimal())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Cadena > Cadena
*/
else if (val1.isTypeCadena() && val2.isTypeCadena())
{
if (val1.getCadena().Length > val2.getCadena().Length)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
|--------------------------------------------------------------------------
| Decimal
|--------------------------------------------------------------------------
*/
/*
* Decimal > Booleano
*/
else if (val1.isTypeDecimal() && val2.isTypeBooleano())
{
Double entero2 = 0.0;
if (val2.getBooleano())
{
entero2 = 1.0;
}
else
{
entero2 = 0.0;
}
if (val1.getDecimal() > entero2)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Decimal > Numerico
*/
else if (val1.isTypeDecimal() && val2.isTypeEntero())
{
int valInt1 = (int)Math.Truncate(val1.getDecimal());
if (valInt1 > val2.getEntero())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Decimal > Cadena
*/
else if (val1.isTypeDecimal() && val2.isTypeCadena())
{
if (val1.getDecimal() > val2.getCadena().Length)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Decimal > Decimal
*/
else if (val1.isTypeDecimal() && val2.isTypeDecimal())
{
if (val1.getDecimal() > val2.getDecimal())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
|--------------------------------------------------------------------------
| Comparando tipo date
|--------------------------------------------------------------------------
*/
/*
* FechaHora > Fecha
*/
else if ((val1.isTypeFechaHora() || val1.isTypeFecha() || val1.isTypeHora()) && (val2.isTypeFechaHora() || val2.isTypeFecha() || val2.isTypeHora()))
{
if (val1.getFechaHora() > val2.getFechaHora())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
else
{
tabla.tablaErrores.insertErrorSemantic("No se pueden operar [" + ambito + "] " + val1.getTipo() + " con " + val2.getTipo(), signo);
}
}
catch (Exception)
{
tabla.tablaErrores.insertErrorSemantic("[opAritmeticaSuma]No se pudo efectuar [" + ambito + " ]", signo);
}
return(retorno);
}
/*
|--------------------------------------------------------------------------
| La ejecución FINAL con ITem entorno
|--------------------------------------------------------------------------
|
|
|
| public virtual void ejecutar(elementoEntorno elem, itemEntorno item)
| {
| ejecutarHijos(elem, item);
| }
|
| public void ejecutarHijos(elementoEntorno elem, itemEntorno item)
| {
|
| if (hayErrores())
| return;
|
| foreach (nodoModelo temp in hijos)
| {
| temp.ejecutar(elem, item);
| }
| }*/
/*
|--------------------------------------------------------------------------
| La ejecución FINAL
|--------------------------------------------------------------------------
| 0= normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
public virtual itemRetorno ejecutar(elementoEntorno tablaEntornos)
{
itemRetorno resultado = ejecutarHijos(tablaEntornos);
return(resultado);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones ope Tipo
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemValor ope_tipo(elementoEntorno elem)
{
itemValor retorno = new itemValor();
retorno.setTypeNulo();
if (hayErrores())
{
return(retorno);
}
if (hijos.Count != 2)
{
return(retorno);
}
String tipo1 = "cadena";
String tipo2 = "entero";
_E nodoE1 = (_E)hijos[0];
_E nodoE2 = (_E)hijos[1];
if (hayErrores())
{
return(retorno);
}
String cadenaVal = "";
int inicioVal = 0;
itemValor itemCadena = nodoE1.getValor(elem);
Object cadenaTemp = itemCadena.getValorParseado(tipo1);
itemValor itemInicio = nodoE2.getValor(elem);
Object inicioTemp = itemInicio.getValorParseado(tipo2);
if (cadenaTemp != null)
{
cadenaVal = (String)cadenaTemp;
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede parsear a cadena el valor", lstAtributos.getToken(0));
return(retorno);
}
if (inicioTemp != null)
{
inicioVal = (int)inicioTemp;
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede parsear a entero el valor", lstAtributos.getToken(0));
return(retorno);
}
if ((inicioVal) > cadenaVal.Length || (inicioVal) < 0)
{
tablaSimbolos.tablaErrores.insertErrorSemantic("El indice superior supera la longitud de la cadena", lstAtributos.getToken(0));
return(retorno);
}
Char[] temp1 = cadenaVal.ToCharArray();
String salida = temp1[inicioVal].ToString();
retorno.setValue(salida);
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);
}
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);
}
public override itemRetorno ejecutar(elementoEntorno elementoEntor)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0 = normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
itemRetorno retorno = new itemRetorno(0);
if (hayErrores())
{
return(retorno);
}
_E nodoE = (_E)getNodo("E");
itemValor valE = nodoE.getValor(elementoEntor);
Object objetoValor = valE.getValorParseado("booleano");
Boolean condicion = false;
if (objetoValor != null)
{
condicion = (Boolean)objetoValor;
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("La condición devulelta no es de tipo booleano,es de tipo:" + valE.getTipo(), lstAtributos.getToken(0));
return(retorno);
}
while (condicion)
{
_LST_CUERPO nodoCuerpo = (_LST_CUERPO)getNodo("LST_CUERPO");
elementoEntorno entornoWhile = new elementoEntorno(elementoEntor, tablaSimbolos, "While", elementoEntor.este);
retorno = nodoCuerpo.ejecutar(entornoWhile);
//analizando el continue, el break, y el return
if (retorno.isRomper())
//este codigo sirve para eliminar el romper en los nodos, más arriba, y solo se quede en el case
{
return(new itemRetorno(0));
}
else if (retorno.isRetorno())
{
return(retorno);
}
else if (retorno.isContinuar())
{
return(new itemRetorno(0));
//retorno = new itemRetorno(0);
}
else if (hayErrores())
{
return(retorno);
}
//volviendo analizar el while
nodoE = (_E)getNodo("E");
valE = nodoE.getValor(elementoEntor);
objetoValor = valE.getValorParseado("booleano");
condicion = (Boolean)objetoValor;
}
if (retorno.isContinuar())
{
return(new itemRetorno(0));
}
return(retorno);
}
public itemValor opIgualacion22(String ambito, elementoEntorno elem)
{
itemValor retorno = new itemValor();
itemValor val1 = hijo1.getValor(elem);
itemValor val2 = hijo2.getValor(elem);
if (val1 == null)
{
tabla.tablaErrores.insertErrorSemantic("[opAritmetica]" + ambito + "Hijo1 es null", new token("--"));
return(retorno);
}
if (val2 == null)
{
tabla.tablaErrores.insertErrorSemantic("[opAritmetica]" + ambito + " Hijo1 es null", new token("--"));
return(retorno);
}
/*
|--------------------------------------------------------------------------
| Booleano
|--------------------------------------------------------------------------
*/
/*
* Booleano + Booleano = Booleano
*
* if (val1.isTypeBooleano() && val2.isTypeBooleano())
* {
* tabla.tablaErrores.insertErrorSemantic("No se pueden comparar valores booleanos [" + ambito + "] " + val1.getTipo() + " == " + val2.getTipo(), signo);
*
*
* return retorno;
* }*/
/*
* Decimal + Numerico = Decimal
*/
else if (val1.isTypeDecimal() && val2.isTypeEntero())
{
Double num1 = val1.getDecimal();
int valInt1 = (int)Math.Truncate(num1);
if (valInt1.Equals(val2.getEntero()))
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Entero + Decimal = Decimal
*/
else if (val1.isTypeEntero() && val2.isTypeDecimal())
{
Double num2 = val2.getDecimal();
int valInt2 = (int)Math.Truncate(num2);
if (valInt2.Equals(val1.getEntero()))
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
else
{
if (val1.valor.Equals(val2.valor))
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
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 opNot(String ambito, elementoEntorno elem)
{
itemValor retorno = new itemValor();
itemValor val1 = hijo1.getValor(elem);
if (val1 == null)
{
tabla.tablaErrores.insertErrorSemantic("[opLogica]" + ambito + "Hijo1 es null", new token("--"));
return(retorno);
}
try
{
/*
|--------------------------------------------------------------------------
| Booleano
|--------------------------------------------------------------------------
*/
/*
* Booleano
*/
if (val1.isTypeBooleano())
{
retorno.setValue(!val1.getBooleano());
return(retorno);
}
/*
|--------------------------------------------------------------------------
| Entero
|--------------------------------------------------------------------------
*/
/*
* Entero
*/
else if (val1.isTypeEntero())
{
int bool1 = 0;
int val1R = val1.getEntero();
if (val1R == 0)
{
bool1 = 1;
}
else if (val1R == 1)
{
bool1 = 0;
}
else
{
tabla.tablaErrores.insertErrorSemantic("El entero: " + val1R + " no se puede parsear a un valor booleano", signo);
return(retorno);
}
retorno.setValue(bool1);
return(retorno);
}
/*
|--------------------------------------------------------------------------
| Decimal
|--------------------------------------------------------------------------
*/
/*
* Decimal
*/
else if (val1.isTypeDecimal())
{
double bool1 = 0.0;
double val1R = val1.getDecimal();
if (val1R == 0.0)
{
bool1 = 1.0;
}
else if (val1R == 1.0)
{
bool1 = 0.0;
}
else
{
tabla.tablaErrores.insertErrorSemantic("El decimal: " + val1R + " no se puede parsear a un valor booleano", signo);
return(retorno);
}
retorno.setValue(bool1);
return(retorno);
}
else
{
tabla.tablaErrores.insertErrorSemantic("No se pueden operar [" + ambito + "] " + val1.getTipo(), signo);
}
}
catch (Exception)
{
tabla.tablaErrores.insertErrorSemantic("[opLogica]No se pudo efectuar [" + ambito + " ]", signo);
}
return(retorno);
}
