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