public clasesDiagrama generarUML2(ParseTreeNode raiz)
{
clasesDiagrama nuevo = new clasesDiagrama();
generarListadoClases(raiz);
Clase claseActual;
foreach (ParseTreeNode actual in this.clasesUML)
{
claseActual = generarClase(actual);
if (claseActual != null)
{
claseActual.setLenguaje("java");
if (!nuevo.insertarClase(claseActual))
{
ErrorA nuev3o = new ErrorA(Constantes.errorSemantico, "La clase " + claseActual.getNombre() + ", no se pudo crear, ya existe", actual.FindToken());
Form1.errores.addError(nuev3o);
}
}
else
{
ErrorA nuev3o = new ErrorA(Constantes.errorSemantico, "Ocurrio un error, no se pudo generar la clase ", actual.FindToken());
Form1.errores.addError(nuev3o);
}
}
return(nuevo);
}
private Funcion getconstructor(ParseTreeNode nodoConstructor, string nombreClase)
{
//CONSTRUCTOR.Rule = ToTerm("__constructor") + "[" + PARAMETROS + "]" + ":" + Eos + CUERPO;
Cuerpo instr;
ListaParametro parametros = getParametros(nodoConstructor.ChildNodes[0]);
string nombre = nodoConstructor.ChildNodes[0].Token.Value.ToString();
Funcion nueva = new Funcion(nombreClase, Constantes.constructor, Constantes.tipoVoid, parametros, Constantes.publico, nodoConstructor.ChildNodes[1]);
if (nombre.Equals(nombreClase, StringComparison.OrdinalIgnoreCase))
{
nueva = new Funcion(nombreClase, nombre, Constantes.tipoVoid, parametros, Constantes.publico, nodoConstructor.ChildNodes[1]);
nueva.setConstructor(true);
// instr = getCuerpo(nodoConstructor.ChildNodes[1]);
// nueva.setCuerpo(instr);
return(nueva);
}
else
{
ErrorA nuevo = new ErrorA(Constantes.errorSemantico, nodoConstructor.ChildNodes[0].Token.Location.Line,
nodoConstructor.ChildNodes[0].Token.Location.Position, nodoConstructor.ChildNodes[0].Token.Location.Column,
"El nombre de " + nombre + ", no coincide con el nombre de clase, " + nombreClase);
Form1.errores.addError(nuevo);
return(null);
//error semantico
}
}
private Instruccion getInstruccion(ParseTreeNode instr)
{
switch (instr.Term.Name)
{
case Constantes.expresion: //para las llamadas
{
int noHijos = instr.ChildNodes.Count;
ExpresionLlamada nuevaLlamada;
if (instr.ChildNodes[noHijos - 1].Term.Name.Equals(Constantes.llamada, StringComparison.OrdinalIgnoreCase))
{
nuevaLlamada = new ExpresionLlamada(instr);
return(nuevaLlamada);
}
else
{
ErrorA err = new ErrorA(Constantes.errorSemantico, "En invalido colocar este tipo de expresion, debe ser una llamada", instr.Token);
Form1.errores.addError(err);
return(null);
}
}
case Constantes.declaracion: {
Declaracion nuevo = new Declaracion(instr);
return(nuevo);
}
}
return(null);
}
private Clase agregarInstruccionesClase(Clase claseModificar, ParseTreeNode instrucciones)
{
foreach (ParseTreeNode item in instrucciones.ChildNodes)
{
switch (item.Term.Name)
{/*ELEMENTO.Rule = FUNCION
| ATRIBUTO
| CONSTRUCTOR
| FUNCION_SOBRE;
*/
case Constantes.funcion:
{
Funcion nueva = getFuncion(item, claseModificar.getNombre());
claseModificar.addFuncion(nueva);
break;
}
case Constantes.atributo:
{
List <Atributo> atributos = generarAtributos(item);
foreach (Atributo atr in atributos)
{
claseModificar.addAtributo(atr);
}
break;
}
case Constantes.constructor:
{
Funcion constructor = getconstructor(item, claseModificar.getNombre());
if (constructor != null)
{
claseModificar.addFuncion(constructor);
}
else
{
ErrorA nuevo = new ErrorA("Semantico", "No se pudo generar el constructor", item.Token);
Form1.errores.addError(nuevo);
}
break;
}
case Constantes.funSobre:
{
Funcion nueva = getFuncion(item.ChildNodes[0], claseModificar.getNombre());
nueva.setSobreescrita(true);
claseModificar.addFuncion(nueva);
break;
}
}
}
return(claseModificar);
}
private void heap(ParseTreeNode nodo, int modo)
{
if (modo == 0)
{
//asignacionHeap.Rule = identificador + ToTerm("=") + "HEAP" + "[" + EXPRESION + "]" + ";";
string id = nodo.ChildNodes[0].Token.ValueString;
Object val = resolverExp(nodo.ChildNodes[1]);
if (!esNula(val))
{
int indice = (int)val;
temporales.agregarTemp(new Temporal(id, Heap[indice]));
}
else
{
ErrorA er = new ErrorA("Semantico", "Ocurrio un error a realizar la operacion", nodo.FindToken());
Form1.errores.addError(er);
}
}
else if (modo == 1)
{//heap.Rule = ToTerm("HEAP") + "[" + EXPRESION + "]" + "=" + EXPRESION + ";";
object objIndice = resolverExp(nodo.ChildNodes[0]);
object valor = resolverExp(nodo.ChildNodes[1]);
if (!esNula(objIndice) && !esNula(valor))
{
int indice = (int)objIndice;
if (valor is Double)
{
Heap[indice] = (double)valor;
}
else if (valor is int)
{
Heap[indice] = (int)valor;
}
}
else
{
ErrorA er = new ErrorA("Semantico", "Ocurrio un error a realizar la operacion", nodo.FindToken());
Form1.errores.addError(er);
}
}
}
private void pila(ParseTreeNode nodo, int modo)
{
if (modo == 0)
{// identificador + ToTerm("=") + "STACK" + "[" + EXPRESION + "]" + ";";
string id = nodo.ChildNodes[0].Token.ValueString;
Object val = resolverExp(nodo.ChildNodes[1]);
int aux = (int)val;
if (!val.ToString().Equals("nulo"))
{
temporales.agregarTemp(new Temporal(id, Pila[aux]));
}
else
{
ErrorA er = new ErrorA("Semantico", "Ocurrio un error a realizar la operacion", nodo.FindToken());
Form1.errores.addError(er);
}
}
else if (modo == 1)
{// stack.Rule = ToTerm("STACK") + "[" + EXPRESION + "]" + "=" + EXPRESION + ";";
Object indice = resolverExp(nodo.ChildNodes[0]);
Object valor = resolverExp(nodo.ChildNodes[1]);
if (!valor.ToString().Equals("nulo") &&
!indice.ToString().Equals("nulo"))
{
int ind = (int)indice;
if (valor is Double)
{
Pila[ind] = (double)valor;
}
else if (valor is int)
{
Pila[ind] = (int)valor;
}
}
else
{
ErrorA er = new ErrorA("Semantico", "Ocurrio un error a realizar la operacion", nodo.FindToken());
Form1.errores.addError(er);
}
}
}
/*
* private List<Atributo> generarAtributos(ParseTreeNode nodoAtributo)
* {
*
* ATRIBUTO.Rule = VISIBILIDAD + TIPO + L_IDS + ToTerm(";")3,4,2,3
| VISIBILIDAD + TIPO + identificador + ToTerm("=") + EXPRESION + ToTerm(";")
| TIPO + L_IDS + ToTerm(";")
| TIPO + identificador + ToTerm("=") + EXPRESION + ToTerm(";");
|
|
| List<Atributo> lista = new List<Atributo>();
| Atributo nuevo;
| int noHijos = nodoAtributo.ChildNodes.Count;
| string tipo, nombre, visibilidad;
| if (noHijos == 2)
| {
| visibilidad = Constantes.publico;
| tipo = nodoAtributo.ChildNodes[0].ChildNodes[0].Token.Value.ToString();
| foreach (ParseTreeNode item in nodoAtributo.ChildNodes[1].ChildNodes)
| {
| nombre = item.Token.Value.ToString();
| nuevo = new Atributo(visibilidad, nombre, tipo);
| lista.Add(nuevo);
| }
| return lista;
|
| }
| else if (noHijos == 4)
| {
| visibilidad = nodoAtributo.ChildNodes[0].ChildNodes[0].Token.Value.ToString();
| tipo = nodoAtributo.ChildNodes[1].ChildNodes[0].Token.Value.ToString();
| nombre = nodoAtributo.ChildNodes[2].Token.Value.ToString();
| nuevo = new Atributo(visibilidad, nombre, tipo);
| lista.Add(nuevo);
| return lista;
| }
| else
| {//posee tres hijos
| if (nodoAtributo.ChildNodes[0].Term.Name.Equals(Constantes.visibilidad))
| {
|
| visibilidad =nodoAtributo.ChildNodes[0].ChildNodes[0].Token.Value.ToString();
| tipo = nodoAtributo.ChildNodes[1].ChildNodes[0].Token.Value.ToString();
| foreach (ParseTreeNode item in nodoAtributo.ChildNodes[2].ChildNodes)
| {
| nombre = item.Token.Value.ToString();
| nuevo = new Atributo(visibilidad, nombre, tipo);
| lista.Add(nuevo);
| }
| return lista;
|
| }
| else
| {
| visibilidad = Constantes.publico;
| tipo = nodoAtributo.ChildNodes[0].ChildNodes[0].Token.Value.ToString();
| nombre = nodoAtributo.ChildNodes[1].Token.Value.ToString();
| nuevo = new Atributo(visibilidad, nombre, tipo);
| lista.Add(nuevo);
| return lista;
|
|
| }
|
| }
|
| }
*/
private Funcion getConstructor(ParseTreeNode nodoConstructor, string nombreClase)
{
/* CONSTRUCTOR.Rule = identificador + ToTerm("(") + L_PARAMETRO + ToTerm(")") + CUERPO;*/
Funcion constructor;
string nombre = nodoConstructor.ChildNodes[0].Token.Value.ToString();
if (nombre.ToUpper().Equals(nombreClase.ToUpper()))
{
ListaParametro parametros = getParametros(nodoConstructor.ChildNodes[1]);
constructor = new Funcion(nombreClase, nombre, Constantes.tipoVoid, parametros, Constantes.publico, nodoConstructor.ChildNodes[2]);
constructor.setConstructor(true);
return(constructor);
}
else
{
ErrorA nuevo = new ErrorA(Constantes.errorSemantico, nodoConstructor.ChildNodes[0].Token.Location.Line,
nodoConstructor.ChildNodes[0].Token.Location.Position, nodoConstructor.ChildNodes[0].Token.Location.Column,
"El nombre de " + nombre + ", no coincide con el nombre de clase, " + nombreClase);
Form1.errores.addError(nuevo);
return(null);
//error semantico
}
}
public void generarUML(ParseTreeNode raiz)
{
generarListadoClases(raiz);
Clase claseActual;
foreach (ParseTreeNode actual in this.clasesUML)
{
claseActual = generarClase(actual);
if (claseActual != null)
{
claseActual.setLenguaje("python");
if (!Form1.uml.insertarClase(claseActual))
{
ErrorA nuevo = new ErrorA(Constantes.errorSemantico, "La clase " + claseActual.getNombre() + ", no se pudo crear, ya existe", actual.FindToken());
Form1.errores.addError(nuevo);
}
}
else
{
ErrorA nuevo = new ErrorA(Constantes.errorSemantico, "Ocurrio un error, no se pudo generar la clase ", actual.FindToken());
Form1.errores.addError(nuevo);
}
}
}
private Object resolverExp(ParseTreeNode nodo)
{
switch (nodo.Term.Name)
{
case "TERMINO":
{
return(resolverExp(nodo.ChildNodes[0]));
}
case ConstantesInterprete.ENTERO:
{
return(int.Parse(nodo.ChildNodes[0].Token.ValueString));
}
case ConstantesInterprete.DECIMAL:
{
return(double.Parse(nodo.ChildNodes[0].Token.ValueString));
}
case "ID":
{
string id = nodo.ChildNodes[0].Token.ValueString;
return(temporales.getValorTemp(id));
}
case ConstantesInterprete.NEGATIVO:
{
Object valn = resolverExp(nodo.ChildNodes[1]);
if (valn is int)
{
return(int.Parse(valn + "") * -1);
}
if (valn is Double)
{
return(Double.Parse(valn + "") * -1);
}
return("");
}
case ConstantesInterprete.OPERACION:
{
#region operaciones
Object val1 = resolverExp(nodo.ChildNodes[0]);
Object val2 = resolverExp(nodo.ChildNodes[2]);
switch (nodo.ChildNodes[1].ChildNodes[0].Term.Name)
{
case "+":
{
if ((esInt(val1) || esDouble(val1)) &&
(esInt(val2) || esDouble(val2)))
{
if (esInt(val2) && esInt(val2))
{
return((int)int.Parse(val1.ToString()) + int.Parse(val2.ToString()));
}
else
{
return((Double)double.Parse(val1.ToString()) + double.Parse(val2.ToString()));
}
}
else
{
ErrorA n = new ErrorA("Semantico", "Tipos no validos para una suma", nodo.FindToken());
Form1.errores.addError(n);
return("nulo");
}
}
case "-":
{
if ((esInt(val1) || esDouble(val1)) &&
(esInt(val2) || esDouble(val2)))
{
if (esInt(val2) && esInt(val2))
{
return((int)int.Parse(val1.ToString()) - int.Parse(val2.ToString()));
}
else
{
return((Double)double.Parse(val1.ToString()) - double.Parse(val2.ToString()));
}
}
else
{
ErrorA n = new ErrorA("Semantico", "Tipos no validos para una resta", nodo.FindToken());
Form1.errores.addError(n);
return("nulo");
}
}
case "*":
{
if ((esInt(val1) || esDouble(val1)) &&
(esInt(val2) || esDouble(val2)))
{
if (esInt(val2) && esInt(val2))
{
return((int)int.Parse(val1.ToString()) * int.Parse(val2.ToString()));
}
else
{
return((Double)double.Parse(val1.ToString()) * double.Parse(val2.ToString()));
}
}
else
{
ErrorA n = new ErrorA("Semantico", "Tipos no validos para una multiplicacion", nodo.FindToken());
Form1.errores.addError(n);
return("nulo");
}
}
case "/":
{
if ((esInt(val1) || esDouble(val1)) &&
(esInt(val2) || esDouble(val2)))
{
if (int.Parse(val2.ToString()) != 0)
{
return(double.Parse(val1.ToString()) / double.Parse(val2.ToString()));
}
else
{
ErrorA n = new ErrorA("Semantico", "No se puede realizar division por cero", nodo.FindToken());
Form1.errores.addError(n);
return("nulo");
}
}
else
{
ErrorA n = new ErrorA("Semantico", "Tipos no validos para una division", nodo.FindToken());
Form1.errores.addError(n);
return("nulo");
}
}
case "^":
{
if ((esInt(val1) || esDouble(val1)) &&
(esInt(val2) || esDouble(val2)))
{
if (esInt(val2) && esInt(val2))
{
return((int)Math.Pow(int.Parse(val1.ToString()), int.Parse(val2.ToString())));
}
else
{
return((Double)Math.Pow(Double.Parse(val1.ToString()), Double.Parse(val2.ToString())));
}
}
else
{
ErrorA n = new ErrorA("Semantico", "Tipos no validos para una potencia", nodo.FindToken());
Form1.errores.addError(n);
return("nulo");
}
}
} //fin switch operaciones
#endregion
}
return("nulo");
}
return("nulo");
}
private Clase agregarInstruccionesClase(Clase claseModificar, ParseTreeNode instrucciones)
{
foreach (ParseTreeNode item in instrucciones.ChildNodes)
{
switch (item.Term.Name)
{
case Constantes.funcion:
{
Funcion nueva = getFuncion(item, claseModificar.getNombre());
claseModificar.addFuncion(nueva);
break;
}
case Constantes.funSobre:
{
Funcion nueva = getFuncion(item.ChildNodes[0], claseModificar.getNombre());
nueva.setSobreescrita(true);
claseModificar.addFuncion(nueva);
break;
}
case Constantes.atributo:
{
List <Atributo> atributos = generarAtributos(item);
foreach (Atributo atr in atributos)
{
claseModificar.addAtributo(atr);
}
break;
}
case Constantes.principal:
{
if (!claseModificar.funciones.hayPrincipal())
{
Funcion principal = getPrincipal(item, claseModificar.getNombre());
claseModificar.addFuncion(principal);
}
else
{
ErrorA err = new ErrorA(Constantes.errorSemantico, item.FindToken().Location.Line, item.FindToken().Location.Position, item.FindToken().Location.Column, "Una clase unicamente puede poseer un metodo principal");
Form1.errores.addError(err);
}
break;
}
case Constantes.constructor:
{
Funcion constructor = getConstructor(item, claseModificar.getNombre());
if (constructor != null)
{
claseModificar.addFuncion(constructor);
}
else
{
ErrorA nuevo = new ErrorA("Semantico", "No se pudo generar el constructor", item.Token);
Form1.errores.addError(nuevo);
}
break;
}
}
}
return(claseModificar);
}
private List <Atributo> generarAtributos(ParseTreeNode nodoAtributo)
{
List <Atributo> lista = new List <Atributo>();
Atributo nuevo;
int noHijos = nodoAtributo.ChildNodes.Count;
string tipo, nombre, visibilidad;
if (noHijos == 3 && nodoAtributo.ChildNodes[2].Term.Name.Equals(Constantes.instancia, StringComparison.OrdinalIgnoreCase))
{
////TIPO + identificador + ToTerm("=") + INSTANCIA + ";"
visibilidad = Constantes.publico;
tipo = nodoAtributo.ChildNodes[0].ChildNodes[0].Token.ValueString;
nombre = nodoAtributo.ChildNodes[1].Token.ValueString;
nuevo = new Atributo(visibilidad, nombre, tipo, getTipoAtributo(tipo));
nuevo.setExpresionAtributo(nodoAtributo.ChildNodes[2]);
lista.Add(nuevo);
}
else if (noHijos == 4 && nodoAtributo.ChildNodes[3].Term.Name.Equals(Constantes.instancia, StringComparison.OrdinalIgnoreCase))
{//VISIBILIDAD + TIPO + identificador + ToTerm("=") + INSTANCIA
visibilidad = nodoAtributo.ChildNodes[0].ChildNodes[0].Token.ValueString;
tipo = nodoAtributo.ChildNodes[1].ChildNodes[0].Token.ValueString;
nombre = nodoAtributo.ChildNodes[2].Token.ValueString;
nuevo = new Atributo(visibilidad, nombre, tipo, getTipoAtributo(tipo));
nuevo.setExpresionAtributo(nodoAtributo.ChildNodes[3]);
lista.Add(nuevo);
}
else if (noHijos == 5)
{//arreglo con filas declaradas y visibilidad
// VISIBILIDAD + TIPO + identificador + LPOSICIONES + ToTerm("=") + "{" + LFILAS + "}" + ";"
visibilidad = nodoAtributo.ChildNodes[0].ChildNodes[0].Token.ValueString;
tipo = nodoAtributo.ChildNodes[1].ChildNodes[0].Token.ValueString;
nombre = nodoAtributo.ChildNodes[2].Token.ValueString;
int noPosiciones = nodoAtributo.ChildNodes[3].ChildNodes.Count;
ParseTreeNode[] expresionesDimensiones = getExpresionesArreglo(nodoAtributo.ChildNodes[3]);
if (noPosiciones == expresionesDimensiones.Length && noPosiciones == nodoAtributo.ChildNodes[4].ChildNodes.Count)
{//si se puede crear el arreglo
nuevo = new Atributo(visibilidad, nombre, tipo, Constantes.ARREGLO, noPosiciones, expresionesDimensiones);
nuevo.setExpresionAtributo(nodoAtributo.ChildNodes[4]);
lista.Add(nuevo);
}
else
{//error semantico
ErrorA err = new ErrorA(Constantes.errorSemantico, "No coinciden numero de dimensiones", nodoAtributo.Token);
Form1.errores.addError(err);
}
}
else if (noHijos == 4)
{
if (nodoAtributo.ChildNodes[0].Term.Name.Equals(Constantes.tipo, StringComparison.OrdinalIgnoreCase))
{
// TIPO + identificador + LPOSICIONES + ToTerm("=") + "{" + LFILAS + "}" + ";";
visibilidad = Constantes.publico;
tipo = nodoAtributo.ChildNodes[0].ChildNodes[0].Token.ValueString;
nombre = nodoAtributo.ChildNodes[1].Token.ValueString;
int noPosiciones = nodoAtributo.ChildNodes[3].ChildNodes.Count;
ParseTreeNode[] expresionesDimensiones = getExpresionesArreglo(nodoAtributo.ChildNodes[2]);
int noFilasExpresion = nodoAtributo.ChildNodes[3].ChildNodes.Count;
if (expresionesDimensiones.Length == noPosiciones && noPosiciones == noFilasExpresion)
{
nuevo = new Atributo(visibilidad, nombre, tipo, Constantes.ARREGLO, noPosiciones, expresionesDimensiones);
nuevo.setExpresionAtributo(nodoAtributo.ChildNodes[3]);
lista.Add(nuevo);
}
else
{
ErrorA err = new ErrorA(Constantes.errorSemantico, "No coinciden numero de dimensiones", nodoAtributo.Token);
Form1.errores.addError(err);
}
}
else if (nodoAtributo.ChildNodes[3].Term.Name.Equals(Constantes.lposiciones, StringComparison.OrdinalIgnoreCase))
{
// VISIBILIDAD + TIPO + identificador + LPOSICIONES + ToTerm(";")
visibilidad = nodoAtributo.ChildNodes[0].ChildNodes[0].Token.ValueString;
tipo = nodoAtributo.ChildNodes[1].ChildNodes[0].Token.ValueString;
nombre = nodoAtributo.ChildNodes[2].Token.ValueString;
int noPosiciones = nodoAtributo.ChildNodes[3].ChildNodes.Count;
ParseTreeNode[] expresionesDimensiones = getExpresionesArreglo(nodoAtributo.ChildNodes[3]);
if (noPosiciones == expresionesDimensiones.Length)
{//si se puede crear el arreglo
nuevo = new Atributo(visibilidad, nombre, tipo, Constantes.ARREGLO, noPosiciones, expresionesDimensiones);
lista.Add(nuevo);
}
else
{//error semantico
ErrorA err = new ErrorA(Constantes.errorSemantico, "No coinciden numero de dimensiones", nodoAtributo.Token);
Form1.errores.addError(err);
}
}
else
{
/*VISIBILIDAD + TIPO + identificador + ToTerm("=") + EXPRESION + ToTerm(";") //1
*/
visibilidad = nodoAtributo.ChildNodes[0].ChildNodes[0].Token.ValueString;
tipo = nodoAtributo.ChildNodes[1].ChildNodes[0].Token.ValueString;
nombre = nodoAtributo.ChildNodes[2].Token.ValueString;
nuevo = new Atributo(visibilidad, nombre, tipo, getTipoAtributo(tipo));
nuevo.setExpresionAtributo(nodoAtributo.ChildNodes[3]);
lista.Add(nuevo);
}
}//fin de ==4
else if (noHijos == 3)
{
if (nodoAtributo.ChildNodes[0].Term.Name.Equals(Constantes.visibilidad, StringComparison.OrdinalIgnoreCase))
{
//ATRIBUTO.Rule = VISIBILIDAD + TIPO + L_IDS + ToTerm(";")
visibilidad = nodoAtributo.ChildNodes[0].ChildNodes[0].Token.ValueString;
tipo = nodoAtributo.ChildNodes[1].ChildNodes[0].Token.ValueString;
foreach (ParseTreeNode item in nodoAtributo.ChildNodes[2].ChildNodes)
{
nombre = item.Token.Value.ToString();
nuevo = new Atributo(visibilidad, nombre, tipo, getTipoAtributo(tipo));
lista.Add(nuevo);
}
}
else if (nodoAtributo.ChildNodes[2].Term.Name.Equals(Constantes.lposiciones, StringComparison.OrdinalIgnoreCase))
{
//| TIPO + identificador + LPOSICIONES + ToTerm(";")
visibilidad = Constantes.publico;
nombre = nodoAtributo.ChildNodes[1].Token.ValueString;
tipo = nodoAtributo.ChildNodes[0].ChildNodes[0].Token.ValueString;
int noPosiciones = nodoAtributo.ChildNodes[2].ChildNodes.Count;
ParseTreeNode[] expresionesDimensiones = getExpresionesArreglo(nodoAtributo.ChildNodes[2]);
if (noPosiciones == expresionesDimensiones.Length)
{//si se puede crear el arreglo
nuevo = new Atributo(visibilidad, nombre, tipo, Constantes.ARREGLO, noPosiciones, expresionesDimensiones);
lista.Add(nuevo);
}
else
{//error semantico
ErrorA err = new ErrorA(Constantes.errorSemantico, "No coinciden numero de dimensiones", nodoAtributo.Token);
Form1.errores.addError(err);
}
}
else
{
//| TIPO + identificador + ToTerm("=") + EXPRESION + ToTerm(";") //1
visibilidad = Constantes.publico;
nombre = nodoAtributo.ChildNodes[1].Token.ValueString;
tipo = nodoAtributo.ChildNodes[0].ChildNodes[0].Token.ValueString;
nuevo = new Atributo(visibilidad, nombre, tipo, getTipoAtributo(tipo));
nuevo.setExpresionAtributo(nodoAtributo.ChildNodes[2]);
lista.Add(nuevo);
}
}
else if (noHijos == 2)
{
//TIPO + L_IDS + ToTerm(";")
visibilidad = Constantes.publico;
tipo = nodoAtributo.ChildNodes[0].ChildNodes[0].Token.ValueString;
foreach (ParseTreeNode item in nodoAtributo.ChildNodes[1].ChildNodes)
{
nombre = item.Token.Value.ToString();
nuevo = new Atributo(visibilidad, nombre, tipo, getTipoAtributo(tipo));
lista.Add(nuevo);
}
}
return(lista);
}
/*--- Generacion de tabla de simbolos -------*/
public List <Simbolo> getSimbolosClase()
{
agregarConstructorPorDefecto();
/*Pasos para simboos de fucniones y metodos:
* 1. Ingresamos a la tabla de simblos el simbolo de la funcion o metodo
* 2. Ingresamos el this
* 3. Ingresamos los parametros
* 4. ingresamos las declaraciones que se hayan realizado en la funcion
* 5. ingresamos el return
* 6. Calculamos el tamanho de metodo y lo vamos a actualizar en la lista
*/
this.tamanho = atributos.atributos.Count;
List <Simbolo> retorno = new List <Simbolo>();
Simbolo simClase = new Simbolo(Constantes.noTieneVisi, this.nombre, this.nombre, Constantes.clase, Constantes.noTieneVisi, Constantes.clase, -1, this.tamanho);
retorno.Add(simClase);
List <Simbolo> h = generarSimbolosAtributos();
foreach (Simbolo s in h)
{
retorno.Add(s);
}
Ambitos ambitos;
foreach (Funcion func in this.funciones.funciones)
{
int noParametros = 0;
List <String> tipoParametros = new List <String>();
ambitos = new Ambitos();
ambitos.addAmbito(func.firma);
apuntador = 0;
//paso 2
Simbolo simThis = new Simbolo(Constantes.noTieneVisi, Constantes3D.THIS, Constantes3D.THIS, "", ambitos.getAmbito(), Constantes3D.THIS, apuntador, 1);
apuntador++;
//paso 3
List <Simbolo> simbolosParametros = new List <Simbolo>();
Simbolo simTemporal;
foreach (variable var in func.parametros.parametros)
{
noParametros++;
tipoParametros.Add(var.tipo);
simTemporal = new Simbolo(Constantes.noTieneVisi, var.nombre, var.tipo, getTipoAtributo(var.tipo), ambitos.getAmbito(), Constantes3D.parametro, apuntador, 1);
simbolosParametros.Add(simTemporal);
apuntador++;
}
//paso 4
List <Simbolo> lTemporalFuncion = new List <Simbolo>();
if (func.cuerpo != null)
{
lTemporalFuncion = generarSimbolosMetodo(func.cuerpo, lTemporalFuncion, ambitos);
}
//paso 5
Simbolo simReturn = new Simbolo(Constantes.noTieneVisi, Constantes3D.retorno, Constantes3D.retorno, "", ambitos.getAmbito(), Constantes3D.retorno, apuntador, 1);
int sizeFun = 1 + simbolosParametros.Count + lTemporalFuncion.Count + 1;
//paso 1
Simbolo simFuncion = new Simbolo(func.visibilidad, func.firma, func.tipo, "", this.nombre, func.getRol(), -1, sizeFun, noParametros, func.tiposParametrosCadena, func.nombre);
retorno.Add(simFuncion);
retorno.Add(simThis);
foreach (Simbolo item in simbolosParametros)
{
if (!existe(retorno, item))
{
retorno.Add(item);
}
else
{
ErrorA er = new ErrorA(Constantes.errorSemantico, 0, 0, 0, "Ya existe un simboo con ese nombre, " + item.nombreReal + ", en el ambito " + ambitos.ambitos.Peek());
Form1.errores.addError(er);
}
}
foreach (Simbolo item in lTemporalFuncion)
{
if (!existe(retorno, item))
{
retorno.Add(item);
}
else
{
ErrorA er = new ErrorA(Constantes.errorSemantico, 0, 0, 0, "Ya existe un simboo con ese nombre, " + item.nombreReal + ", en el ambito " + ambitos.ambitos.Peek());
Form1.errores.addError(er);
}
}
retorno.Add(simReturn);
ambitos.ambitos.Pop();
}
return(retorno);
}
private List <Simbolo> generarSimbolosMetodo(ParseTreeNode nodo, List <Simbolo> lista, Ambitos ambitos)
{
String nombreNodo = nodo.Term.Name.ToString();
switch (nombreNodo)
{
/*INSTRUCCION.Rule = DECLRACION + Eos
| ASIGNACION + Eos no se HACWE //
| SI
| SALIR + Eos//
| CONTINUAR + Eos//
| MIENTRAS//
| PARA//
| LOOP//
| HACER//
*
| REPETIR//
| ELEGIR;//*/
#region nuevasJava
case Constantes.decla2: {
int noHijos = nodo.ChildNodes.Count;
if (noHijos == 2)
{ //TIPO + identificador + ToTerm(";")
Simbolo s = new Simbolo(Constantes.noTieneVisi, nodo.ChildNodes[1].Token.ValueString, nodo.ChildNodes[0].ChildNodes[0].Token.ValueString,
getTipoAtributo(nodo.ChildNodes[0].ChildNodes[0].Token.ValueString), ambitos.getAmbito(), Constantes.varLocal, apuntador, 1);
apuntador++;
lista.Add(s);
return(lista);
}
else if (noHijos == 3)
{
if (nodo.ChildNodes[2].Term.Name.Equals(Constantes.lposiciones, StringComparison.OrdinalIgnoreCase))
{ //TIPO + identificador + LPOSICIONES + ToTerm(";")
string tipo = nodo.ChildNodes[0].ChildNodes[0].Token.ValueString;
string id = nodo.ChildNodes[1].Token.ValueString;
ParseTreeNode nodoPosiciones = nodo.ChildNodes[2];
listaDimensiones lDim;
Simbolo nuevo;
bool bandera = true;
//varifico que todo sea int
foreach (ParseTreeNode n in nodoPosiciones.ChildNodes)
{
bandera = bandera && (n.ChildNodes[0].Term.Name.Equals(Constantes.tipoEntero, StringComparison.OrdinalIgnoreCase));
}
if (bandera)
{
List <int> valores = new List <int>();
foreach (ParseTreeNode n in nodoPosiciones.ChildNodes)
{
int g = int.Parse(n.ChildNodes[0].ChildNodes[0].Token.ValueString); // (n.Term.Name.Equals(Constantes.tipoEntero, StringComparison.OrdinalIgnoreCase));
valores.Add(g);
}
lDim = new listaDimensiones(valores);
int linealizado = lDim.getLinealizado();
nuevo = new Simbolo(Constantes.noTieneVisi, id, tipo, Constantes.ARREGLO, ambitos.ambitos.Peek(), "arreglo local", apuntador, linealizado, valores.Count, lDim);
apuntador++;
lista.Add(nuevo);
}
else
{
ErrorA er = new ErrorA(Constantes.errorSemantico, "Para los arreglos unicamente se permites valores enteros", nodo.FindToken());
Form1.errores.addError(er);
}
return(lista);
}
else
{ //TIPO + identificador + ToTerm("=") + EXPRESION + ";"
Simbolo s = new Simbolo(Constantes.noTieneVisi, nodo.ChildNodes[1].Token.ValueString, nodo.ChildNodes[0].ChildNodes[0].Token.ValueString,
getTipoAtributo(nodo.ChildNodes[0].ChildNodes[0].Token.ValueString), ambitos.getAmbito(), Constantes.varLocal, apuntador, 1);
apuntador++;
lista.Add(s);
return(lista);
}
}
else
{
//TIPO + identificador + LPOSICIONES + ToTerm("=") + "{" + LFILAS + "}" + ";";
string tipo = nodo.ChildNodes[0].ChildNodes[0].Token.ValueString;
string id = nodo.ChildNodes[1].Token.ValueString;
ParseTreeNode nodoPosiciones = nodo.ChildNodes[2];
listaDimensiones lDim;
Simbolo nuevo;
bool bandera = true;
//varifico que todo sea int
foreach (ParseTreeNode n in nodoPosiciones.ChildNodes)
{
bandera = bandera && (n.ChildNodes[0].Term.Name.Equals(Constantes.tipoEntero, StringComparison.OrdinalIgnoreCase));
}
if (bandera)
{
List <int> valores = new List <int>();
foreach (ParseTreeNode n in nodoPosiciones.ChildNodes)
{
int g = int.Parse(n.ChildNodes[0].ChildNodes[0].Token.ValueString); // (n.Term.Name.Equals(Constantes.tipoEntero, StringComparison.OrdinalIgnoreCase));
valores.Add(g);
}
lDim = new listaDimensiones(valores);
int linealizado = lDim.getLinealizado();
nuevo = new Simbolo(Constantes.noTieneVisi, id, tipo, Constantes.ARREGLO, ambitos.ambitos.Peek(), "arreglo local", apuntador, linealizado, valores.Count, lDim);
apuntador++;
lista.Add(nuevo);
}
else
{
ErrorA er = new ErrorA(Constantes.errorSemantico, "Para los arreglos unicamente se permites valores enteros", nodo.FindToken());
Form1.errores.addError(er);
}
return(lista);
}
}
#endregion
case Constantes.si:
{
/* * SI.Rule = ToTerm(Constantes.si) + EXPRESION + ":" + Eos + CUERPO + L_EXTRAS + SI_NO
| ToTerm(Constantes.si) + EXPRESION + ":" + Eos + CUERPO + L_EXTRAS
| ToTerm(Constantes.si) + EXPRESION + ":" + Eos + CUERPO + SI_NO;
*/
int noHijos = nodo.ChildNodes.Count;
if (noHijos == 3)
{
ambitos.addIf();
lista = generarSimbolosMetodo(nodo.ChildNodes[1], lista, ambitos);
ambitos.ambitos.Pop();
lista = generarSimbolosMetodo(nodo.ChildNodes[2], lista, ambitos);
}
else
{
ambitos.addIf();
lista = generarSimbolosMetodo(nodo.ChildNodes[1], lista, ambitos);
ambitos.ambitos.Pop();
lista = generarSimbolosMetodo(nodo.ChildNodes[2], lista, ambitos);
lista = generarSimbolosMetodo(nodo.ChildNodes[3], lista, ambitos);
}
return(lista);
}
case Constantes.lextra:
{
//L_EXTRAS.Rule = MakeStarRule(L_EXTRAS, EXTRA);
foreach (ParseTreeNode nodoHijo in nodo.ChildNodes)
{
lista = generarSimbolosMetodo(nodoHijo, lista, ambitos);
}
return(lista);
}
case Constantes.extraSi:
{
//EXTRA.Rule = ToTerm(Constantes.sino_si_python) + EXPRESION + ":" + Eos + CUERPO;
ambitos.addIf();
lista = generarSimbolosMetodo(nodo.ChildNodes[1], lista, ambitos);
ambitos.ambitos.Pop();
return(lista);
}
case Constantes.sino:
{
// SI_NO.Rule = ToTerm(Constantes.sino_python) + ":" + Eos + CUERPO;
ambitos.addElse();
lista = generarSimbolosMetodo(nodo.ChildNodes[0], lista, ambitos);
ambitos.ambitos.Pop();
return(lista);
}
case Constantes.elegir:
{
// ELEGIR.Rule = ToTerm(Constantes.elegir) + EXPRESION + ":" + Eos + CUERPOELEGIR;
ambitos.addElegir();
lista = generarSimbolosMetodo(nodo.ChildNodes[1], lista, ambitos);
ambitos.ambitos.Pop();
return(lista);
}
case Constantes.x:
{
ambitos.addX();
lista = generarSimbolosMetodo(nodo.ChildNodes[2], lista, ambitos);
ambitos.ambitos.Pop();
return(lista);
}
case Constantes.cuerpoElegir:
{
int noHijos = nodo.ChildNodes.Count;
if (noHijos == 2)
{
lista = generarSimbolosMetodo(nodo.ChildNodes[0], lista, ambitos);
lista = generarSimbolosMetodo(nodo.ChildNodes[1], lista, ambitos);
}
else
{
lista = generarSimbolosMetodo(nodo.ChildNodes[0], lista, ambitos);
}
return(lista);
}
case Constantes.lcasos:
{
foreach (ParseTreeNode nodoHijo in nodo.ChildNodes)
{
lista = generarSimbolosMetodo(nodoHijo, lista, ambitos);
}
return(lista);
}
case Constantes.defecto:
{
//DEFECTO.Rule = ToTerm(Constantes.defecto) + ":" + Eos + CUERPO;
ambitos.addDefecto();
lista = generarSimbolosMetodo(nodo.ChildNodes[0], lista, ambitos);
ambitos.ambitos.Pop();
return(lista);
}
case Constantes.caso:
{
//CASO.Rule = EXPRESION + TtoTerm(":") + Eos + CUERPO;
ambitos.addCaso();
lista = generarSimbolosMetodo(nodo.ChildNodes[1], lista, ambitos);
ambitos.ambitos.Pop();
return(lista);
}
case Constantes.loop:
{
//LOOP.Rule = ToTerm(Constantes.loop) + ":" + Eos + CUERPO;
ambitos.addLoop();
lista = generarSimbolosMetodo(nodo.ChildNodes[0], lista, ambitos);
ambitos.ambitos.Pop();
return(lista);
}
case Constantes.para:
{
//PARA.Rule = ToTerm(Constantes.para) + "[" + ASIGNACION + ":" + EXPRESION + ":" + EXPRESION + "]" + ":" + Eos + CUERPO;
ambitos.addPara();
lista = generarSimbolosMetodo(nodo.ChildNodes[3], lista, ambitos);
ambitos.ambitos.Pop();
return(lista);
}
case Constantes.hacer:
{
//HACER.Rule = ToTerm(Constantes.hacer) + ":" + Eos + CUERPO + Constantes.mientras + EXPRESION + Eos;
ambitos.addHAcer();
lista = generarSimbolosMetodo(nodo.ChildNodes[0], lista, ambitos);
ambitos.ambitos.Pop();
return(lista);
}
case Constantes.repetir:
{
//REPETIR.Rule = ToTerm(Constantes.repetir) + ":" + Eos + CUERPO + Constantes.hasta + EXPRESION+Eos;
ambitos.addRepetir();
lista = generarSimbolosMetodo(nodo.ChildNodes[0], lista, ambitos);
ambitos.ambitos.Pop();
return(lista);
}
case Constantes.asignacion:
{
break;
}
case Constantes.cuerpo:
{
if (nodo.ChildNodes.Count > 0)
{
return(generarSimbolosMetodo(nodo.ChildNodes[0], lista, ambitos));
}
else
{
return(lista);
}
}
case Constantes.instrucciones:
{
foreach (ParseTreeNode nodoHijo in nodo.ChildNodes)
{
lista = generarSimbolosMetodo(nodoHijo, lista, ambitos);
}
return(lista);
}
case Constantes.instruccion:
{
return(generarSimbolosMetodo(nodo.ChildNodes[0], lista, ambitos));
}
case Constantes.continuar:
{
break;
}
case Constantes.salir:
{
break;
}
case Constantes.declaracion:
{
/*DECLAARREGLO.Rule = identificador + POSICIONES;
*
* DECLRACION.Rule = TIPO + L_IDS
| TIPO + DECLAARREGLO;
| POSICION.Rule = ToTerm("[") + EXPRESION + "]";
|
| POSICIONES.Rule = MakePlusRule(POSICIONES, POSICION);
|
*/
string tipo = nodo.ChildNodes[0].ChildNodes[0].Token.ValueString;
if (nodo.ChildNodes[1].Term.Name.Equals(Constantes.lposiciones, StringComparison.OrdinalIgnoreCase))
{ //es un arreglo
//1. validar que todas las posiciones sean un int
Simbolo nuevo;
listaDimensiones lDim;
string nombreArreglo = nodo.ChildNodes[1].ChildNodes[0].Token.Value.ToString();
ParseTreeNode nodoPos = nodo.ChildNodes[1].ChildNodes[1];
bool bandera = true;
foreach (ParseTreeNode n in nodoPos.ChildNodes)
{
bandera = bandera && (n.ChildNodes[0].Term.Name.Equals(Constantes.tipoEntero, StringComparison.OrdinalIgnoreCase));
}
if (bandera)
{
List <int> valores = new List <int>();
foreach (ParseTreeNode n in nodoPos.ChildNodes)
{
int g = int.Parse(n.ChildNodes[0].ChildNodes[0].Token.ValueString); // (n.Term.Name.Equals(Constantes.tipoEntero, StringComparison.OrdinalIgnoreCase));
apuntador++;
valores.Add(g);
}
lDim = new listaDimensiones(valores);
int linealizado = lDim.getLinealizado();
nuevo = new Simbolo(Constantes.noTieneVisi, nombreArreglo, tipo, Constantes.ARREGLO, ambitos.ambitos.Peek(), "arreglo local", apuntador, linealizado, valores.Count, lDim);
lista.Add(nuevo);
}
else
{
ErrorA n = new ErrorA(Constantes.errorSemantico, "Unicamente se aceptan enteros para dimensinoes de arreglos", nodo.FindToken());
Form1.errores.addError(n);
}
}
else
{ //idnomarmal
string nombre;
Simbolo nuevo;
foreach (ParseTreeNode item in nodo.ChildNodes[1].ChildNodes)
{
nombre = item.Token.ValueString;
if (getTipoAtributo(tipo).Equals(Constantes.OBJETO, StringComparison.OrdinalIgnoreCase))
{
nuevo = new Simbolo(Constantes.noTieneVisi, nombre, tipo, getTipoAtributo(tipo), ambitos.getAmbito(), Constantes.varLocal, apuntador, 1);
this.apuntador++;
}
else
{
nuevo = new Simbolo(Constantes.noTieneVisi, nombre, tipo, getTipoAtributo(tipo), ambitos.getAmbito(), Constantes.varLocal, apuntador, 1);
this.apuntador++;
}
lista.Add(nuevo);
}
}
return(lista);
}
case Constantes.mientras:
{
ambitos.addWhile();
//MIENTRAS.Rule = ToTerm(Constantes.mientras) + EXPRESION+":" + Eos + CUERPO;
lista = generarSimbolosMetodo(nodo.ChildNodes[1], lista, ambitos);
ambitos.ambitos.Pop();
return(lista);
}
}
return(lista);
}
public clasesDiagrama agregarHerencia()
{
clasesDiagrama umlRetorno = new clasesDiagrama();
Clase actual;
for (int i = 0; i < listaClases.Count; i++)
{
actual = listaClases.ElementAt(i);
if (actual.herencia != null)
{//posee herencia
Clase clasePadre = getClase(actual.herencia);
Clase temporal = new Clase();
if (clasePadre.lenguaje.Equals(actual.lenguaje, StringComparison.OrdinalIgnoreCase))
{
// buscamos todos los atributos que sean validos
temporal.nombre = actual.nombre;
temporal.herencia = actual.herencia;
temporal.lenguaje = actual.lenguaje;
temporal.tamanho = actual.tamanho;
temporal.apuntador = actual.apuntador;
//atributos de la clase padre
foreach (Atributo atrTemp in clasePadre.atributos.atributos)
{
Atributo nuevo = esValidoAtriHerencia(atrTemp, temporal.nombre);
Atributo nuevoSuper = esPadreValidoAtriHerencia(atrTemp, temporal.nombre);
if (nuevo != null && nuevoSuper != null)
{
temporal.addAtributo(nuevoSuper);
temporal.addAtributo(nuevo);
}
}
//agregamos los atributos de la clase ya que han sido guardados los de la clase padre
foreach (Atributo item in actual.atributos.atributos)
{
temporal.addAtributo(item);
}
//agregamos las funciones de la clase padre
foreach (Funcion item in clasePadre.funciones.funciones)
{
Funcion funcNueva = esValidoFuncHerencia(item, temporal.nombre);
Funcion funcNuevaPadre = esPadreValidoFuncHerencia(item, temporal.nombre);
if (funcNueva != null && funcNuevaPadre != null)
{
temporal.addFuncion(funcNuevaPadre);
temporal.addFuncion(funcNueva);
}
}
foreach (Funcion item in actual.funciones.funciones)
{
temporal.funciones.sobreEscribirFunciones(item);
}
umlRetorno.insertarClase(temporal);
}
else
{
ErrorA er = new ErrorA(Constantes.errorSemantico, 0, 0, 0, "La clase " + actual.nombre + " es de otro lenguaje a la clase " + clasePadre.nombre);
Form1.errores.addError(er);
}
}
else
{
umlRetorno.insertarClase(actual);
}
}
return(umlRetorno);
}
public EitherA(ErrorA left) : base(left)
{
}