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 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 = "";
}
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);
}
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));
}
}
}
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);
}