/*public opModelo(nodoModelo hijo11, nodoModelo hijo21, tablaSimbolos tabla)
* {
* this.hijo11 = hijo11;
* this.hijo21 = hijo21;
* this.tabla = tabla;
* }*/
public opModelo(nodoModelo hijo1, nodoModelo hijo2, tablaSimbolos tabla, token signo)
{
this.hijo1 = (_E)hijo1;
this.hijo2 = (_E)hijo2;
this.tabla = tabla;
this.signo = signo;
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones ope Tipo
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemValor ope_tipo(elementoEntorno elem)
{
itemValor retorno = new itemValor();
retorno.setTypeNulo();
if (hayErrores())
{
return(retorno);
}
_E nodoE = (_E)getNodo("E");
itemValor valE = nodoE.getValor(elem);
String tipo = "cadena";
Object resul = valE.getValorParseado(tipo);
if (resul != null)
{
String cadena = (String)resul;
retorno.setValue(cadena);
return(retorno);
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede parsear a " + tipo + " el valor", lstAtributos.getToken(0));
return(retorno);
}
}
/*
|-------------------------------------------------------------------------------------------------------------------
| Funciones ope Tipo
|-------------------------------------------------------------------------------------------------------------------
|
*/
public itemValor getValor(elementoEntorno elem)
{
itemValor retorno = new itemValor();
retorno.setTypeNulo();
if (hayErrores())
{
return(retorno);
}
if (hijos.Count != 3)
{
return(retorno);
}
_VALOR nodoE = (_VALOR)hijos[0];
itemValor valE = nodoE.getValor(elem, new token(""));
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);
}
_E nodoE2 = (_E)hijos[1];
_E nodoE3 = (_E)hijos[2];
if (hayErrores())
{
return(retorno);
}
itemValor itemVerdadero = nodoE2.getValor(elem);
itemValor itemFalso = nodoE3.getValor(elem);
if (condicion)
{
return(itemVerdadero);
}
else
{
return(itemFalso);
}
}
/*
|-------------------------------------------------------------------------------------------------------------------
| 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);
}
_E nodoE2 = (_E)hijos[0];
if (hayErrores())
{
return(retorno);
}
itemValor itemInicio = nodoE2.getValor(elem);
if (itemInicio.isTypeFecha())
{
return(itemInicio);
}
else if (itemInicio.isTypeCadena())
{
itemValor tel = new itemValor();
tel.convertirCadena(itemInicio.getCadena());
if (tel.isTypeFecha())
{
retorno = tel;
return(retorno);
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se pudo parsear a fecha", lstAtributos.getToken(0));
return(retorno);
}
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se pueden parsear a fecha expresiones que no sean cadenas", lstAtributos.getToken(0));
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)
{
tablaSimbolos.tablaErrores.insertErrorSemantic("Se estan esperando dos parametros, ruta de audio, y valor booleano", lstAtributos.getToken(0));
return(retorno);
}
_E nodo1 = (_E)hijos[0];
_E nodo2 = (_E)hijos[1];
itemValor itRuta = nodo1.getValor(tablaEntornos);
itemValor itBoolean = nodo2.getValor(tablaEntornos);
Object objRuta = itRuta.getValorParseado("cadena");
Object objBool = itBoolean.getValorParseado("booleano");
if (objRuta == null || objBool == null)
{
tablaSimbolos.tablaErrores.insertErrorSemantic("Uno de los parámetros no fue cadena y/o booleano", lstAtributos.getToken(0));
return(retorno);
}
else
{
string ruta = (string)objRuta;
ruta = tablaSimbolos.getRutaProyecto() + "\\" + ruta;
Boolean booleano = (Boolean)objBool;
frmAudio fdecimal = new frmAudio(tablaEntornos, ruta, booleano);
fdecimal.ShowDialog();
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);
}
String tipo2 = "entero";
_E nodoE2 = (_E)hijos[0];
if (hayErrores())
{
return(retorno);
}
int inicioVal = 0;
itemValor itemInicio = nodoE2.getValor(elem);
Object inicioTemp = itemInicio.getValorParseado(tipo2);
if (itemInicio.isTypeDecimal())
{
retorno.setValue(Math.Cos(itemInicio.getDecimal()));
return(retorno);
}
else if (inicioTemp != null)
{
inicioVal = (int)inicioTemp;
retorno.setValue(Math.Cos(inicioVal));
return(retorno);
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede parsear a entero el valor", lstAtributos.getToken(0));
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);
}
String tipo1 = "booleano";
_E nodoE1 = (_E)hijos[0];
if (hayErrores())
{
return(retorno);
}
Boolean boolVal = false;
itemValor itemBool = nodoE1.getValor(elem);
Object boolObject = itemBool.getValorParseado(tipo1);
if (boolObject != null)
{
boolVal = (Boolean)boolObject;
retorno.setValue(boolVal);
return(retorno);
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede parsear a booleano el valor", lstAtributos.getToken(0));
return(retorno);
}
}
/*
|-------------------------------------------------------------------------------------------------------------------
| 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);
}
}
/*
|-------------------------------------------------------------------------------------------------------------------
| 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 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);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemRetorno ejecutar(elementoEntorno tablaEntornos)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0= normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
//validar que solo vengan en formulario y pregutnas, y grupos
itemRetorno retorno = new itemRetorno(0);
//ya estoy recibiendo la tabla donde debo trabajar prro
if (hayErrores())
{
return(retorno);
}
_E val = getNodoE();
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);
if (temp.isTypeNulo())
{
mostrarMensaje("Mensaje");
}
else
{
if (tablaSimbolos.consola != null)
{
if (temp.valor != null)
{
try
{
mostrarMensaje(temp.valor.ToString());
}
catch (Exception e)
{
tablaSimbolos.consola.insertar(e.ToString());
}
}
//tablaSimbolos.consola.insertar("imprimiendo");
}
else
{
println("tablaSimblo.consola is null");
}
//
}
}
else
{
mostrarMensaje("");
}
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 nodoModelo getNodo(String nombreNoTerminal, tablaSimbolos tabla)
{
nodoModelo retorno = null;
switch (nombreNoTerminal)
{
case "S":
retorno = new _S(nombreNoTerminal, tabla);
break;
case "LST_IMPORT":
retorno = new _LST_IMPORT(nombreNoTerminal, tabla);
break;
case "IMPORT":
retorno = new _IMPORT(nombreNoTerminal, tabla);
break;
case "LST_CLASE":
retorno = new _LST_CLASE(nombreNoTerminal, tabla);
break;
case "CLASE":
retorno = new _CLASE(nombreNoTerminal, tabla);
break;
case "TIPO":
retorno = new _TIPO(nombreNoTerminal, tabla);
break;
case "EXTENDER":
retorno = new _EXTENDER(nombreNoTerminal, tabla);
break;
case "VISIBILIDAD":
retorno = new _VISIBILIDAD(nombreNoTerminal, tabla);
break;
case "LST_PARAMETROS":
retorno = new _LST_PARAMETROS(nombreNoTerminal, tabla);
break;
case "PARAMETRO":
retorno = new _PARAMETRO(nombreNoTerminal, tabla);
break;
case "LST_VAL":
retorno = new _LST_VAL(nombreNoTerminal, tabla);
break;
case "CP_CLASE":
retorno = new _CP_CLASE(nombreNoTerminal, tabla);
break;
case "CUERPO_CLASE":
retorno = new _CUERPO_CLASE(nombreNoTerminal, tabla);
break;
case "METODO":
retorno = new _METODO(nombreNoTerminal, tabla);
break;
case "SOBRESCRITURA":
retorno = new _SOBRESCRITURA(nombreNoTerminal, tabla);
break;
case "MAIN":
retorno = new _MAIN(nombreNoTerminal, tabla);
break;
case "CONSTRUCTOR":
retorno = new _CONSTRUCTOR(nombreNoTerminal, tabla);
break;
case "DECLARAR_VARIABLE_GLOBAL":
retorno = new _DECLARAR_VARIABLE_GLOBAL(nombreNoTerminal, tabla);
break;
case "DECLARAR_VARIABLE_SINVISIBI":
retorno = new _DECLARAR_VARIABLE_SINVISIBI(nombreNoTerminal, tabla);
break;
case "VAL":
retorno = new _VAL(nombreNoTerminal, tabla);
break;
case "LST_LLAVES_VAL":
retorno = new _LST_LLAVES_VAL(nombreNoTerminal, tabla);
break;
case "LLAVES_VAL_P":
retorno = new _LLAVES_VAL_P(nombreNoTerminal, tabla);
break;
case "VAR_ARREGLO":
retorno = new _VAR_ARREGLO(nombreNoTerminal, tabla);
break;
case "LST_CORCHETES":
retorno = new _LST_CORCHETES(nombreNoTerminal, tabla);
break;
case "LST_CORCHETES_VAL":
retorno = new _LST_CORCHETES_VAL(nombreNoTerminal, tabla);
break;
case "USAR_METO_VAR":
retorno = new _USAR_METO_VAR(nombreNoTerminal, tabla);
break;
case "USAR_VARIABLEP":
retorno = new _USAR_VARIABLEP(nombreNoTerminal, tabla);
break;
case "USAR_VARIABLE":
retorno = new _USAR_VARIABLE(nombreNoTerminal, tabla);
break;
case "USAR_METODO":
retorno = new _USAR_METODO(nombreNoTerminal, tabla);
break;
case "LLAMADA_FORMULARIO":
retorno = new _LLAMADA_FORMULARIO(nombreNoTerminal, tabla);
break;
case "LST_CUERPO":
retorno = new _LST_CUERPO(nombreNoTerminal, tabla);
break;
case "CUERPO":
retorno = new _CUERPO(nombreNoTerminal, tabla);
break;
case "VALOR":
retorno = new _VALOR(nombreNoTerminal, tabla);
break;
case "PAR_CORCHETES_VACIOS":
retorno = new _PAR_CORCHETES_VACIOS(nombreNoTerminal, tabla);
break;
case "E":
retorno = new _E(nombreNoTerminal, tabla);
break;
case "FUNCIONES_NATIVAS":
retorno = new _FUNCIONES_NATIVAS(nombreNoTerminal, tabla);
break;
case "IMPRIMIR":
retorno = new _IMPRIMIR(nombreNoTerminal, tabla);
break;
case "ID_VAR_FUNC":
retorno = new _ID_VAR_FUNC(nombreNoTerminal, tabla);
break;
case "LST_PUNTOSP":
retorno = new _LST_PUNTOSP(nombreNoTerminal, tabla);
break;
case "ASIG_VALOR":
retorno = new _ASIG_VALOR(nombreNoTerminal, tabla);
break;
case "PAR_CORCHETES_VAL":
retorno = new _PAR_CORCHETES_VAL(nombreNoTerminal, tabla);
break;
case "RETORNO":
retorno = new _RETORNO(nombreNoTerminal, tabla);
break;
case "SI":
retorno = new _SI(nombreNoTerminal, tabla);
break;
case "SINO_SI":
retorno = new _SINO_SI(nombreNoTerminal, tabla);
break;
case "SINO":
retorno = new _SINO(nombreNoTerminal, tabla);
break;
case "SENTENCIAS":
retorno = new _SENTENCIAS(nombreNoTerminal, tabla);
break;
case "SI_SIMPLIFICADO":
retorno = new _SI_SIMPLIFICADO(nombreNoTerminal, tabla);
break;
case "CASO":
retorno = new _CASO(nombreNoTerminal, tabla);
break;
case "CUERPO_CASE":
retorno = new _CUERPO_CASE(nombreNoTerminal, tabla);
break;
case "ROMPER":
retorno = new _ROMPER(nombreNoTerminal, tabla);
break;
case "WHILE":
retorno = new _WHILE(nombreNoTerminal, tabla);
break;
case "CONTINUAR":
retorno = new _CONTINUAR(nombreNoTerminal, tabla);
break;
case "FOR":
retorno = new _FOR(nombreNoTerminal, tabla);
break;
case "DOWHILE":
retorno = new _DOWHILE(nombreNoTerminal, tabla);
break;
case "REPETIR":
retorno = new _REPETIR(nombreNoTerminal, tabla);
break;
case "MENSAJE":
retorno = new _MENSAJE(nombreNoTerminal, tabla);
break;
case "TO_CADENA":
retorno = new _TO_CADENA(nombreNoTerminal, tabla);
break;
case "SUB_CAD":
retorno = new _SUB_CAD(nombreNoTerminal, tabla);
break;
case "POS_CAD":
retorno = new _POS_CAD(nombreNoTerminal, tabla);
break;
case "TO_BOOLEAN":
retorno = new _TO_BOOLEAN(nombreNoTerminal, tabla);
break;
case "TO_ENTERO":
retorno = new _TO_ENTERO(nombreNoTerminal, tabla);
break;
case "HOY":
retorno = new _HOY(nombreNoTerminal, tabla);
break;
case "AHORA":
retorno = new _AHORA(nombreNoTerminal, tabla);
break;
case "TO_FECHA":
retorno = new _TO_FECHA(nombreNoTerminal, tabla);
break;
case "TO_HORA":
retorno = new _TO_HORA(nombreNoTerminal, tabla);
break;
case "TO_FECHAHORA":
retorno = new _TO_FECHAHORA(nombreNoTerminal, tabla);
break;
case "TAM":
retorno = new _TAM(nombreNoTerminal, tabla);
break;
case "RANDOM":
retorno = new _RANDOM(nombreNoTerminal, tabla);
break;
case "MIN":
retorno = new _MIN(nombreNoTerminal, tabla);
break;
case "MAX":
retorno = new _MAX(nombreNoTerminal, tabla);
break;
case "OPE_TIPO":
retorno = new _OPE_TIPO(nombreNoTerminal, tabla);
break;
case "OPE_ARITME":
retorno = new _OPE_ARITME(nombreNoTerminal, tabla);
break;
case "POTENCIA":
retorno = new _POTENCIA(nombreNoTerminal, tabla);
break;
case "LOGARITMO":
retorno = new _LOGARITMO(nombreNoTerminal, tabla);
break;
case "LOGARITMO10":
retorno = new _LOGARITMO10(nombreNoTerminal, tabla);
break;
case "ABSOLUTO":
retorno = new _ABSOLUTO(nombreNoTerminal, tabla);
break;
case "SENO":
retorno = new _SENO(nombreNoTerminal, tabla);
break;
case "COSENO":
retorno = new _COSENO(nombreNoTerminal, tabla);
break;
case "TANGENTE":
retorno = new _TANGENTE(nombreNoTerminal, tabla);
break;
case "RAIZ":
retorno = new _RAIZ(nombreNoTerminal, tabla);
break;
case "PI":
retorno = new _PI(nombreNoTerminal, tabla);
break;
case "SUPER":
retorno = new _SUPER(nombreNoTerminal, tabla);
return(retorno);
case "FORMULARIO":
retorno = new _FORMULARIO(nombreNoTerminal, tabla);
return(retorno);
case "PREGUNTA":
retorno = new _PREGUNTA(nombreNoTerminal, tabla);
return(retorno);
case "GRUPO":
retorno = new _GRUPO(nombreNoTerminal, tabla);
return(retorno);
case "LST_CUERPO_PREGUNTA":
retorno = new _LST_CUERPO_PREGUNTA(nombreNoTerminal, tabla);
return(retorno);
case "CUERPO_PREGUNTA":
retorno = new _CUERPO_PREGUNTA(nombreNoTerminal, tabla);
return(retorno);
case "PREGUNTA_NATIVA":
retorno = new _PREGUNTA_NATIVA(nombreNoTerminal, tabla);
return(retorno);
case "ESCRIBIR_ARCHIVO":
retorno = new _ESCRIBIR_ARCHIVO(nombreNoTerminal, tabla);
return(retorno);
case "FUNC_MULTIMEDIA":
retorno = new _FUNC_MULTIMEDIA(nombreNoTerminal, tabla);
return(retorno);
case "AUDIO":
retorno = new _AUDIO(nombreNoTerminal, tabla);
return(retorno);
case "VIDEO":
retorno = new _VIDEO(nombreNoTerminal, tabla);
return(retorno);
case "IMAGEN":
retorno = new _IMAGEN(nombreNoTerminal, tabla);
return(retorno);
case "LEN":
retorno = new _LEN(nombreNoTerminal, tabla);
return(retorno);
default:
retorno = new nodoModelo("Desc_" + nombreNoTerminal, tabla);
Console.WriteLine("[generarArbol]No se encontró el nodo:" + nombreNoTerminal);
break;
}
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);
}
_E nodoE1 = (_E)hijos[0];
if (hayErrores())
{
return(retorno);
}
itemValor itemInicio = nodoE1.getValor(elem);
if (itemInicio.valor != null)
{
if (itemInicio.isTypeBooleano() || itemInicio.isTypeEntero() || itemInicio.isTypeDecimal())
{
Object intObject = itemInicio.getValorParseado("entero");
if (intObject != null)
{
int reton = (int)intObject;
retorno.setValue(reton);
return(retorno);
}
}
Object cadeObject = itemInicio.getValorParseado("cadena");
if (cadeObject != null)
{
String caden = (String)cadeObject;
retorno.setValue(caden.Length);
return(retorno);
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede parsear a cadena para verificar su tamaño", lstAtributos.getToken(0));
return(retorno);
}
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede parsear un objeto nulo", lstAtributos.getToken(0));
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 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);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| 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);
}
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);
}
}
/*
|-------------------------------------------------------------------------------------------------------------------
| 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);
}
if (hijos[0].nombre.Equals("DECLARAR_VARIABLE_SINVISIBI"))
/*
|----------------------------
| tPara + sAbreParent + DECLARAR_VARIABLE_SINVISIBI + sPuntoComa + E + sPuntoComa + ASIG_VALOR+ sCierraParent+ sAbreLlave+ LST_CUERPO + sCierraLlave
*/
{
nodoModelo nodotemp = getNodo("DECLARAR_VARIABLE_SINVISIBI");
if (nodotemp == null)
{
return(retorno);
}
_DECLARAR_VARIABLE_SINVISIBI decla = (_DECLARAR_VARIABLE_SINVISIBI)nodotemp;
decla.ejecutar(elementoEntor);
_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)
{
elementoEntorno entornoFor = new elementoEntorno(elementoEntor, tablaSimbolos, "para", elementoEntor.este);
_LST_CUERPO nodoCuerpo = (_LST_CUERPO)getNodo("LST_CUERPO");
retorno = nodoCuerpo.ejecutar(entornoFor);
//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);
}
//i++
_ASIG_VALOR asig = (_ASIG_VALOR)getNodo("ASIG_VALOR");
asig.ejecutar(entornoFor);
//volviendo analizar el while
nodoE = (_E)getNodo("E");
valE = nodoE.getValor(entornoFor);
objetoValor = valE.getValorParseado("booleano");
condicion = (Boolean)objetoValor;
}
if (retorno.isContinuar())
{
return(new itemRetorno(0));
}
}
else if (hijos[0].nombre.Equals("ASIG_VALOR"))
/*
|----------------------------
| tPara + sAbreParent + ASIG_VALOR + sPuntoComa + E + sPuntoComa + ASIG_VALOR + sCierraParent + sAbreLlave + LST_CUERPO + sCierraLlave;
*/
{
nodoModelo nodotemp = getNodo("ASIG_VALOR");
if (nodotemp == null)
{
return(retorno);
}
_ASIG_VALOR decla = (_ASIG_VALOR)hijos[0];
decla.ejecutar(elementoEntor);
_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)
{
elementoEntorno entornoFor = new elementoEntorno(elementoEntor, tablaSimbolos, "para", elementoEntor.este);
_LST_CUERPO nodoCuerpo = (_LST_CUERPO)getNodo("LST_CUERPO");
retorno = nodoCuerpo.ejecutar(entornoFor);
//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);
}
//i++
_ASIG_VALOR asig = (_ASIG_VALOR)hijos[2];
asig.ejecutar(entornoFor);
//volviendo analizar el while
nodoE = (_E)getNodo("E");
valE = nodoE.getValor(entornoFor);
objetoValor = valE.getValorParseado("booleano");
condicion = (Boolean)objetoValor;
}
if (retorno.isContinuar())
{
return(new itemRetorno(0));
}
}
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);
}
