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);
}
public void agregarProcedimiento(Procedimiento nuevo)
{
if (!existeProcedimiento(nuevo))
{
procedimientos.Add(nuevo);
}
}
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);
}
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);
}
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);
}