public LinkedList <Simbolo> guardarProcedimiento(String clase, Procedimiento procedimiento)
 {
     simbolos = new LinkedList <Simbolo>();
     // Agregar this y super a la lista de simbolos
     simbolos.AddLast(guardarEste(procedimiento.completo));
     simbolos.AddLast(guardarSuper(procedimiento.completo));
     tamanio = 2;
     // Ver si es funcion o no
     if (procedimiento.tipo != (int)Simbolo.Tipo.VACIO)
     {
         Atributo retorno = new Atributo("retorno", procedimiento.tipo, procedimiento.linea, procedimiento.columna);
         retorno.clase = procedimiento.clase;
         simbolos.AddLast(guardarSimboloRetorno(procedimiento.completo, retorno));
     }
     // Recorrer parametros
     foreach (Atributo parametro in procedimiento.parametros)
     {
         simbolos.AddLast(guardarSimboloParametro(procedimiento.completo, parametro));
     }
     // Recorrer sentencias en busca de declaraciones
     foreach (Atributo variable in procedimiento.declaraciones)
     {
         simbolos.AddLast(guardarSimboloVariable(procedimiento.completo, variable, false));
     }
     // Recorrer al inicio el procedimiento
     simbolos.AddFirst(guardarSimboloProcedimiento(clase, procedimiento));
     return(simbolos);
 }
        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);
        }
        public LinkedList <Simbolo> guardarConstructor(String clase, Procedimiento constructor)
        {
            simbolos = new LinkedList <Simbolo>();
            // Agregar this y super a la lista de simbolos
            simbolos.AddLast(guardarEste(constructor.completo));
            simbolos.AddLast(guardarSuper(constructor.completo));
            Atributo retorno = new Atributo("retorno", (int)Simbolo.Tipo.CLASE, constructor.linea, constructor.columna);

            retorno.clase = clase;
            simbolos.AddLast(guardarSimboloRetorno(constructor.completo, retorno));
            tamanio = 3;
            // Recorrer parametros
            foreach (Atributo parametro in constructor.parametros)
            {
                simbolos.AddLast(guardarSimboloParametro(constructor.completo, parametro));
            }
            // Recorrer sentencias en busca de declaraciones
            foreach (Atributo variable in constructor.declaraciones)
            {
                simbolos.AddLast(guardarSimboloVariable(constructor.completo, variable, false));
            }
            // Recorrer al inicio el constructor
            simbolos.AddFirst(guardarSimboloConstructor(clase, constructor));
            return(simbolos);
        }
예제 #4
0
 public void agregarProcedimiento(Procedimiento nuevo)
 {
     if (!existeProcedimiento(nuevo))
     {
         procedimientos.Add(nuevo);
     }
 }
예제 #5
0
 public void agregarConstructor(Procedimiento nuevo)
 {
     if (!existeConstructor(nuevo))
     {
         constructores.Add(nuevo);
     }
 }
        public Simbolo guardarSimboloConstructor(String padre, Procedimiento constructor)
        {
            Simbolo sconstructor = new Simbolo();

            sconstructor.ambito      = (int)Simbolo.Tipo.GLOBAL;
            sconstructor.visibilidad = constructor.visibilidad;
            sconstructor.clase       = "";
            sconstructor.dimensiones = null;
            sconstructor.nombre      = constructor.completo;
            sconstructor.padre       = padre;
            sconstructor.pos         = -1;
            sconstructor.rol         = (int)Simbolo.Tipo.CONSTRUCTOR;
            sconstructor.tam         = tamanio;
            sconstructor.tipo        = -1;
            return(sconstructor);
        }
        public static String getNombreProcedimiento(Procedimiento proc)
        {
            String nombre = proc.nombre;

            if (proc.parametros != null)
            {
                if (proc.parametros.Count > 0)
                {
                    foreach (Atributo p in proc.parametros)
                    {
                        nombre += "_" + Simbolo.getValor(p.tipo);
                    }
                }
            }
            return(nombre);
        }
예제 #8
0
 public bool existeProcedimiento(Procedimiento nuevo)
 {
     foreach (Procedimiento proc in procedimientos)
     {
         String n1 = nuevo.completo;
         String n2 = proc.completo;
         if (n1.Equals(n2))
         {
             Errores.getInstance.agregar(new Error((int)Error.tipoError.SEMANTICO,
                                                   "El procedimiento " + n1 + " ya existe en la clase " + nombre,
                                                   nuevo.linea, nuevo.columna));
             return(true);
         }
     }
     return(false);
 }
        public Simbolo guardarSimboloProcedimiento(String padre, Procedimiento procedimiento)
        {
            Simbolo sprocedimiento = new Simbolo();

            sprocedimiento.ambito      = (int)Simbolo.Tipo.GLOBAL;
            sprocedimiento.clase       = "";
            sprocedimiento.dimensiones = null;
            sprocedimiento.nombre      = procedimiento.completo;
            sprocedimiento.visibilidad = procedimiento.visibilidad;
            sprocedimiento.padre       = padre;
            sprocedimiento.tam         = tamanio;
            sprocedimiento.tipo        = procedimiento.tipo;
            sprocedimiento.rol         = (int)Simbolo.Tipo.FUNCION;
            if (procedimiento.tipo == (int)Simbolo.Tipo.VACIO)
            {
                sprocedimiento.rol = (int)Simbolo.Tipo.METODO;
            }
            if (procedimiento.tipo == (int)Simbolo.Tipo.CLASE)
            {
                sprocedimiento.clase = procedimiento.clase;
            }
            return(sprocedimiento);
        }
예제 #10
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));
                }
            }
        }
예제 #11
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);
        }