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