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 static void getReporteTS(TablaSimbolos ts, ref DataGridView tabla)
{
/*public String nombre, padre, clase;
* public int ambito, tipo, rol, pos, tam;
* //public int fila, columna;
* public List<int> dimensiones;*/
tabla.Columns.Add(crearColumna("#"));
tabla.Columns.Add(crearColumna("Rol"));
tabla.Columns.Add(crearColumna("Nombre"));
tabla.Columns.Add(crearColumna("Padre"));
tabla.Columns.Add(crearColumna("Tipo"));
tabla.Columns.Add(crearColumna("Clase"));
tabla.Columns.Add(crearColumna("Ambito"));
tabla.Columns.Add(crearColumna("Visibilidad"));
tabla.Columns.Add(crearColumna("Posicion"));
tabla.Columns.Add(crearColumna("Tamaño"));
tabla.Columns.Add(crearColumna("Dimensiones"));
int id = 1;
foreach (Simbolo simbolo in ts)
{
object[] fila = new object[11];
fila[0] = id;
fila[1] = Simbolo.getValor(simbolo.rol);
fila[2] = simbolo.nombre;
fila[3] = simbolo.padre;
fila[4] = Simbolo.getValor(simbolo.tipo);
fila[5] = simbolo.clase;
if (simbolo.clase == null)
{
fila[5] = "--------";
}
fila[6] = Simbolo.getValor(simbolo.ambito);
fila[7] = Simbolo.getVisibilidad(simbolo.visibilidad);
fila[8] = simbolo.pos;
fila[9] = simbolo.tam;
fila[10] = "--------";
if (simbolo.dimensiones != null)
{
fila[10] = "";
foreach (int v in simbolo.dimensiones)
{
fila[10] += v + " ";
}
}
tabla.Rows.Add(fila);
id++;
}
}
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 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);
}