public override Resultado ejecutar(Contexto ctx, int nivel)
        {
            //Obiene nombre de la variable, el valor, si es incremento o decremento y el cuerpo de la funcion
            String        nombreVar  = instruccion.ChildNodes[0].Token.Text;
            String        tipoVar    = Constantes.T_NUM;
            Resultado     ValorVar   = new Expresion(instruccion.ChildNodes[1].ChildNodes[0]).resolver(ctx);
            ParseTreeNode NodoCuerpo = instruccion.ChildNodes[4];
            String        inc_dec    = instruccion.ChildNodes[3].ToString();
            //si el valor de la variable no es el mismo a number se sale
            String castValue = "";

            switch (tipoVar)
            {
            case Constantes.T_BOOL:
                castValue = "" + Convert.ToInt32(Convert.ToBoolean(ValorVar.Valor));
                break;

            case Constantes.T_NUM:
                castValue = ValorVar.Valor;
                break;

            default:
                return(FabricarResultado.creaFail());
            }
            // Creo variablew
            Variable var = new Variable(nombreVar, castValue, tipoVar, nivel);

            //si existe, es error entonces
            if (ctx.existeVariable(nombreVar))
            {
                return(FabricarResultado.creaFail());
            }
            ctx.setVariable(var);
            Resultado exec = null;

            while (true)
            {
                Resultado condicionPara = new Expresion(instruccion.ChildNodes[2].ChildNodes[0]).resolver(ctx);
                if (condicionPara.Tipo != Constantes.T_BOOL)
                {
                    ListaErrores.getInstance().setErrorSemantico(instruccion.Token.Location.Line, instruccion.Token.Location.Line, "La condicion no retorna un valor booleando", Interprete.archivo);
                    return(FabricarResultado.creaFail());
                }

                bool cond = condicionPara.Boleano;

                if (!cond)
                {
                    exec = FabricarResultado.creaOk();
                    break;
                }

                Cuerpo cuerpo = new Cuerpo(NodoCuerpo, true);
                exec = cuerpo.ejecutar(ctx, nivel + 1);
                if (exec.esContinuar())
                {
                    continue;
                }
                if (exec.esDetener())
                {
                    exec = FabricarResultado.creaOk();
                    break;
                }
                if (exec.esRetorno())
                {
                    break;
                }

                Variable asigTemp = ctx.getVariable(nombreVar);
                if (asigTemp != null)
                {
                    if (asigTemp.Tipo == Constantes.T_NUM)
                    {
                        double valor = Convert.ToDouble(asigTemp.Valor);
                        if (inc_dec == Constantes.INCREMENTO)
                        {
                            valor++;
                        }
                        else
                        {
                            valor--;
                        }
                        asigTemp.Valor = valor.ToString();
                    }
                    ctx.ActualizarValor(nombreVar, asigTemp);
                }
                ctx.limpiarContexto(nivel + 1);
            }

            ctx.limpiarContexto(nivel + 1);
            ctx.limpiarContexto(nivel);

            return(exec);
        }
        public Resultado ejecutar(Contexto ctx, int nivel)
        {
            String nombreVar = instruccion.ChildNodes[0].Token.Text;

            if (!existeVariable(ctx, nombreVar))
            {
                return(FabricarResultado.creaFail());
            }
            Resultado res  = new Expresion(instruccion.ChildNodes[1].ChildNodes[0]).resolver(ctx);
            String    tipo = res.Tipo;

            if (tipo == Constantes.T_ERROR)
            {
                ListaErrores.getInstance().setErrorSemantico(instruccion.Token.Location.Line, instruccion.Token.Location.Line, "No se puedo resolver la expresion", Interprete.archivo);
                return(FabricarResultado.creaFail());
                //error en la expresion
            }
            Variable destino = obtenerVariable(ctx, nombreVar);
            String   tipoVar = destino.Tipo;
            String   casteo  = Constantes.ValidarTipos(tipoVar, tipo, Constantes.MT_ASIG);
            String   valor   = null;

            if (casteo == Constantes.T_ERROR)
            {
                ListaErrores.getInstance().setErrorSemantico(instruccion.Token.Location.Line, instruccion.Token.Location.Line, "No se puede asignar ese tipo de dato", Interprete.archivo);
                //no se puede asignar ese tipo
            }
            else
            {
                String tmp = "";
                switch (tipoVar)
                {
                case Constantes.T_STR:
                    switch (tipo)
                    {
                    case Constantes.T_BOOL:
                        tmp = "" + Convert.ToInt32(Convert.ToBoolean(res.Valor));
                        break;

                    default:
                        tmp = res.Valor;
                        break;
                    }
                    break;

                case Constantes.T_NUM:
                    switch (tipo)
                    {
                    case Constantes.T_BOOL:
                        tmp = "" + Convert.ToInt32(Convert.ToBoolean(res.Valor));
                        break;

                    case Constantes.T_NUM:
                        tmp = res.Valor;
                        break;

                    default:

                        ListaErrores.getInstance().setErrorSemantico(instruccion.Token.Location.Line, instruccion.Token.Location.Line, "error de casteo", Interprete.archivo);
                        //error por si llegara a pasar aunque no lo creo
                        break;
                    }
                    break;

                case Constantes.T_BOOL:
                    switch (tipo)
                    {
                    case Constantes.T_BOOL:
                        tmp = res.Valor;
                        break;

                    default:
                        ListaErrores.getInstance().setErrorSemantico(instruccion.Token.Location.Line, instruccion.Token.Location.Line, "error de casteo", Interprete.archivo);
                        //error por si llegara a pasar aunque no lo creo
                        break;
                    }
                    break;
                }
                valor = tmp;
            }
            destino.Valor = valor;

            ctx.ActualizarValor(nombreVar, destino);
            return(FabricarResultado.creaOk());
        }