Esempio n. 1
0
        /*
         |-------------------------------------------------------------------------------------------------------------------
         | EJECUCIÓN FINAL
         |-------------------------------------------------------------------------------------------------------------------
         |
         */

        public itemEntorno getDestino(elementoEntorno elementoEntorno)
        {
            itemEntorno retorno = null;

            if (hayErrores())
            {
                return(retorno);
            }


            if (lstAtributos.listaAtributos.Count == 0)

            /*
             |----------------------------
             |  ID_VAR_FUNC + LST_PUNTOSP
             */
            {
                #region reg1
                nodoModelo idVar = getNodo("ID_VAR_FUNC");
                if (idVar != null)
                {
                    nodoModelo lstPuntos = getNodo("LST_PUNTOSP");
                    if (lstPuntos != null)
                    {
                        _ID_VAR_FUNC temp1  = (_ID_VAR_FUNC)idVar;
                        _LST_PUNTOSP puntos = (_LST_PUNTOSP)lstPuntos;


                        itemValor   te1 = temp1.getValor(elementoEntorno);
                        itemEntorno te2 = puntos.getDestino(elementoEntorno, te1);
                        return(te2);

                        //tengo que obtener el objeto de id_var_func
                    }
                }
                #endregion
            }

            else if (lstAtributos.listaAtributos.Count == 1)
            {
                if (hijos.Count > 0)

                /*
                 |----------------------------
                 | valId + LST_CORCHETES_VAL
                 |------------
                 | Lst_Corchtes tiene que retornar una lista de tipo entero
                 |
                 */
                {
                    #region reg2

                    String item1     = lstAtributos.listaAtributos[0].nombretoken;
                    token  nombreVar = lstAtributos.getToken(0);
                    if (item1.Equals("valId"))

                    {
                        _LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)getNodo("LST_CORCHETES_VAL");
                        return(getEntornoId(lstAtributos.listaAtributos[0].tok, elementoEntorno, lstCorchetes.getLstInt(elementoEntorno, nombreVar)));
                    }
                    #endregion
                }
                else

                /*
                 |----------------------------
                 | valId
                 */
                {
                    String item1 = lstAtributos.listaAtributos[0].nombretoken;

                    if (item1.Equals("valId"))

                    {
                        return(getEntornoId(lstAtributos.listaAtributos[0].tok, elementoEntorno, new List <int>()));
                    }
                }
            }
            else if (lstAtributos.listaAtributos.Count == 3)
            {
                String item1 = lstAtributos.listaAtributos[0].nombretoken;
                String item2 = lstAtributos.listaAtributos[1].nombretoken;
                String item3 = lstAtributos.listaAtributos[2].nombretoken;

                if (item1.Equals("este") && item2.Equals(".") && item3.Equals("valId"))
                {
                    if (hijos.Count > 0)

                    /*
                     |----------------------------
                     |  tEste + sPunto + valId  + LST_CORCHETES_VAL
                     */
                    {
                        #region reg4


                        String valId     = lstAtributos.listaAtributos[2].nombretoken;
                        token  nombreVar = lstAtributos.getToken(2);
                        if (valId.Equals("valId"))

                        {
                            _LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)getNodo("LST_CORCHETES_VAL");
                            return(getEntornoId(lstAtributos.listaAtributos[2].tok, elementoEntorno.este.tablaEntorno.raiz, lstCorchetes.getLstInt(elementoEntorno, nombreVar)));
                        }

                        #endregion
                    }
                    else

                    /*
                     |----------------------------
                     |  tEste + sPunto + valId
                     */
                    {
                        String valId = lstAtributos.listaAtributos[2].nombretoken;

                        if (valId.Equals("valId"))

                        {
                            return(getEntornoId(lstAtributos.listaAtributos[2].tok, elementoEntorno.este.tablaEntorno.raiz, new List <int>()));
                        }
                    }
                }

                if (item1.Equals("valId") && item2.Equals("(") && item3.Equals(")"))
                {
                    if (hijos.Count == 2)

                    /*
                     |----------------------------
                     |  valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL;
                     |------------------------
                     * Primero ejecuto el metodo que me tiene que retornar siempre dimension>0
                     * luego enviarle ese valor, para extraer lo que se quiere
                     */
                    {
                        tablaSimbolos.tablaErrores.insertErrorSemantic("No se le puede asignar un valor a la expresión metodo" + lstAtributos.getToken(0).val + "()[] ", lstAtributos.getToken(0));
                    }

                    if (hijos.Count == 1)
                    {
                        String nombreHijo = hijos[0].nombre;
                        if (nombreHijo.Equals("LST_VAL"))

                        /*
                         |----------------------------
                         |  valId + sAbreParent + LST_VAL + sCierraParent;
                         |-------------
                         | Esto es un metodo
                         */
                        {
                            tablaSimbolos.tablaErrores.insertErrorSemantic("No se le puede asignar un valor a la expresión metodo" + lstAtributos.getToken(0).val + "()", lstAtributos.getToken(0));
                        }
                    }
                }
            }
            else if (lstAtributos.listaAtributos.Count == 5)
            {
                String item1 = lstAtributos.listaAtributos[0].nombretoken;
                String item2 = lstAtributos.listaAtributos[1].nombretoken;
                String item3 = lstAtributos.listaAtributos[2].nombretoken;

                if (item1.Equals("este") && item2.Equals(".") && item3.Equals("valId"))
                {
                    if (hijos.Count == 2)

                    /*
                     |----------------------------
                     | tEste + sPunto + valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL;
                     */
                    {
                        tablaSimbolos.tablaErrores.insertErrorSemantic("No se le puede asignar un valor a la expresión metodo este." + lstAtributos.getToken(0).val + "()[] ", lstAtributos.getToken(0));
                    }
                    else if (hijos.Count == 1)
                    {
                        if (hijos[0].nombre.Equals("LST_VAL"))

                        /*
                         |----------------------------
                         | tEste + sPunto + valId + sAbreParent + LST_VAL + sCierraParent
                         */
                        {
                            tablaSimbolos.tablaErrores.insertErrorSemantic("No se le puede asignar un valor a la expresión metodo este." + lstAtributos.getToken(0).val + "() ", lstAtributos.getToken(0));
                        }
                    }
                }
            }
            return(retorno);
        }
        /*
         |-------------------------------------------------------------------------------------------------------------------
         | EJECUCIÓN FINAL
         |-------------------------------------------------------------------------------------------------------------------
         |
         */

        public itemValor getValor(elementoEntorno elementoEntorno)
        {
            itemValor retorno = new itemValor();

            retorno.setTypeVacio();

            retorno.setTypeVacio(); //no puede retornar nada, es un metodo mahe



            if (hayErrores())
            {
                return(retorno);
            }


            if (lstAtributos.listaAtributos.Count == 0)

            /*
             |----------------------------
             |  ID_VAR_FUNC + LST_PUNTOSP
             */
            {
                #region reg1
                nodoModelo idVar = getNodo("ID_VAR_FUNC");
                if (idVar != null)
                {
                    nodoModelo lstPuntos = getNodo("LST_PUNTOSP");
                    if (lstPuntos != null)
                    {
                        _ID_VAR_FUNC temp1  = (_ID_VAR_FUNC)idVar;
                        _LST_PUNTOSP puntos = (_LST_PUNTOSP)lstPuntos;


                        itemValor te1 = temp1.getValor(elementoEntorno);
                        itemValor te2 = puntos.getValor(elementoEntorno, te1);


                        //aquí puedo revisar si fue una pregunta para poder guardarla en el entorno

                        /* if (te2.isTypeObjeto())
                         * {
                         *   if (te2.nombreObjeto.Equals("form"))
                         *   {
                         *
                         *       //guardando la pregunta dentro de la tabla de simbolos, jejejejejejejejejejejejejeje
                         *       itemEntorno sim = new itemEntorno(te1.nombrePregunta, te1.nombrePregunta, te1, new token("publico"), new List<int>(), tablaSimbolos);
                         *       elementoEntorno.insertarEntorno(sim);
                         *
                         *
                         *       ///ejecuto el metodo ejecutar final, es el que muestra las preguntas
                         *       //elementoEntorno.este.ejecutarMetodoFuncion(new token("ejecutarfinal"), new lstValores(), sim.valor.getObjeto().tablaEntorno.raiz);
                         *       //println("entorno de ejecutar final ===================================0");
                         *
                         *       // sim.valor.getObjeto().tablaEntorno.raiz.este.ejecutarMetodoFuncion(new token("ejecutarfinal"), new lstValores(), sim.valor.getObjeto().tablaEntorno.raiz);
                         *
                         *
                         *   }
                         * }
                         *
                         * if(te1.nombrePregunta.esPregunta)
                         * {
                         *
                         *   if (temp1.lstAtributos.listaAtributos.Count > 0)
                         *   {
                         *       String nombreToken = temp1.lstAtributos.listaAtributos[0].nombretoken;
                         *
                         *       if (nombreToken.Equals("valId"))
                         *       {
                         *           //ahora ya que revisar que se encuentre entre la lsita de preguntas.
                         *           //     elementoEntorno.este.cuerpoClase.ls
                         *           if (tablaSimbolos.esPregunta(temp1.lstAtributos.getToken(0).valLower))
                         *           {
                         *               //es pregunta
                         *               itemEntorno sim = new itemEntorno(te1.nombrePregunta, te1.nombrePregunta, te1, new token("publico"), new List<int>(), tablaSimbolos);
                         *               elementoEntorno.insertarEntorno(sim);
                         *
                         *           }
                         *
                         *       }
                         *
                         *   }
                         *
                         *
                         * }
                         */

                        return(te2);

                        //tengo que obtener el objeto de id_var_func
                    }
                }
                #endregion
            }

            else if (lstAtributos.listaAtributos.Count == 1)
            {
                if (hijos.Count > 0)

                /*
                 |----------------------------
                 | valId + LST_CORCHETES_VAL
                 |------------
                 | Lst_Corchtes tiene que retornar una lista de tipo entero
                 |
                 */
                {
                    #region reg2
                    token      nombreVar  = lstAtributos.getToken(0);
                    nodoModelo nodoLstCor = getNodo("LST_CORCHETES_VAL");
                    if (nodoLstCor != null)
                    {
                        _LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)nodoLstCor;
                        List <int>         listaEntero  = lstCorchetes.getLstInt(elementoEntorno, nombreVar);
                        String             item1        = lstAtributos.listaAtributos[0].nombretoken;
                        //mapeando el indice

                        if (item1.Equals("valId"))

                        {
                            return(getValIdCorchetes(lstAtributos.listaAtributos[0].tok, elementoEntorno, listaEntero));
                        }
                        else
                        {
                            println(" valId + LST_CORCHETES_VAL -> No viene val id");
                        }
                    }
                    #endregion
                }
                else

                /*
                 |----------------------------
                 | valId
                 */
                {
                    #region reg3
                    String item1 = lstAtributos.listaAtributos[0].nombretoken;

                    if (item1.Equals("valId"))

                    {
                        return(getValId(lstAtributos.listaAtributos[0].tok, elementoEntorno));
                    }
                    #endregion
                }
            }

            else if (lstAtributos.listaAtributos.Count == 3)
            {
                String item1 = lstAtributos.listaAtributos[0].nombretoken;
                String item2 = lstAtributos.listaAtributos[1].nombretoken;
                String item3 = lstAtributos.listaAtributos[2].nombretoken;

                if (item1.Equals("este") && item2.Equals(".") && item3.Equals("valId"))
                {
                    if (hijos.Count > 0)

                    /*
                     |----------------------------
                     |  tEste + sPunto + valId  + LST_CORCHETES_VAL
                     */
                    {
                        #region reg4
                        token      nombreVar  = lstAtributos.getToken(2);
                        nodoModelo nodoLstCor = getNodo("LST_CORCHETES_VAL");
                        if (nodoLstCor != null)
                        {
                            _LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)nodoLstCor;
                            List <int>         listaEntero  = lstCorchetes.getLstInt(elementoEntorno, nombreVar);
                            String             item11       = lstAtributos.listaAtributos[2].nombretoken;
                            //mapeando el indice

                            if (item11.Equals("valId"))

                            {
                                return(getValIdCorchetes(lstAtributos.listaAtributos[2].tok, elementoEntorno.este.tablaEntorno.raiz, listaEntero));
                            }
                            else
                            {
                                println(" tEste + sPunto + valId  + LST_CORCHETES_VAL -> No viene val id");
                            }
                        }
                        #endregion
                    }
                    else

                    /*
                     |----------------------------
                     |  tEste + sPunto + valId
                     */
                    {
                        #region cuerpo
                        String esteId = lstAtributos.listaAtributos[2].nombretoken;

                        if (esteId.Equals("valId"))

                        {
                            return(getValId(lstAtributos.listaAtributos[2].tok, elementoEntorno.este.tablaEntorno.raiz));
                        }
                        else
                        {
                            println("(tEste + sPunto + valId) No se encontró valId");
                        }

                        #endregion
                    }
                }
                if (item1.Equals("valId") && item2.Equals("(") && item3.Equals(")"))
                {
                    if (hijos.Count == 2)

                    /*
                     |----------------------------
                     |  valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL;
                     |------------------------
                     * Primero ejecuto el metodo que me tiene que retornar siempre dimension>0
                     * luego enviarle ese valor, para extraer lo que se quiere
                     */
                    {
                        #region cuerpo
                        if (hayErrores())
                        {
                            return(retorno);
                        }

                        String esteId = lstAtributos.listaAtributos[0].nombretoken;

                        if (esteId.Equals("valId"))

                        {
                            //esto es del metodo
                            nodoModelo nodoTemp               = getNodo("LST_VAL");
                            _LST_VAL   lstParametros          = (_LST_VAL)nodoTemp;
                            itemValor  itemValorRetornoMetodo = elementoEntorno.este.ejecutarMetodoFuncion(lstAtributos.getToken(0), lstParametros.getLstValores(elementoEntorno), elementoEntorno.este.tablaEntorno.raiz);

                            //esto es de la parte del arreglo
                            nodoModelo         nodoLstCorchetes = getNodo("LST_CORCHETES_VAL");
                            _LST_CORCHETES_VAL lstCorchetes     = (_LST_CORCHETES_VAL)nodoLstCorchetes;
                            List <int>         listaEntero      = lstCorchetes.getLstInt(elementoEntorno, lstAtributos.listaAtributos[0].tok);

                            if (itemValorRetornoMetodo.dimensiones.Count == listaEntero.Count)
                            //tienen la misma dimension
                            {
                                println("getValCorchetes");
                                return(getValCorchetes(lstAtributos.getToken(0), elementoEntorno, listaEntero, itemValorRetornoMetodo));
                            }
                            else
                            //no tienen la misma dimensión.
                            {
                                tablaSimbolos.tablaErrores.insertErrorSemantic("El metodo: " + lstAtributos.getToken(0).val + " no devuelve la misma cantidad de dimensiones que a las que se quiere acceder", lstAtributos.getToken(0));
                                return(retorno);
                            }
                        }
                        else
                        {
                            println("valId + sAbreParent + LST_VAL + sCierraParent; -> no viene valId");
                            return(retorno);
                        }


                        #endregion
                    }

                    if (hijos.Count == 1)
                    {
                        String nombreHijo = hijos[0].nombre;
                        if (nombreHijo.Equals("LST_CORCHETES_VAL"))

                        /*
                         |----------------------------
                         |  valId + sAbreParent + sCierraParent + LST_CORCHETES_VAL;
                         */
                        {
                            #region cuerpo
                            if (hayErrores())
                            {
                                return(retorno);
                            }

                            String esteId = lstAtributos.listaAtributos[0].nombretoken;

                            if (esteId.Equals("valId"))

                            {
                                //esto es del metodo
                                nodoModelo nodoTemp      = getNodo("LST_VAL");
                                lstValores sinParametros = new lstValores();

                                itemValor itemValorRetornoMetodo = elementoEntorno.este.ejecutarMetodoFuncion(lstAtributos.getToken(0), sinParametros, elementoEntorno.este.tablaEntorno.raiz);

                                //esto es de la parte del arreglo
                                nodoModelo         nodoLstCorchetes = getNodo("LST_CORCHETES_VAL");
                                _LST_CORCHETES_VAL lstCorchetes     = (_LST_CORCHETES_VAL)nodoLstCorchetes;
                                List <int>         listaEntero      = lstCorchetes.getLstInt(elementoEntorno, lstAtributos.listaAtributos[0].tok);

                                if (itemValorRetornoMetodo.dimensiones.Count == listaEntero.Count)
                                //tienen la misma dimension
                                {
                                    println("getValCorchetes");
                                    return(getValCorchetes(lstAtributos.getToken(0), elementoEntorno, listaEntero, itemValorRetornoMetodo));
                                }
                                else
                                //no tienen la misma dimensión.
                                {
                                    tablaSimbolos.tablaErrores.insertErrorSemantic("El metodo: " + lstAtributos.getToken(0).val + " no devuelve la misma cantidad de dimensiones que a las que se quiere acceder", lstAtributos.getToken(0));
                                    return(retorno);
                                }
                            }
                            else
                            {
                                println("valId + sAbreParent + LST_VAL + sCierraParent; -> no viene valId");
                                return(retorno);
                            }

                            #endregion
                        }
                        else if (nombreHijo.Equals("LST_VAL"))

                        /*
                         |----------------------------
                         |  valId + sAbreParent + LST_VAL + sCierraParent;
                         |-------------
                         | Esto es un metodo
                         | Desde aquí puedo llamar a las preguntas, y tiene mayor prioridad
                         | si me encuentro dentro de un entorno de nombre, formulario, o de nombre grupo
                         */
                        {
                            #region cuerpo
                            String esteId = lstAtributos.listaAtributos[0].nombretoken;


                            /*if (elementoEntorno.nombre.Equals("formulario") || elementoEntorno.nombre.Equals("grupo"))
                             *
                             * Esto es como el constructor nuevo pregunta()
                             *
                             * {
                             * }*/

                            //primero busco en las preguntas, luego en los metodos, jejejejeje
                            itemValor ret = crearPregunta(elementoEntorno);
                            if (ret != null)
                            {
                                //eso quiere decir que es una pregunta

                                ret.nombrePregunta            = lstAtributos.getToken(0);
                                ret.nombrePregunta.esPregunta = true;

                                itemEntorno sim = new itemEntorno(ret.nombrePregunta, ret.nombrePregunta, ret, new token("publico"), new List <int>(), tablaSimbolos);
                                elementoEntorno.insertarEntorno(sim);


                                return(ret);
                            }

                            //si no lo encuentro como pregunta, sigo la ejecución en busca de un metodo.
                            if (esteId.Equals("valId"))

                            {
                                nodoModelo nodoTemp      = getNodo("LST_VAL");
                                _LST_VAL   lstParametros = (_LST_VAL)nodoTemp;
                                return(elementoEntorno.este.ejecutarMetodoFuncion(lstAtributos.getToken(0), lstParametros.getLstValores(elementoEntorno), elementoEntorno.este.tablaEntorno.raiz));
                            }
                            else
                            {
                                println("valId + sAbreParent + LST_VAL + sCierraParent; -> no viene valId");
                            }

                            #endregion
                        }
                    }

                    if (hijos.Count == 0)

                    /*
                     |----------------------------
                     |  valId + sAbreParent +  sCierraParent;
                     |-------------
                     | Esto es un metodo sin parámetros
                     | hay que buscarlo entre la lista de metodos
                     */
                    {
                        #region cuerpo
                        String esteId = lstAtributos.listaAtributos[0].nombretoken;

                        if (esteId.Equals("valId"))

                        {
                            lstValores sinParametros = new lstValores();
                            return(elementoEntorno.este.ejecutarMetodoFuncion(lstAtributos.getToken(0), sinParametros, elementoEntorno.este.tablaEntorno.raiz));
                        }
                        else
                        {
                            println("valId + sAbreParent +  sCierraParent -> no viene valId");
                        }
                        #endregion
                    }
                }
            }
            else if (lstAtributos.listaAtributos.Count == 5)
            {
                String item1 = lstAtributos.listaAtributos[0].nombretoken;
                String item2 = lstAtributos.listaAtributos[1].nombretoken;
                String item3 = lstAtributos.listaAtributos[2].nombretoken;

                if (item1.Equals("este") && item2.Equals(".") && item3.Equals("valId"))
                {
                    if (hijos.Count == 2)

                    /*
                     |----------------------------
                     | tEste + sPunto + valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL;
                     */
                    {
                        #region cuerpo
                        if (hayErrores())
                        {
                            return(retorno);
                        }

                        String esteId = lstAtributos.listaAtributos[2].nombretoken;

                        if (esteId.Equals("valId"))

                        {
                            //esto es del metodo
                            nodoModelo nodoTemp               = getNodo("LST_VAL");
                            _LST_VAL   lstParametros          = (_LST_VAL)nodoTemp;
                            itemValor  itemValorRetornoMetodo = elementoEntorno.este.ejecutarMetodoFuncion(lstAtributos.getToken(2), lstParametros.getLstValores(elementoEntorno), elementoEntorno.este.tablaEntorno.raiz);

                            //esto es de la parte del arreglo
                            nodoModelo         nodoLstCorchetes = getNodo("LST_CORCHETES_VAL");
                            _LST_CORCHETES_VAL lstCorchetes     = (_LST_CORCHETES_VAL)nodoLstCorchetes;
                            List <int>         listaEntero      = lstCorchetes.getLstInt(elementoEntorno, lstAtributos.listaAtributos[2].tok);

                            if (itemValorRetornoMetodo.dimensiones.Count == listaEntero.Count)
                            //tienen la misma dimension
                            {
                                println("getValCorchetes");
                                return(getValCorchetes(lstAtributos.getToken(2), elementoEntorno, listaEntero, itemValorRetornoMetodo));
                            }
                            else
                            //no tienen la misma dimensión.
                            {
                                tablaSimbolos.tablaErrores.insertErrorSemantic("El metodo: " + lstAtributos.getToken(2).val + " no devuelve la misma cantidad de dimensiones que a las que se quiere acceder", lstAtributos.getToken(2));
                                return(retorno);
                            }
                        }
                        else
                        {
                            println("tEste + sPunto + valId + sAbreParent + LST_VAL + sCierraParent + LST_CORCHETES_VAL;");
                        }
                        #endregion
                    }
                    else if (hijos.Count == 1)
                    {
                        if (hijos[0].nombre.Equals("LST_CORCHETES_VAL"))

                        /*
                         |----------------------------
                         | tEste + sPunto + valId + sAbreParent + sCierraParent + LST_CORCHETES_VAL;
                         */
                        {
                            #region cuerpo
                            if (hayErrores())
                            {
                                return(retorno);
                            }

                            String esteId = lstAtributos.listaAtributos[2].nombretoken;

                            if (esteId.Equals("valId"))

                            {
                                //esto es del metodo
                                nodoModelo nodoTemp      = getNodo("LST_VAL");
                                lstValores sinParametros = new lstValores();

                                itemValor itemValorRetornoMetodo = elementoEntorno.este.ejecutarMetodoFuncion(lstAtributos.getToken(2), sinParametros, elementoEntorno.este.tablaEntorno.raiz);

                                //esto es de la parte del arreglo
                                nodoModelo         nodoLstCorchetes = getNodo("LST_CORCHETES_VAL");
                                _LST_CORCHETES_VAL lstCorchetes     = (_LST_CORCHETES_VAL)nodoLstCorchetes;
                                List <int>         listaEntero      = lstCorchetes.getLstInt(elementoEntorno, lstAtributos.listaAtributos[2].tok);

                                if (itemValorRetornoMetodo.dimensiones.Count == listaEntero.Count)
                                //tienen la misma dimension
                                {
                                    println("getValCorchetes");
                                    return(getValCorchetes(lstAtributos.getToken(2), elementoEntorno, listaEntero, itemValorRetornoMetodo));
                                }
                                else
                                //no tienen la misma dimensión.
                                {
                                    tablaSimbolos.tablaErrores.insertErrorSemantic("El metodo: " + lstAtributos.getToken(2).val + " no devuelve la misma cantidad de dimensiones que a las que se quiere acceder", lstAtributos.getToken(2));
                                    return(retorno);
                                }
                            }
                            else
                            {
                                println("tEste + sPunto + valId + sAbreParent + sCierraParent + LST_CORCHETES_VAL");
                            }
                            #endregion
                        }
                        else if (hijos[0].nombre.Equals("LST_VAL"))

                        /*
                         |----------------------------
                         | tEste + sPunto + valId + sAbreParent + LST_VAL + sCierraParent
                         */
                        {
                            #region cuerpo
                            print("tEste + sPunto + valId + sAbreParent + LST_VAL + sCierraParent");
                            String esteId = lstAtributos.listaAtributos[2].nombretoken;

                            if (esteId.Equals("valId"))

                            {
                                nodoModelo nodoTemp      = getNodo("LST_VAL");
                                _LST_VAL   lstParametros = (_LST_VAL)nodoTemp;
                                return(elementoEntorno.este.ejecutarMetodoFuncion(lstAtributos.getToken(2), lstParametros.getLstValores(elementoEntorno), elementoEntorno.este.tablaEntorno.raiz));
                            }
                            else
                            {
                                println("valId + sAbreParent + LST_VAL + sCierraParent; -> no viene valId");
                            }
                        }
                        #endregion
                    }
                    else if (hijos.Count == 0)

                    /*
                     |----------------------------
                     | tEste + sPunto + valId + sAbreParent  + sCierraParent
                     */
                    {
                        #region cuerpo
                        print("tEste + sPunto + valId + sAbreParent  + sCierraParent");
                        String esteId = lstAtributos.listaAtributos[2].nombretoken;

                        if (esteId.Equals("valId"))

                        {
                            nodoModelo nodoTemp      = getNodo("LST_VAL");
                            lstValores sinParametros = new lstValores();
                            return(elementoEntorno.este.ejecutarMetodoFuncion(lstAtributos.getToken(2), sinParametros, elementoEntorno.este.tablaEntorno.raiz));
                        }
                        else
                        {
                            println("valId + sAbreParent + LST_VAL + sCierraParent; -> no viene valId");
                        }
                        #endregion
                    }
                }
            }


            return(retorno);
        }