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);
}
}
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);
}
}
