public objetoClase este; //sirve para guardar el puntero de la misma clase

        public elementoEntorno(elementoEntorno anterior, tablaSimbolos tabla, String nombre, objetoClase este)
        {
            this.este     = este;
            this.nombre   = nombre;
            this.tabla    = tabla;
            this.anterior = anterior;
            lstEntorno    = new Dictionary <string, itemEntorno>();
        }
Example #2
0
        public void ejecutandoClase(elementoClase clase)
        {
            ///hay que crear una instancia al objeto
            println("Ejecutando el main de " + clase.nombreClase.valLower);
            objetoClase ObjClase = new objetoClase(clase, this);

            ObjClase.ejecutarGlobales();
            ObjClase.ejecutarPrincipal();
            //ObjClase.imprimirTablaEntornos();
        }
Example #3
0
        public itemValor getValor(elementoEntorno elementoEntor, token tipo)
        {
            itemValor retorno = new itemValor();

            retorno.setTypeNulo();


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

            if (lstAtributos.listaAtributos.Count == 4)
            {
                String item1 = lstAtributos.listaAtributos[0].nombretoken;
                String item2 = lstAtributos.listaAtributos[1].nombretoken;
                if (item1.Equals("nuevo") && item2.Equals("valId"))

                /*
                 |----------------------------
                 |   tNuevo + valId + sAbreParent + LST_VAL + sCierraParent
                 */
                {
                    /*
                     |--------------------------------------------------------------------------
                     | nuevo Objeto()
                     | nuevo valId()
                     |--------------------------------------------------------------------------
                     | tNuevo + valId + sAbreParent + LST_VAL + sCierraParent
                     | tengo que crear una nueva clase y cargar los valores globales con sus metdos, funciones, y validar constructores
                     | hay que buscar la clase primero
                     |
                     */

                    //token tokId = lstAtributos.getToken(1);
                    token         tokInstancia = lstAtributos.getToken(1);
                    elementoClase temp         = tablaSimbolos.getClase(tokInstancia);
                    if (temp != null)
                    {
                        objetoClase ObjClase    = new objetoClase(temp, tablaSimbolos);
                        lstValores  lstValores2 = new lstValores();
                        //ahora tengo que llamar al constructor, pero digamos que no tiene, jejejeje


                        if (hijos.Count > 0)
                        {
                            nodoModelo hijo   = hijos[0];
                            _LST_VAL   lstval = (_LST_VAL)hijo;
                            lstValores2 = lstval.getLstValores(elementoEntor);
                            //me tiene que devolver una lista de valores,
                        }

                        ObjClase.ejecutarGlobales(); //cargando sus valores globales
                                                     // jlk
                        ObjClase.ejecutarConstructor(lstAtributos.getToken(1), 0, lstValores2, ObjClase.tablaEntorno.raiz);
                        //println("ejecutando constructor de la claes, new objeto()");

                        retorno.setValue(ObjClase, lstAtributos.getToken(1).valLower);
                        retorno.setTypeObjeto(tokInstancia.valLower);
                        //println("Es un objeto");

                        return(retorno);
                    }
                    else
                    {
                        tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede  instanaciar la clase:" + tokInstancia.valLower + ", para crear el objeto, debido a que no se existe la clase ", tokInstancia);
                    }


                    return(retorno);
                }
            }

            if (hijos.Count > 0)
            {
                nodoModelo hijo = hijos[0];

                switch (hijo.nombre)
                {
                case "PREGUNTA_NATIVA":

                    _PREGUNTA_NATIVA preg = (_PREGUNTA_NATIVA)hijo;

                    return(preg.getValor(elementoEntor));


                case "TIPO":
                    if (hayErrores())
                    {
                        return(retorno);
                    }

                    /*
                     |--------------------------------------------------------------------------
                     | ARREGLO
                     |--------------------------------------------------------------------------
                     | Hay que mapear las variables para inicializar el array valores de item
                     | Estoy definiendo las dimensiones del arreglo
                     | tNuevo + TIPO + LST_CORCHETES_VAL
                     |
                     |
                     | String[][] hola = new String[3][2];
                     |
                     | String[] jejej = new String[12];
                     | int[][] jeje = { new int[12], { 2, 2 } };
                     |
                     | int[][][] numeros = {{3,3,3},{2,2,2},{1,1,1}, {4,4,4},{5,5,5},{6,6,6}};
                     | hola = jejej;*/
                    nodoModelo tempTipo = getNodo("TIPO");
                    _TIPO      nodoTipo = (_TIPO)tempTipo;
                    retorno.setType(nodoTipo.getTipo().valLower);

                    token      item1 = lstAtributos.listaAtributos[0].tok;
                    nodoModelo temp1 = getNodo("LST_CORCHETES_VAL");
                    if (temp1 != null)
                    {
                        _LST_CORCHETES_VAL lstVal     = (_LST_CORCHETES_VAL)temp1;
                        List <int>         tempLstInt = lstVal.getLstInt(elementoEntor, item1);

                        int dimensionMaxima = 1;
                        foreach (int elemento in tempLstInt)
                        {
                            // println("dimen: " + elemento);
                            if (elemento != 0)
                            {
                                dimensionMaxima = dimensionMaxima * elemento;
                            }
                            else
                            {
                                tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede inicializar una matriz con tamaño 0", item1);
                            }
                        }


                        //llenando la lista de nulos


                        Dictionary <int, itemValor> diccionario = new Dictionary <int, itemValor>();

                        for (int i = 0; i < dimensionMaxima; i++)
                        {
                            diccionario.Add(i, new itemValor());
                        }



                        retorno.setArrayTipo(tempLstInt, diccionario, tipo.valLower);



                        //println("La dimensión mapeada -> indice máximo es " + retorno.arrayValores.Count);
                        //tengo que mapear
                        //  sf
                    }



                    //println(itEntorno.nombre.valLower + "-> tNuevo + TIPO + LST_CORCHETES_VAL");
                    return(retorno);

                case "LST_LLAVES_VAL":

                    /*
                     |--------------------------------------------------------------------------
                     | ARREGLO
                     |--------------------------------------------------------------------------
                     | Le estoy enviando directamente los valores al arreglo
                     | LST_LLAVES_VAL esto retorna=Dictionary<int, itemValor>
                     |
                     */
                    nodoModelo      tempLstLlaves = getNodo("LST_LLAVES_VAL");
                    _LST_LLAVES_VAL nodoLstLlaves = (_LST_LLAVES_VAL)tempLstLlaves;


                    nodoLstLlaves.getArray(tipo, elementoEntor);
                    int arrayLengthMapeado = getDimensionMapeada(nodoLstLlaves.lstDimensiones, tipo);
                    if (arrayLengthMapeado == nodoLstLlaves.diccionario.Count)
                    //se puede agregar correctamente
                    {
                        itemValor retorno2 = new itemValor();
                        retorno2.setType(tipo.valLower);
                        retorno2.arrayValores = nodoLstLlaves.diccionario;
                        retorno2.dimensiones  = nodoLstLlaves.lstDimensiones;
                        return(retorno2);
                    }
                    else
                    {
                        println("Hay problema en las dimensiones del arreglo" + tipo.linea);
                    }



                    return(retorno);

                case "E":

                    /*
                     |--------------------------------------------------------------------------
                     | E
                     |--------------------------------------------------------------------------
                     */
                    _E ope = (_E)hijo;
                    return(ope.getValor(elementoEntor));

                default:
                    println(hijo.nombre + "->No se reconoció la producción :(");
                    return(retorno);
                }
            }
            else

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

                if (item1.Equals("tEste"))
                {
                    itemValor it = new itemValor();
                    it.setTypeObjeto(elementoEntor.este.cuerpoClase.nombreClase.valLower);
                    it.setValue(elementoEntor.este, elementoEntor.este.cuerpoClase.nombreClase.valLower);

                    return(it);
                }
                else
                {
                    /*
                     |--------------------------------------------------------------------------
                     | return nulo
                     |--------------------------------------------------------------------------
                     | tNulo
                     */

                    return(retorno);
                }
            }
        }
        public itemValor crearPregunta(elementoEntorno elementoEntor)

        /*
         |--------------------------------------------------------------------------
         |  valId + sAbreParent + LST_VAL + sCierraParent;
         |  tNuevo + valId + sAbreParent + LST_VAL + sCierraParent
         |--------------------------------------------------------------------------
         |
         | tengo que crear una nueva clase y cargar los valores globales con sus metdos, funciones, y validar constructores
         | hay que buscar la clase primero
         |
         */
        {
            itemValor retorno = new itemValor();

            retorno.setTypeVacio();


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


            //token tokId = lstAtributos.getToken(1);
            token         tokInstancia = lstAtributos.getToken(0);
            elementoClase temp         = tablaSimbolos.getPregunta(tokInstancia);

            if (temp != null)
            {
                objetoClase ObjClase    = new objetoClase(temp, tablaSimbolos);
                lstValores  lstValores2 = new lstValores();
                //ahora tengo que llamar al constructor, pero digamos que no tiene, jejejeje


                if (hijos.Count > 0)
                {
                    nodoModelo hijo   = hijos[0];
                    _LST_VAL   lstval = (_LST_VAL)hijo;
                    lstValores2 = lstval.getLstValores(elementoEntor);
                    //me tiene que devolver una lista de valores,
                }
                ObjClase.ejecutarConstructor(lstAtributos.getToken(0), 0, lstValores2, ObjClase.tablaEntorno.raiz);
                ObjClase.ejecutarGlobales(); //cargando sus valores globales
                                             // jlk



                // println("========================00     imprimir lo que contiene la pregunta   00 ==================");
                // elementoEntor.imprimir();
                //println("ejecutando constructor de la claes, new objeto()");

                retorno.setValue(ObjClase, lstAtributos.getToken(0).valLower);
                retorno.setTypeObjeto(tokInstancia.valLower);
                //println("Es un objeto");
                return(retorno);
            }
            else
            {
                return(null);
            }
        }
        /*
         |-------------------------------------------------------------------------------------------------------------------
         | EJECUCIÓN FINAL
         |-------------------------------------------------------------------------------------------------------------------
         | elementoEntorno,es el ambito actual
         | itemValor es el objeto donde voy a seguir buscandos
         | solo puedo recibir item de tipo objeto
         */

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

            retorno.setTypeVacio();



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


            if (item.isTypeObjeto())
            {
                if (lstAtributos.listaAtributos.Count == 2)
                {
                    if (hijos.Count > 0)

                    /*
                     |----------------------------
                     | sPunto + valId + LST_CORCHETES_VAL
                     */
                    {
                        token      nombreVar  = lstAtributos.getToken(1);
                        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[1].nombretoken;
                            //mapeando el indice

                            if (item1.Equals("valId"))

                            {
                                objetoClase tempObjeto = item.getObjeto();

                                if (tempObjeto != null)
                                {
                                    return(getValIdCorchetes(lstAtributos.listaAtributos[1].tok, tempObjeto.tablaEntorno.raiz, listaEntero));
                                    //return getValId(lstAtributos.listaAtributos[1].tok, tempObjeto.tablaEntorno.raiz);
                                }
                                else
                                {
                                    tablaSimbolos.tablaErrores.insertErrorSemantic("No se pudo parsear el objeto", lstAtributos.listaAtributos[1].tok);
                                    return(retorno);
                                }
                            }
                            else
                            {
                                println("sPunto + valId + LST_CORCHETES_VAL -> No viene val id");
                            }
                        }
                    }
                    else

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

                        if (item1.Equals("valId"))

                        {
                            objetoClase tempObjeto = item.getObjeto();

                            if (tempObjeto != null)
                            {
                                return(getValId(lstAtributos.listaAtributos[1].tok, tempObjeto.tablaEntorno.raiz));
                            }
                            else
                            {
                                tablaSimbolos.tablaErrores.insertErrorSemantic("No se pudo parsear el objeto", lstAtributos.listaAtributos[1].tok);
                                return(retorno);
                            }
                        }
                    }
                }
                else if (lstAtributos.listaAtributos.Count == 4)
                {
                    if (hijos.Count == 2)

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

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

                        if (esteId.Equals("valId"))

                        {
                            objetoClase tempObjeto = item.getObjeto();


                            //esto es del metodo
                            nodoModelo nodoTemp               = getNodo("LST_VAL");
                            _LST_VAL   lstParametros          = (_LST_VAL)nodoTemp;
                            itemValor  itemValorRetornoMetodo = tempObjeto.ejecutarMetodoFuncion(lstAtributos.getToken(1), lstParametros.getLstValores(elementoEntorno), tempObjeto.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[1].tok);

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

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

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

                            if (esteId.Equals("valId"))

                            {
                                objetoClase tempObjeto = item.getObjeto();


                                //esto es del metodo
                                nodoModelo nodoTemp      = getNodo("LST_VAL");
                                lstValores sinParametros = new lstValores();
                                //elementoEntorno.este.tablaEntorno.raiz
                                itemValor itemValorRetornoMetodo = tempObjeto.ejecutarMetodoFuncion(lstAtributos.getToken(1), sinParametros, tempObjeto.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[1].tok);

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

                        /*
                         |----------------------------
                         | sPunto + valId + sAbreParent + LST_VAL + sCierraParent
                         */
                        {
                            #region cuerpo
                            String esteId = lstAtributos.listaAtributos[1].nombretoken;

                            objetoClase tempObjeto = item.getObjeto();

                            if (esteId.Equals("valId"))

                            {
                                nodoModelo nodoTemp      = getNodo("LST_VAL");
                                _LST_VAL   lstParametros = (_LST_VAL)nodoTemp;
                                itemValor  reto          = tempObjeto.ejecutarMetodoFuncion(lstAtributos.getToken(1), lstParametros.getLstValores(elementoEntorno), tempObjeto.tablaEntorno.raiz);
                                reto.nombrePregunta = item.nombrePregunta;

                                return(reto);
                            }
                            else
                            {
                                println("sPunto + valId + sAbreParent + LST_VAL + sCierraParent ");
                            }

                            #endregion
                        }
                    }
                    else if (hijos.Count == 0)

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

                        objetoClase tempObjeto = item.getObjeto();


                        println("el nombre del objeto es " + tempObjeto.cuerpoClase.nombreClase.val);
                        if (esteId.Equals("valId"))

                        {
                            nodoModelo nodoTemp      = getNodo("LST_VAL");
                            lstValores sinParametros = new lstValores();
                            return(tempObjeto.ejecutarMetodoFuncion(lstAtributos.getToken(1), sinParametros, tempObjeto.tablaEntorno.raiz));
                        }
                        else
                        {
                            println("sPunto + valId + sAbreParent + sCierraParent ");
                        }

                        #endregion
                    }
                }
            }
            else
            {
                tablaSimbolos.tablaErrores.insertErrorSyntax("[objeto.objeto]El atributo/arreglo/metodo al que se quiere acceder no es de tipo objeto", new token());
            }

            return(retorno);
        }
Example #6
0
        public itemEntorno getDestino(elementoEntorno elementoEntorno, itemValor item)
        {
            itemEntorno retorno = null;

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



            if (item.isTypeObjeto())
            {
                if (lstAtributos.listaAtributos.Count == 2)
                {
                    if (hijos.Count > 0)

                    /*
                     |----------------------------
                     | sPunto + valId + LST_CORCHETES_VAL
                     */
                    {
                        objetoClase tempObjeto = item.getObjeto();

                        String item1     = lstAtributos.listaAtributos[1].nombretoken;
                        token  nombreVar = lstAtributos.getToken(1);
                        if (item1.Equals("valId"))
                        {
                            _LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)getNodo("LST_CORCHETES_VAL");
                            return(getEntornoId(lstAtributos.listaAtributos[1].tok, tempObjeto.tablaEntorno.raiz, lstCorchetes.getLstInt(elementoEntorno, nombreVar)));
                        }
                    }
                    else

                    /*
                     |----------------------------
                     | sPunto + valId
                     */
                    {
                        objetoClase tempObjeto = item.getObjeto();

                        String item1     = lstAtributos.listaAtributos[1].nombretoken;
                        token  nombreVar = lstAtributos.getToken(1);
                        if (item1.Equals("valId"))
                        {
                            _LST_CORCHETES_VAL lstCorchetes = (_LST_CORCHETES_VAL)getNodo("LST_CORCHETES_VAL");
                            return(getEntornoId(lstAtributos.listaAtributos[1].tok, tempObjeto.tablaEntorno.raiz, new List <int>()));
                        }
                    }
                }
                else if (lstAtributos.listaAtributos.Count == 4)
                {
                    if (hijos.Count == 2)

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

                        /*
                         |----------------------------
                         | sPunto + valId + sAbreParent + LST_VAL + sCierraParent
                         */
                        {
                            tablaSimbolos.tablaErrores.insertErrorSemantic("No se le puede asignar un valor a la expresión metodo" + lstAtributos.getToken(1).val + "()", lstAtributos.getToken(1));
                        }
                    }
                }
            }
            else
            {
                tablaSimbolos.tablaErrores.insertErrorSyntax("[objeto.objeto]El atributo/arreglo/metodo al que se quiere acceder no es de tipo objeto", new token());
            }

            return(null);
        }
 public tablaEntornos(tablaSimbolos tabla, objetoClase este)
 {
     raiz = new elementoEntorno(null, tabla, "global", este);
 }