public Procedimiento guardarProcedimiento(ParseTreeNode nodo, bool sobrescribir)
        {
            // VISIBILIDAD TPROC id CMETODO
            // TPROC id CMETODO
            /*** CMETODO -> PARAMETROS SENTENCIAS ***/
            Procedimiento nuevo;
            int           vis    = (int)Simbolo.Visibilidad.PUBLICO;
            int           inicio = 0;

            if (nodo.ChildNodes.Count == 4)
            {
                vis = Simbolo.getVisibilidad(nodo.ChildNodes[inicio].ChildNodes[0].Token.Text);
                inicio++;
            }
            ParseTreeNode   tproc      = nodo.ChildNodes[inicio];
            String          id         = nodo.ChildNodes[inicio + 1].Token.Text;
            ParseTreeNode   cmetodo    = nodo.ChildNodes[inicio + 2];
            int             tipo       = Simbolo.getTipo(tproc.ChildNodes[0].Token.Text);
            List <Atributo> parametros = guardarParametros(cmetodo.ChildNodes[0]);

            nuevo = new Procedimiento(id, tipo, vis, parametros, cmetodo.ChildNodes[1], sobrescribir,
                                      nodo.ChildNodes[inicio + 1].Token.Location.Line,
                                      nodo.ChildNodes[inicio + 1].Token.Location.Column);
            if (tproc.ChildNodes[1].ChildNodes.Count > 0)
            {
                nuevo.agregarArreglo(tproc.ChildNodes[1]);
            }
            return(nuevo);
        }
Example #2
0
        public void evaluarDeclaracion(ParseTreeNode declara)
        {
            /* OLC++
             * DECLARACION.Rule = TIPO + LISTA_IDS + asignarR
             | TIPO + LISTA_IDS + DARREGLO -> INDICES (ARREGLO)?
             | TIPO + LISTA_IDS;
             * Tree
             * DECLARACION.Rule = TIPO + LISTA_IDS + asignarR
             | TIPO + LISTA_IDS
             | TIPO + NARREGLO -> id + INDICES;
             */
            int           tipo = Simbolo.getTipo(declara.ChildNodes[0].Token.Text);
            ParseTreeNode ids  = declara.ChildNodes[1];

            if (ids.Term.Name.Equals("NARREGLO"))
            {
                Atributo variable = new Atributo(ids.ChildNodes[0].Token.Text, tipo,
                                                 ids.ChildNodes[0].Token.Location.Line,
                                                 ids.ChildNodes[0].Token.Location.Column);
                variable.asignarArreglo(ids.ChildNodes[1]);
                if (tipo == (int)Simbolo.Tipo.CLASE)
                {
                    variable.asignarClase(declara.ChildNodes[0].Token.Text);
                }
                agregarVariable(variable);
            }
            else
            {
                foreach (ParseTreeNode var in ids.ChildNodes)
                {
                    Atributo a = new Atributo(var.Token.Text, tipo,
                                              var.Token.Location.Line, var.Token.Location.Column);
                    if (tipo == (int)Simbolo.Tipo.CLASE)
                    {
                        a.asignarClase(declara.ChildNodes[0].Token.Text);
                    }
                    if (declara.ChildNodes.Count == 3)
                    {
                        if (declara.ChildNodes[2].Term.Name.Equals("DARREGLO"))
                        {
                            a.asignarArreglo(declara.ChildNodes[2].ChildNodes[0]);
                            if (declara.ChildNodes[2].ChildNodes.Count == 2)
                            {
                                a.asignarValor(declara.ChildNodes[2].ChildNodes[1]);
                            }
                        }
                        else
                        {
                            a.asignarValor(declara.ChildNodes[2]);
                        }
                    }
                    agregarVariable(a);
                }
            }
        }
 public static void declararAsignarC3D(ParseTreeNode declaracion)
 {
     /* OLC++
      * DECLARACION.Rule = TIPO + LISTA_IDS + asignarR *---*
      | TIPO + LISTA_IDS + DARREGLO -> INDICES (ARREGLO)? *---*
      | TIPO + LISTA_IDS;
      * Tree
      * DECLARACION.Rule = TIPO + LISTA_IDS + asignarR *---*
      | TIPO + LISTA_IDS
      | TIPO + NARREGLO;
      */
     if (declaracion.ChildNodes.Count == 3)
     {
         int           tipo = Simbolo.getTipo(declaracion.ChildNodes[0].Token.Text);
         ParseTreeNode ids  = declaracion.ChildNodes[1];
         foreach (ParseTreeNode id in ids.ChildNodes)
         {
             if (declaracion.ChildNodes[2].Term.Name.Equals("DARREGLO"))
             {
                 ParseTreeNode darr = declaracion.ChildNodes[2];
                 // Guardar espacio
                 if (darr.ChildNodes.Count == 2)
                 {
                     // DARREGLO -> INDICES ARREGLO
                     Arreglo.guardarC3D(id.Token.Text, darr.ChildNodes[1], Acceso.Tipo.NINGUNO);
                 }
                 else
                 {
                     Arreglo.guardarC3D(id.Token.Text, null, Acceso.Tipo.NINGUNO);
                 }
             }
             else
             {
                 // EXP
                 Acceso.actual = null;
                 Nodo exp  = Expresion.expresionC3D(declaracion.ChildNodes[2]);
                 Nodo nodo = Acceso.generarC3DID(id.Token.Text, Acceso.Tipo.NINGUNO,
                                                 "P", "Stack");
                 // Asignar la expresion
                 GeneradorC3D.instrucciones.Add(new C3D((int)C3D.TipoC3D.VALOR,
                                                        nodo.estructura, nodo.referencia, exp.cadena));
             }
         }
     }
     else
     {
         // 2 hijos
         if (declaracion.ChildNodes[1].Term.Name.Equals("NARREGLO"))
         {
             ParseTreeNode id = declaracion.ChildNodes[1].ChildNodes[0];
             Arreglo.guardarC3D(id.Token.Text, null, Acceso.Tipo.NINGUNO);
         }
     }
 }
        private void btnAgregarProcedimiento_Click(object sender, EventArgs e)
        {
            // Guardar datos de procedimiento
            int    vis        = Simbolo.getVisibilidad(visibilidad.SelectedItem.ToString().ToLower());
            String stipo      = tipo.SelectedItem.ToString().ToLower();
            int    tipo_valor = Simbolo.getTipo(stipo);
            String nombre     = txtNombre.Text;

            // Guardar el procedimiento en la lista de procedimientos
            listProcedimientos.Items.Add(getValor(nombre, vis) + "() : " + stipo);
            // Guardar el procedimiento en la clase
            clase.agregarProcedimiento(new Procedimiento(nombre, tipo_valor, vis, null, null, false, listProcedimientos.Items.Count, 0));
            // Limpiar
            visibilidad.ResetText();
            tipo.ResetText();
            txtNombre.Text = "";
        }
Example #5
0
        public List <Atributo> guardarParametros(ParseTreeNode nodo)
        {
            List <Atributo> parametros = new List <Atributo>();

            foreach (ParseTreeNode pa in nodo.ChildNodes)
            {
                // PARAMETRO -> TIPO NARREGLO -> id INDICES
                int      tipo      = Simbolo.getTipo(pa.ChildNodes[0].Token.Text);
                Atributo parametro = new Atributo(pa.ChildNodes[1].Token.Text, tipo,
                                                  pa.ChildNodes[1].Token.Location.Line,
                                                  pa.ChildNodes[1].Token.Location.Column);
                if (tipo == (int)Simbolo.Tipo.CLASE)
                {
                    parametro.asignarClase(pa.ChildNodes[0].ChildNodes[0].Token.Text);
                }
                if (pa.ChildNodes[2].ChildNodes.Count > 0)
                {
                    parametro.asignarArreglo(pa.ChildNodes[2]);
                }
                parametros.Add(parametro);
            }
            return(parametros);
        }
Example #6
0
        public Procedimiento guardarProcedimiento(ParseTreeNode nodo)
        {
            /*
             * METODO -> sobreescribir VISIBILIDAD TPROC id LISTA_PARAMETROS BLOQUE
             | VISIBILIDAD TPROC id LISTA_PARAMETROS BLOQUE
             | sobreescribir TPROC id LISTA_PARAMETROS BLOQUE
             | TPROC id LISTA_PARAMETROS BLOQUE
             */
            List <Atributo> parametros;

            if (nodo.ChildNodes.Count == 6)
            {
                // METODO -> sobreescribir VISIBILIDAD TPROC id LISTA_PARAMETROS BLOQUE
                parametros = guardarParametros(nodo.ChildNodes[4]);
                String id  = nodo.ChildNodes[3].Token.Text;
                int    vis = Simbolo.getVisibilidad(nodo.ChildNodes[1].ChildNodes[0].Token.Text);
                if (nodo.ChildNodes[2].ChildNodes.Count == 3)
                {
                    int           tipo = Simbolo.getTipo(nodo.ChildNodes[2].ChildNodes[1].Token.Text);
                    Procedimiento proc = new Procedimiento(id, tipo, vis,
                                                           parametros, nodo.ChildNodes[5].ChildNodes[0], true,
                                                           nodo.ChildNodes[3].Token.Location.Line,
                                                           nodo.ChildNodes[3].Token.Location.Column);
                    if (tipo == (int)Simbolo.Tipo.CLASE)
                    {
                        proc.agregarClase(nodo.ChildNodes[2].ChildNodes[1].Token.Text);
                    }
                    if (nodo.ChildNodes[2].ChildNodes[2].ChildNodes.Count > 0)
                    {
                        proc.agregarArreglo(nodo.ChildNodes[2].ChildNodes[2]);
                    }
                    return(proc);
                }
                else
                {
                    return(new Procedimiento(id, (int)Simbolo.Tipo.VACIO, vis, parametros,
                                             nodo.ChildNodes[5].ChildNodes[0], true,
                                             nodo.ChildNodes[3].Token.Location.Line,
                                             nodo.ChildNodes[3].Token.Location.Column));
                }
            }
            else if (nodo.ChildNodes.Count == 5)
            {
                /*
                 * METODO -> VISIBILIDAD TPROC id LISTA_PARAMETROS BLOQUE
                 | sobreescribir TPROC id LISTA_PARAMETROS BLOQUE
                 */
                parametros = guardarParametros(nodo.ChildNodes[3]);
                String id = nodo.ChildNodes[2].Token.Text;
                if (nodo.ChildNodes[0].Term.Name.Equals("VISIBILIDAD"))
                {
                    int vis = Simbolo.getVisibilidad(nodo.ChildNodes[0].ChildNodes[0].Token.Text);
                    if (nodo.ChildNodes[2].ChildNodes.Count == 3)
                    {
                        int           tipo = Simbolo.getTipo(nodo.ChildNodes[2].ChildNodes[1].Token.Text);
                        Procedimiento proc = new Procedimiento(id, tipo, vis,
                                                               parametros, nodo.ChildNodes[4].ChildNodes[0], false,
                                                               nodo.ChildNodes[2].Token.Location.Line,
                                                               nodo.ChildNodes[2].Token.Location.Column);
                        if (tipo == (int)Simbolo.Tipo.CLASE)
                        {
                            proc.agregarClase(nodo.ChildNodes[2].ChildNodes[1].Token.Text);
                        }
                        if (nodo.ChildNodes[2].ChildNodes[2].ChildNodes.Count > 0)
                        {
                            proc.agregarArreglo(nodo.ChildNodes[2].ChildNodes[2]);
                        }
                        return(proc);
                    }
                    else
                    {
                        return(new Procedimiento(id, (int)Simbolo.Tipo.VACIO, vis, parametros,
                                                 nodo.ChildNodes[4].ChildNodes[0], false,
                                                 nodo.ChildNodes[2].Token.Location.Line,
                                                 nodo.ChildNodes[2].Token.Location.Column));
                    }
                }
                else
                {
                    if (nodo.ChildNodes[2].ChildNodes.Count == 3)
                    {
                        int           tipo = Simbolo.getTipo(nodo.ChildNodes[2].ChildNodes[1].Token.Text);
                        Procedimiento proc = new Procedimiento(id, tipo,
                                                               parametros, nodo.ChildNodes[4].ChildNodes[0], true,
                                                               nodo.ChildNodes[2].Token.Location.Line,
                                                               nodo.ChildNodes[2].Token.Location.Column);
                        if (tipo == (int)Simbolo.Tipo.CLASE)
                        {
                            proc.agregarClase(nodo.ChildNodes[2].ChildNodes[1].Token.Text);
                        }
                        if (nodo.ChildNodes[2].ChildNodes[2].ChildNodes.Count > 0)
                        {
                            proc.agregarArreglo(nodo.ChildNodes[2].ChildNodes[2]);
                        }
                        return(proc);
                    }
                    else
                    {
                        return(new Procedimiento(id, (int)Simbolo.Tipo.VACIO, parametros,
                                                 nodo.ChildNodes[4].ChildNodes[0], true,
                                                 nodo.ChildNodes[2].Token.Location.Line,
                                                 nodo.ChildNodes[2].Token.Location.Column));
                    }
                }
            }
            else
            {
                // METODO -> TPROC id LISTA_PARAMETROS BLOQUE
                parametros = guardarParametros(nodo.ChildNodes[2]);
                String id = nodo.ChildNodes[1].Token.Text;
                if (nodo.ChildNodes[0].ChildNodes.Count == 3)
                {
                    int           tipo = Simbolo.getTipo(nodo.ChildNodes[0].ChildNodes[1].Token.Text);
                    Procedimiento proc = new Procedimiento(id, tipo,
                                                           parametros, nodo.ChildNodes[3].ChildNodes[0], false,
                                                           nodo.ChildNodes[1].Token.Location.Line,
                                                           nodo.ChildNodes[1].Token.Location.Column);
                    if (tipo == (int)Simbolo.Tipo.CLASE)
                    {
                        proc.agregarClase(nodo.ChildNodes[0].ChildNodes[1].Token.Text);
                    }
                    if (nodo.ChildNodes[0].ChildNodes[2].ChildNodes.Count > 0)
                    {
                        proc.agregarArreglo(nodo.ChildNodes[2].ChildNodes[2]);
                    }
                    return(proc);
                }
                else
                {
                    return(new Procedimiento(id, (int)Simbolo.Tipo.VACIO, parametros,
                                             nodo.ChildNodes[3].ChildNodes[0], false,
                                             nodo.ChildNodes[1].Token.Location.Line,
                                             nodo.ChildNodes[1].Token.Location.Column));
                }
            }
        }
Example #7
0
        public Clase guardarClase(ParseTreeNode clase)
        {
            // CLASE -> id BCUERPO | id id BCUERPO
            Clase  nueva;
            String nombre_clase = clase.ChildNodes.ElementAt(0).Token.Value.ToString();
            int    pos          = 1;

            if (clase.ChildNodes.Count == 2)
            {
                nueva = new Clase(nombre_clase, clase.ChildNodes[0].Token.Location.Line,
                                  clase.ChildNodes[0].Token.Location.Line);
            }
            else
            {
                // Tiene padre
                String padre = clase.ChildNodes.ElementAt(1).Token.Value.ToString();
                nueva = new Clase(nombre_clase, padre, clase.ChildNodes[0].Token.Location.Line,
                                  clase.ChildNodes[0].Token.Location.Line);
                pos++;
            }
            // Recorrer atributos, constructores y procedimientos
            ParseTreeNode cuerpos = clase.ChildNodes.ElementAt(pos).ChildNodes.ElementAt(0);

            foreach (ParseTreeNode cuerpo in cuerpos.ChildNodes)
            {
                if (cuerpo.ChildNodes.ElementAt(0).Term.Name.Equals("METODO"))
                {
                    Procedimiento proc = guardarProcedimiento(cuerpo.ChildNodes[0]);
                    proc.llenarDeclaraciones(proc.sentencias, nueva.atributos);
                    nueva.agregarProcedimiento(proc);
                }
                else if (cuerpo.ChildNodes.ElementAt(0).Term.Name.Equals("__constructor"))
                {
                    Procedimiento cons = guardarConstructor(cuerpo);
                    cons.llenarDeclaraciones(cons.sentencias, nueva.atributos);
                    nueva.agregarConstructor(cons);
                }
                else if (cuerpo.ChildNodes.ElementAt(0).Term.Name.Equals("DECLARACION"))
                {
                    ParseTreeNode declara = cuerpo.ChildNodes[0];

                    /* DECLARACION -> TIPO + LISTA_IDS + asignarR
                     | TIPO + LISTA_IDS
                     | TIPO + NARREGLO -> id + INDICES */
                    int           tipo = Simbolo.getTipo(declara.ChildNodes[0].Token.Text);
                    ParseTreeNode ids  = declara.ChildNodes[1];
                    if (ids.Term.Name.Equals("NARREGLO"))
                    {
                        Atributo variable = new Atributo(ids.ChildNodes[0].Token.Text, tipo,
                                                         ids.ChildNodes[0].Token.Location.Line, ids.ChildNodes[0].Token.Location.Column);
                        variable.asignarArreglo(ids.ChildNodes[1]);
                        if (tipo == (int)Simbolo.Tipo.CLASE)
                        {
                            variable.asignarClase(declara.ChildNodes[0].ChildNodes[0].Token.Text);
                        }
                        nueva.agregarAtributo(variable);
                    }
                    else
                    {
                        foreach (ParseTreeNode var in ids.ChildNodes)
                        {
                            Atributo a = new Atributo(var.Token.Text, tipo,
                                                      var.Token.Location.Line, var.Token.Location.Column);
                            if (declara.ChildNodes.Count == 3)
                            {
                                a.asignarValor(declara.ChildNodes[2]);
                            }
                            nueva.agregarAtributo(a);
                        }
                    }
                }
                else if (cuerpo.ChildNodes[0].Term.Name.Equals("VISIBILIDAD"))
                {
                    int           vis     = Simbolo.getVisibilidad(cuerpo.ChildNodes[0].ChildNodes[0].Token.Text);
                    ParseTreeNode declara = cuerpo.ChildNodes[1];
                    int           tipo    = Simbolo.getTipo(declara.ChildNodes[0].Token.Text);
                    ParseTreeNode ids     = declara.ChildNodes[1];
                    if (ids.Term.Name.Equals("NARREGLO"))
                    {
                        Atributo variable = new Atributo(ids.ChildNodes[0].Token.Text, tipo,
                                                         ids.ChildNodes[0].Token.Location.Line, ids.ChildNodes[0].Token.Location.Column);
                        variable.asignarArreglo(ids.ChildNodes[1]);
                        if (tipo == (int)Simbolo.Tipo.CLASE)
                        {
                            variable.asignarClase(declara.ChildNodes[0].ChildNodes[0].Token.Text);
                        }
                        nueva.agregarAtributo(variable);
                    }
                    else
                    {
                        foreach (ParseTreeNode var in ids.ChildNodes)
                        {
                            Atributo a = new Atributo(var.Token.Text, tipo,
                                                      var.Token.Location.Line, var.Token.Location.Column);
                            if (declara.ChildNodes.Count == 3)
                            {
                                a.asignarValor(declara.ChildNodes[2]);
                            }
                            nueva.agregarAtributo(a);
                        }
                    }
                }
            }
            return(nueva);
        }
        public Clase guardarClase(ParseTreeNode nodo)
        {
            // CLASE -> id id CUERPOS
            //| id CUERPOS
            Clase nueva;
            int   idCuerpos = 1;

            if (nodo.ChildNodes.Count == 3)
            {
                // Tiene padre
                nueva = new Clase(nodo.ChildNodes[0].Token.Text,
                                  nodo.ChildNodes[1].Token.Text, nodo.ChildNodes[0].Token.Location.Line,
                                  nodo.ChildNodes[0].Token.Location.Column);
                idCuerpos = 2;
            }
            else
            {
                // No tiene padre
                nueva = new Clase(nodo.ChildNodes[0].Token.Text,
                                  nodo.ChildNodes[0].Token.Location.Line,
                                  nodo.ChildNodes[0].Token.Location.Column);
            }
            // Recorrer cuerpos
            foreach (ParseTreeNode cuerpo in nodo.ChildNodes[idCuerpos].ChildNodes)
            {
                // Recorrer cada uno de los cuerpos en busca de Declaraciones, Metodos, Funciones o Constructores

                /*
                 * CUERPO.Rule = VISIBILIDAD + TPROC + id + TCUERPO? -> 4 , 3
                 | TPROC + id + TCUERPO? -> 3 , 2
                 | sobreescribir + METODO -> 2
                 | PRINCIPAL -> 1
                 | VISIBILIDAD + CONSTRUCTOR -> 2
                 | CONSTRUCTOR -> 1
                 | ASIGNACION + fin; -> 1
                 */
                switch (cuerpo.ChildNodes.Count)
                {
                case 1:
                    // CONSTRUCTOR o PRINCIPAL
                    if (cuerpo.ChildNodes[0].Term.Name.Equals("CONSTRUCTOR"))
                    {
                        Procedimiento cons = guardarConstructor(cuerpo.ChildNodes[0],
                                                                (int)Simbolo.Visibilidad.PUBLICO);
                        cons.llenarDeclaraciones(cons.sentencias, nueva.atributos);
                        nueva.agregarConstructor(cons);
                    }
                    else if (cuerpo.ChildNodes[0].Term.Name.Equals("PRINCIPAL"))
                    {
                        Procedimiento proc = new Procedimiento("main",
                                                               (int)Simbolo.Tipo.VACIO, new List <Atributo>(), cuerpo.ChildNodes[0].ChildNodes[0],
                                                               cuerpo.Span.Location.Line, cuerpo.Span.Location.Column);
                        proc.llenarDeclaraciones(proc.sentencias, nueva.atributos);
                        nueva.agregarProcedimiento(proc);
                    }
                    break;

                case 2:
                    // sobreescribir METODO
                    // VISIBILIDAD CONSTRUCTOR
                    // TPROC id
                    if (cuerpo.ChildNodes[1].Term.Name.Equals("CONSTRUCTOR"))
                    {
                        int           vis  = Simbolo.getVisibilidad(cuerpo.ChildNodes[0].ChildNodes[0].Token.Text);
                        Procedimiento cons = guardarConstructor(cuerpo.ChildNodes[1], vis);
                        cons.llenarDeclaraciones(cons.sentencias, nueva.atributos);
                        nueva.agregarConstructor(cons);
                    }
                    else if (cuerpo.ChildNodes[1].Term.Name.Equals("METODO"))
                    {
                        Procedimiento proc = guardarProcedimiento
                                                 (cuerpo.ChildNodes[1], true);
                        proc.llenarDeclaraciones(proc.sentencias, nueva.atributos);
                        nueva.agregarProcedimiento(proc);
                    }
                    else
                    {
                        // TPROC id
                        ParseTreeNode tproc = cuerpo.ChildNodes[0];
                        int           tipo  = Simbolo.getTipo(tproc.ChildNodes[0].Token.Text);
                        Atributo      a     = new Atributo(cuerpo.ChildNodes[1].Token.Text,
                                                           tipo, cuerpo.ChildNodes[1].Token.Location.Line,
                                                           cuerpo.ChildNodes[1].Token.Location.Column);
                        if (tipo == (int)Simbolo.Tipo.CLASE)
                        {
                            a.asignarClase(tproc.ChildNodes[0].Token.Text);
                        }
                        nueva.agregarAtributo(a);
                    }
                    break;

                case 3:
                    // TPROC id CMETODO
                    // TPROC id DARREGLO
                    // TPROC id EXP
                    // VISIBILIDAD TPROC id
                    if (cuerpo.ChildNodes[0].Term.Name.Equals("TPROC"))
                    {
                        if (cuerpo.ChildNodes[2].Term.Name.Equals("CMETODO"))
                        {
                            // Es procedimiento
                            Procedimiento proc = guardarProcedimiento
                                                     (cuerpo, true);
                            proc.llenarDeclaraciones(proc.sentencias, nueva.atributos);
                            nueva.agregarProcedimiento(proc);
                        }
                        else
                        {
                            // Es atributo
                            ParseTreeNode tproc = cuerpo.ChildNodes[0];
                            String        ctipo = tproc.ChildNodes[0].Token.Text;
                            int           tipo  = Simbolo.getTipo(ctipo);
                            Atributo      a     = new Atributo(cuerpo.ChildNodes[1].Token.Text,
                                                               tipo, cuerpo.ChildNodes[1].Token.Location.Line,
                                                               cuerpo.ChildNodes[1].Token.Location.Column);
                            // Ver si el tipo de la variable es una clase
                            if (tipo == (int)Simbolo.Tipo.CLASE)
                            {
                                a.asignarClase(ctipo);
                            }
                            // Verificar si es un arreglo o tiene valor
                            if (cuerpo.ChildNodes[2].Term.Name.Equals("EXP"))
                            {
                                // Tiene valor
                                a.asignarValor(cuerpo.ChildNodes[2]);
                            }
                            else
                            {
                                // Es arreglo
                                ParseTreeNode darr = cuerpo.ChildNodes[2];
                                a.asignarArreglo(darr.ChildNodes[0]);
                                if (darr.ChildNodes.Count == 2)
                                {
                                    a.asignarValor(darr.ChildNodes[1]);
                                }
                            }
                            nueva.agregarAtributo(a);
                        }
                    }
                    else if (cuerpo.ChildNodes[0].Term.Name.Equals("VISIBILIDAD"))
                    {
                        // Es atributo
                        int           vis   = Simbolo.getVisibilidad(cuerpo.ChildNodes[0].ChildNodes[0].Token.Text);
                        ParseTreeNode tproc = cuerpo.ChildNodes[1];
                        String        ctipo = tproc.ChildNodes[0].Token.Text;
                        int           tipo  = Simbolo.getTipo(ctipo);
                        Atributo      a     = new Atributo(cuerpo.ChildNodes[2].Token.Text,
                                                           tipo, vis, cuerpo.ChildNodes[2].Token.Location.Line,
                                                           cuerpo.ChildNodes[2].Token.Location.Column);
                        if (tipo == (int)Simbolo.Tipo.CLASE)
                        {
                            a.asignarClase(ctipo);
                        }
                        nueva.agregarAtributo(a);
                    }
                    break;

                case 4:
                    // VISIBILIDAD TPROC id CMETODO
                    // VISIBILIDAD TPROC id DARREGLO
                    // VISIBILIDAD TPROC id EXP
                    int vis2 = Simbolo.getVisibilidad(cuerpo.ChildNodes[0].ChildNodes[0].Token.Text);
                    if (cuerpo.ChildNodes[3].Term.Name.Equals("CMETODO"))
                    {
                        // Es procedimiento
                        Procedimiento proc = guardarProcedimiento(cuerpo, false);
                        proc.llenarDeclaraciones(proc.sentencias, nueva.atributos);
                        nueva.agregarProcedimiento(proc);
                    }
                    else
                    {
                        // Es atributo --> DARREGLO o EXP
                        // Es atributo
                        ParseTreeNode tproc = cuerpo.ChildNodes[1];
                        String        ctipo = tproc.ChildNodes[0].Token.Text;
                        int           tipo  = Simbolo.getTipo(ctipo);
                        Atributo      a     = new Atributo(cuerpo.ChildNodes[2].Token.Text,
                                                           tipo, vis2, cuerpo.ChildNodes[2].Token.Location.Line,
                                                           cuerpo.ChildNodes[2].Token.Location.Column);
                        // Ver si el tipo de la variable es una clase
                        if (tipo == (int)Simbolo.Tipo.CLASE)
                        {
                            a.asignarClase(ctipo);
                        }
                        // Verificar si es un arreglo o tiene valor
                        if (cuerpo.ChildNodes[3].Term.Name.Equals("EXP"))
                        {
                            // Tiene valor
                            a.asignarValor(cuerpo.ChildNodes[3]);
                        }
                        else
                        {
                            // Es arreglo
                            ParseTreeNode darr = cuerpo.ChildNodes[3];
                            a.asignarArreglo(darr.ChildNodes[0]);
                            if (darr.ChildNodes.Count == 2)
                            {
                                a.asignarValor(darr.ChildNodes[1]);
                            }
                        }
                        nueva.agregarAtributo(a);
                    }
                    break;
                }
            }
            return(nueva);
        }