public void EjecutarDeclaracion(Simbolo global)
{
FExpresion expresion = (FExpresion)global.Objeto;
if (expresion != null)
{
NodoExpresion valor = expresion.ResolverExpresion(expresion.Incerteza, expresion.RutaArchivo);
if (TitusNotifiaciones.ContarErrores() == 0)
{
if (global.Tipo == Constante.TString)
{
if (valor.Tipo == Constante.TString || valor.Tipo == Constante.TNumber || valor.Tipo == Constante.TBool)
{
valor.Tipo = valor.Tipo;
TablaVariables.Tabla.Add(new Variables(global.Tipo, global.Nombre, Constante.TVariable, valor, null, global.Fila, global.Columna));
}
else
{
TabError error = new TabError();
error.InsertarFila(Constante.ErroEjecucion, "No se puede asignar una variable de tipo " + global.Tipo + " un valor " + valor.Tipo, global.RutaArchivo, global.Fila.ToString(), global.Columna.ToString());
TitusNotifiaciones.setDatosErrores(error);
}
}
else if (global.Tipo == Constante.TNumber)
{
if (valor.Tipo == Constante.TNumber || valor.Tipo == Constante.TBool)
{
valor.Tipo = valor.Tipo;
TablaVariables.Tabla.Add(new Variables(global.Tipo, global.Nombre, Constante.TVariable, valor, null, global.Fila, global.Columna));
}
else
{
TabError error = new TabError();
error.InsertarFila(Constante.ErroEjecucion, "No se puede asignar una variable de tipo " + global.Tipo + " un valor " + valor.Tipo, global.RutaArchivo, global.Fila.ToString(), global.Columna.ToString());
TitusNotifiaciones.setDatosErrores(error);
}
}
else if (global.Tipo == Constante.TBool)
{
if (valor.Tipo == Constante.TBool)
{
valor.Tipo = valor.Tipo;
TablaVariables.Tabla.Add(new Variables(global.Tipo, global.Nombre, Constante.TVariable, valor, null, global.Fila, global.Columna));
}
else
{
TabError error = new TabError();
error.InsertarFila(Constante.ErroEjecucion, "No se puede asignar una variable de tipo " + global.Tipo + " un valor " + valor.Tipo, global.RutaArchivo, global.Fila.ToString(), global.Columna.ToString());
TitusNotifiaciones.setDatosErrores(error);
}
}
}
}
else
{
TablaVariables.Tabla.Add(new Variables(global.Tipo, global.Nombre, Constante.TVariable, null, null, global.Fila, global.Columna));
}
}
public void EjecutarRetorno(Simbolo retorno)
{
if (retorno.Objeto != null)
{
FExpresion aux = (FExpresion)retorno.Objeto;
NodoExpresion val = aux.ResolverExpresion(retorno.Ambito.Incerteza, retorno.Ambito.RutaArchivo);
if (TitusNotifiaciones.ContarErrores() == 0)
{
TablaVariables.Tabla.Add(new Variables(Constante.TRetorno, Constante.TRetorno, Constante.TRetorno, val, null, retorno.Fila, retorno.Columna));
}
}
else
{
TablaVariables.Tabla.Add(new Variables(Constante.TRetorno, Constante.TRetorno, Constante.TRetorno, null, null, retorno.Fila, retorno.Columna));
}
}
public void BuscarErroresAmbitos(Simbolo simbolo, String archivo, Double Incerteza, String rutaimagen)
{
simbolo.RutaArchivo = archivo;
if (simbolo.Ambito != null)
{
simbolo.Ambito.Incerteza = Inicio.Global.Incerteza;
simbolo.Ambito.RutaImagenes = Inicio.Global.RutaImagenes;
simbolo.Ambito.RutaArchivo = Inicio.Ruta;
foreach (Simbolo s in simbolo.Ambito.TablaSimbolo)
{
BuscarErroresAmbitos(s, archivo, Incerteza, rutaimagen);
}
}
switch (simbolo.Rol)
{
case Constante.DECLARACION:
if (simbolo.Objeto != null)
{
FExpresion expdecla = (FExpresion)simbolo.Objeto;
expdecla.RutaArchivo = archivo;
expdecla.RutaImagen = rutaimagen;
expdecla.Incerteza = Incerteza;
}
break;
case Constante.ASIGNACION:
if (simbolo.Objeto != null)
{
FExpresion expdecla = (FExpresion)simbolo.Objeto;
expdecla.RutaArchivo = archivo;
expdecla.RutaImagen = rutaimagen;
expdecla.Incerteza = Incerteza;
}
break;
case Constante.LLAMADA_FUNCION:
if (simbolo.Objeto != null)
{
FLlamada fllamada = (FLlamada)simbolo.Objeto;
fllamada.RutaArchivo = archivo;
fllamada.RutaImagen = rutaimagen;
fllamada.Incerteza = Incerteza;
foreach (FExpresion parametro in fllamada.Parametros)
{
parametro.RutaArchivo = archivo;
parametro.RutaImagen = rutaimagen;
parametro.Incerteza = Incerteza;
}
if (fllamada.Ambito != null)
{
foreach (Simbolo s in fllamada.Ambito.TablaSimbolo)
{
BuscarErroresAmbitos(s, archivo, Incerteza, rutaimagen);
}
}
}
break;
case Constante.TRetorno:
if (simbolo.Objeto != null)
{
FExpresion fretorno = (FExpresion)simbolo.Objeto;
fretorno.Incerteza = Incerteza;
fretorno.RutaArchivo = archivo;
fretorno.RutaImagen = rutaimagen;
}
break;
case Constante.TSi:
if (simbolo.Objeto != null)
{
FSi fsi = (FSi)simbolo.Objeto;
fsi.RutaArchivo = archivo;
fsi.RutaImagen = rutaimagen;
fsi.Incerteza = Incerteza;
fsi.Condicion.RutaArchivo = archivo;
fsi.Condicion.RutaImagen = rutaimagen;
fsi.Condicion.Incerteza = Incerteza;
if (fsi.Sino != null)
{
foreach (Simbolo s in fsi.Sino.TablaSimbolo)
{
BuscarErroresAmbitos(s, archivo, Incerteza, rutaimagen);
}
}
}
break;
case Constante.TSelecciona:
if (simbolo.Objeto != null)
{
FSelecciona fselecciona = (FSelecciona)simbolo.Objeto;
fselecciona.RutaArchivo = archivo;
fselecciona.RutaImagen = rutaimagen;
fselecciona.Incerteza = Incerteza;
if (fselecciona.Ambito != null)
{
foreach (Simbolo s in fselecciona.Ambito.TablaSimbolo)
{
BuscarErroresAmbitos(s, archivo, Incerteza, rutaimagen);
}
}
if (fselecciona.Expresion != null)
{
fselecciona.Expresion.RutaArchivo = archivo;
fselecciona.Expresion.RutaImagen = rutaimagen;
fselecciona.Expresion.Incerteza = Incerteza;
}
if (fselecciona.Casos != null)
{
foreach (FCaso caso in fselecciona.Casos)
{
caso.RutaArchivo = archivo;
caso.RutaImagen = rutaimagen;
caso.Incerteza = Incerteza;
if (caso.ambito != null)
{
foreach (Simbolo s in caso.ambito.TablaSimbolo)
{
BuscarErroresAmbitos(s, archivo, Incerteza, rutaimagen);
}
}
}
}
if (fselecciona.Defecto != null)
{
fselecciona.Defecto.RutaArchivo = archivo;
fselecciona.Defecto.RutaImagen = rutaimagen;
fselecciona.Defecto.Incerteza = Incerteza;
if (fselecciona.Defecto.ambito != null)
{
foreach (Simbolo s in fselecciona.Defecto.ambito.TablaSimbolo)
{
BuscarErroresAmbitos(s, archivo, Incerteza, rutaimagen);
}
}
}
}
break;
case Constante.TPara:
if (simbolo.Objeto != null)
{
FPara fpara = (FPara)simbolo.Objeto;
fpara.Incerteza = Incerteza;
fpara.RutaArchivo = archivo;
fpara.RutaImagen = rutaimagen;
if (fpara.Condicion != null)
{
fpara.Condicion.Incerteza = Incerteza;
fpara.Condicion.RutaArchivo = archivo;
fpara.Condicion.RutaImagen = rutaimagen;
}
if (fpara.Declaracion != null)
{
foreach (Simbolo s in fpara.ambito.TablaSimbolo)
{
BuscarErroresAmbitos(s, archivo, Incerteza, rutaimagen);
}
}
}
break;
case Constante.THasta:
if (simbolo.Objeto != null)
{
FHasta fhasta = (FHasta)simbolo.Objeto;
if (fhasta.Condicion != null)
{
fhasta.Condicion.Incerteza = Incerteza;
fhasta.Condicion.RutaArchivo = archivo;
fhasta.Condicion.RutaImagen = rutaimagen;
}
if (fhasta.ambito != null)
{
foreach (Simbolo s in fhasta.ambito.TablaSimbolo)
{
BuscarErroresAmbitos(s, archivo, Incerteza, rutaimagen);
}
}
}
break;
case Constante.TMientras:
if (simbolo.Objeto != null)
{
FMientras fmientras = (FMientras)simbolo.Objeto;
if (fmientras.Condicion != null)
{
fmientras.Condicion.Incerteza = Incerteza;
fmientras.Condicion.RutaArchivo = archivo;
fmientras.Condicion.RutaImagen = rutaimagen;
}
if (fmientras.ambito != null)
{
foreach (Simbolo s in fmientras.ambito.TablaSimbolo)
{
BuscarErroresAmbitos(s, archivo, Incerteza, rutaimagen);
}
}
}
break;
case Constante.TDetener:
if (simbolo.Objeto != null)
{
}
break;
case Constante.TContinuar:
if (simbolo.Objeto != null)
{
}
break;
case Constante.TMostrar:
if (simbolo.Objeto != null)
{
FMostrar funcion = (FMostrar)simbolo.Objeto;
funcion.Incerteza = Incerteza;
funcion.RutaArchivo = archivo;
funcion.RutaImagen = rutaimagen;
foreach (FExpresion expmostrar in funcion.Parametros)
{
expmostrar.Incerteza = Incerteza;
expmostrar.RutaImagen = rutaimagen;
expmostrar.RutaArchivo = archivo;
}
}
break;
case Constante.TDibujarAST:
if (simbolo.Objeto != null)
{
FDibujarAST funcion = (FDibujarAST)simbolo.Objeto;
funcion.Incerteza = Incerteza;
funcion.RutaArchivo = archivo;
funcion.RutaImagen = rutaimagen;
}
break;
case Constante.TDibujarEXP:
if (simbolo.Objeto != null)
{
FDibujarExpresion funcion = (FDibujarExpresion)simbolo.Objeto;
funcion.Incerteza = Incerteza;
funcion.RutaArchivo = archivo;
funcion.RutaImagen = rutaimagen;
if (funcion.Expresion != null)
{
funcion.Expresion.Incerteza = Incerteza;
funcion.Expresion.RutaArchivo = archivo;
funcion.Expresion.RutaImagen = rutaimagen;
}
}
break;
}
if (simbolo.Ambito.TablaSimbolo.Count > 0)
{
foreach (Simbolo simbolo2 in simbolo.Ambito.TablaSimbolo)
{
BuscarErroresAmbitos(simbolo2, archivo, Incerteza, rutaimagen);
}
}
}
public void EjecutarFuncion(Simbolo simbolo)
{
FLlamada listaparametros = (FLlamada)simbolo.Objeto;
Variables metodo = TablaVariables.BuscarMetodo(simbolo.Nombre, listaparametros);
if (metodo != null)
{
FFuncion funcion = (FFuncion)metodo.Valor;
FLlamada llamada = (FLlamada)simbolo.Objeto;
if (funcion.Parametros.Count == llamada.Parametros.Count)
{
//metemos el return
//Variables retorno = new Variables(Constante.TRetorno, Constante.TRetorno, Constante.RETORNO, null, null, 0, 0);
//TablaVariables.Tabla.Add(retorno);
int cont = 0;
//meter variables de los parametros
while (cont < funcion.Parametros.Count && TitusNotifiaciones.ContarErrores() == 0)
{
FExpresion f = (FExpresion)llamada.Parametros[cont];
NodoExpresion resultadoparametro = f.ResolverExpresion(funcion.Incerteza, funcion.RutaArchivo);
if (TitusNotifiaciones.ContarErrores() == 0)
{
if (funcion.Parametros[cont].Tipo == resultadoparametro.Tipo)
{
Variables parametro = new Variables(funcion.Parametros[cont].Tipo, funcion.Parametros[cont].Nombre, Constante.TVariable, resultadoparametro, null, simbolo.Fila, simbolo.Columna);
TablaVariables.Tabla.Add(parametro);
}
else
{
//error de asignacion del tipo de parametro
TabError error = new TabError();
error.InsertarFila(Constante.ErroEjecucion, "Se esperaba un tipo: " + funcion.Parametros[cont].Tipo + ", no un tipo: " + resultadoparametro.Tipo, funcion.RutaArchivo, resultadoparametro.Linea.ToString(), resultadoparametro.Columna.ToString());
TitusNotifiaciones.setDatosErrores(error);
}
}
cont++;
}
//ejecuatamos el metodo
if (TitusNotifiaciones.ContarErrores() == 0)
{
Ejecutar execute = new Ejecutar();
execute.EjecutarInstrucciones(metodo.Ambito.TablaSimbolo);
//obtenemos el valor del return
if (TablaVariables.IsRetorno())
{
TablaVariables.SacarVariable();
}
execute.SacarAmbito(metodo.Ambito.TablaSimbolo);
execute.SacarAmbito(funcion.Parametros);
}
}
else
{
//error de cantidad de parametros
TabError error = new TabError();
error.InsertarFila(Constante.ErroEjecucion, "La funcion esperaba " + funcion.Parametros.Count + " parametros", funcion.RutaArchivo, simbolo.Fila.ToString(), simbolo.Columna.ToString());
TitusNotifiaciones.setDatosErrores(error);
}
}
else
{
TabError error = new TabError();
error.InsertarFila(Constante.ErroEjecucion, "No existe la funcion " + simbolo.Nombre + "()", simbolo.RutaArchivo, simbolo.Fila.ToString(), simbolo.Columna.ToString());
TitusNotifiaciones.setDatosErrores(error);
}
}
public Object RecorrerArbol(ParseTreeNode Nodo)
{
switch (Nodo.Term.Name)
{
case Constante.INICIO:
EjecutarSBS ejecucion = new EjecutarSBS();
foreach (ParseTreeNodeList hijo in (List <ParseTreeNodeList>)RecorrerArbol(Nodo.ChildNodes[0])) //enviamos a analizar el encabezado
{
if (hijo[0].Term.Name == Constante.TDefine)
{
if (hijo[1].Term.Name == "numero")
{
ejecucion.SetDefineNumber(Double.Parse(hijo[1].Token.ValueString));
}
else if (hijo[1].Term.Name == Constante.Cadena)
{
ejecucion.SetDefineRuta((String)hijo[1].Token.Value);
}
}
else if (hijo[0].Term.Name == Constante.TIncluye)
{
EIncluye incluye = new Encabezado.EIncluye(hijo[1].Token.Text + ".sbs", "");
ejecucion.AgregarIncluye(new Simbolo(incluye.Archivo, Constante.TIncluye, Constante.Cadena, hijo[1].Token.Location.Line + 1, hijo[1].Token.Location.Column + 1, null, incluye));
}
}
Ambito global = new Ambito("Global"); //creamos el ambito global para la ejecucion
global.Incerteza = ejecucion.DefineNumber;
global.RutaImagenes = ejecucion.DefineRuta;
global.TablaSimbolo = (List <Simbolo>)RecorrerArbol(Nodo.ChildNodes[1]); //enviamos a analizar el cuerpo que retornara una lista de simbolos
//asignamos el ambito padre a las instrucciones
foreach (Simbolo simbolo in global.TablaSimbolo)
{
if (simbolo.Ambito != null)
{
simbolo.Ambito.Padre = global;
}
}
ejecucion.Global = global;
return(ejecucion);
case Constante.LISTA_ENCABEZADOS:
if (Nodo.ChildNodes.Count > 0)
{
return(RecorrerArbol(Nodo.ChildNodes[0]));
}
else
{
List <ParseTreeNodeList> vacio = new List <ParseTreeNodeList>();
return(vacio);
}
case Constante.LISTA_ENCABEZADO:
List <ParseTreeNodeList> listae = new List <ParseTreeNodeList>();
foreach (ParseTreeNode hijo in Nodo.ChildNodes)
{
listae.Add((ParseTreeNodeList)RecorrerArbol(hijo));
}
return(listae);
case Constante.ENCABEZADO:
return(RecorrerArbol(Nodo.ChildNodes[0]));
case Constante.DEFINE:
return(Nodo.ChildNodes);
case Constante.INCLUYE:
return(Nodo.ChildNodes);
case Constante.LISTA_SENTENCIA:
List <Simbolo> listas = new List <Simbolo>();
foreach (ParseTreeNode hijo in Nodo.ChildNodes)
{
foreach (Simbolo s in (List <Simbolo>)RecorrerArbol(hijo))
{
listas.Add(s);
}
}
return(listas);
case Constante.SENTENCIA:
return(RecorrerArbol(Nodo.ChildNodes[0]));
case Constante.PRINCIPAL:
Ambito ambito = new Ambito(Constante.TPrincipal);
if (Nodo.ChildNodes.Count > 0)
{
//asignamos el listado de instrucciones al ambito principal
if (Nodo.ChildNodes[1].ChildNodes.Count > 0)
{
ambito.TablaSimbolo = (List <Simbolo>)RecorrerArbol(Nodo.ChildNodes[1]);
//asignamos el ambito padre a la lista de instrucciones
foreach (Simbolo simbolo in ambito.TablaSimbolo)
{
if (simbolo.Ambito != null)
{
simbolo.Ambito.Padre = ambito;
}
}
}
}
List <Simbolo> aux = new List <Simbolo>();
aux.Add(new Simbolo(Constante.TPrincipal, Constante.TPrincipal, Constante.TPrincipal, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, ambito, null));
return(aux);
case Constante.LISTA_INSTRUCCIONES:
if (Nodo.ChildNodes.Count > 0)
{
return(RecorrerArbol(Nodo.ChildNodes[0]));
}
else
{
List <Simbolo> vacio = new List <Simbolo>();
return(vacio);
}
case Constante.LISTA_INSTRUCCION:
List <Simbolo> listai = new List <Simbolo>();
foreach (ParseTreeNode hijo in Nodo.ChildNodes)
{
List <Simbolo> listhijo = (List <Simbolo>)RecorrerArbol(hijo);
foreach (Simbolo simbolo in listhijo)
{
listai.Add(simbolo);
}
}
return(listai);
case Constante.INSTRUCCION:
return(RecorrerArbol(Nodo.ChildNodes[0]));
case Constante.DECLARACION:
List <Simbolo> listadecla = new List <Simbolo>();
foreach (ParseTreeNode id in Nodo.ChildNodes[1].ChildNodes)
{
if (Nodo.ChildNodes.Count == 4)
{
listadecla.Add(new Simbolo(id.Token.ValueString, Constante.DECLARACION, Nodo.ChildNodes[0].Token.ValueString, id.Token.Location.Line + 1, id.Token.Location.Column + 1, new Ambito(id.Token.ValueString), new FExpresion(Nodo.ChildNodes[3])));
}
else
{
listadecla.Add(new Simbolo(id.Token.ValueString, Constante.DECLARACION, Nodo.ChildNodes[0].Token.ValueString, id.Token.Location.Line + 1, id.Token.Location.Column + 1, new Ambito(id.Token.ValueString), null));
}
}
return(listadecla);
case Constante.ASIGNACION:
List <Simbolo> listasigna = new List <Simbolo>();
listasigna.Add(new Simbolo(Nodo.ChildNodes[0].Token.ValueString, Constante.ASIGNACION, "", Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, new Ambito(Constante.ASIGNACION), new FExpresion(Nodo.ChildNodes[2])));
FExpresion a = (FExpresion)(listasigna[0].Objeto);
return(listasigna);
case Constante.FUNCION:
Ambito ambitof = new Ambito(Nodo.ChildNodes[1].Token.ValueString);
FFuncion ffuncion = new FFuncion();
//enviamos a recorrer si tiene parametros
if (Nodo.ChildNodes[2].ChildNodes.Count > 0)
{
foreach (ParseTreeNode hijo in Nodo.ChildNodes[2].ChildNodes[0].ChildNodes)
{
ffuncion.Parametros.Add(new Simbolo(hijo.ChildNodes[1].Token.ValueString, Constante.DECLARACION, hijo.ChildNodes[0].Token.ValueString, hijo.ChildNodes[1].Token.Location.Line + 1, hijo.ChildNodes[1].Token.Location.Column + 1, new Ambito(hijo.ChildNodes[1].Token.ValueString), null));
}
}
//asignamos el listado de instrucciones al ambito
if (Nodo.ChildNodes[3].ChildNodes.Count > 0)
{
ambitof.TablaSimbolo = (List <Simbolo>)RecorrerArbol(Nodo.ChildNodes[3]);
}
//asignamos el ambito padre a la lista de instrucciones
foreach (Simbolo simbolo in ambitof.TablaSimbolo)
{
if (simbolo.Ambito != null)
{
simbolo.Ambito.Padre = ambitof;
}
}
List <Simbolo> auxf = new List <Simbolo>();
ffuncion.Ambito = ambitof;
auxf.Add(new Simbolo(Nodo.ChildNodes[1].Token.ValueString, Constante.FUNCION, Nodo.ChildNodes[0].Token.ValueString, Nodo.ChildNodes[1].Token.Location.Line + 1, Nodo.ChildNodes[1].Token.Location.Column + 1, ambitof, ffuncion));
return(auxf);
case Constante.LLAMADA_FUNCION:
FLlamada fllamadafuncion = new FLlamada();
//enviamos a recorrer si tiene parametros
if (Nodo.ChildNodes[1].ChildNodes.Count > 0)
{
foreach (ParseTreeNode hijo in Nodo.ChildNodes[1].ChildNodes[0].ChildNodes)
{
fllamadafuncion.Parametros.Add(new FExpresion(hijo));
}
}
List <Simbolo> listllada = new List <Simbolo>();
fllamadafuncion.Ambito = new Ambito(Nodo.ChildNodes[0].Token.ValueString);
listllada.Add(new Simbolo(Nodo.ChildNodes[0].Token.ValueString, Constante.LLAMADA_FUNCION, "", Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, fllamadafuncion.Ambito, fllamadafuncion));
return(listllada);
case Constante.RETORNO:
List <Simbolo> listaretorno = new List <Simbolo>();
if (Nodo.ChildNodes.Count == 2)
{
listaretorno.Add(new Simbolo(Constante.TRetorno, Constante.TRetorno, Constante.TRetorno, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, new Ambito(Constante.TRetorno), new FExpresion(Nodo.ChildNodes[1])));
}
else
{
listaretorno.Add(new Simbolo(Constante.TRetorno, Constante.TRetorno, Constante.TRetorno, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, new Ambito(Constante.TRetorno), null));
}
return(listaretorno);
case Constante.SI:
List <Simbolo> listasi = new List <Simbolo>();
FSi fsi = new FSi();
Ambito ambitosi = new Ambito(Constante.TSi);
fsi.Condicion = new FExpresion(Nodo.ChildNodes[1]); //asignamos la condicion
if (Nodo.ChildNodes[2].ChildNodes.Count > 0)
{
List <Simbolo> listasis = (List <Simbolo>)RecorrerArbol(Nodo.ChildNodes[2]);
foreach (Simbolo hijo in listasis)
{
//agregamos el ambito padre que seria el si
hijo.Ambito.Padre = ambitosi;
//agregamos los simbolos al ambito de si
ambitosi.TablaSimbolo.Add(hijo);
}
}
if (Nodo.ChildNodes[3].ChildNodes.Count > 0)
{
fsi.Sino = new Ambito(Constante.TSino);
fsi.Sino.Padre = ambitosi;
List <Simbolo> listasino = (List <Simbolo>)RecorrerArbol(Nodo.ChildNodes[3]);
foreach (Simbolo hijo in listasino)
{
//agregamos el ambito padre que seria el sino
hijo.Ambito.Padre = fsi.Sino;
//agregamos los simbolos al ambito de sino
fsi.Sino.TablaSimbolo.Add(hijo);
}
}
listasi.Add(new Simbolo(Constante.TSi, Constante.TSi, Constante.TSi, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, ambitosi, fsi));
return(listasi);
case Constante.SINO:
List <Simbolo> listsino = (List <Simbolo>)RecorrerArbol(Nodo.ChildNodes[1]);
return(listsino);
case Constante.SELECCIONA:
List <Simbolo> listselecciona = new List <Simbolo>();
FSelecciona fselecciona = new FSelecciona();
//enviamos la expresion
fselecciona.Expresion = new FExpresion(Nodo.ChildNodes[1]);
//asignamos la lista de casos
fselecciona.Casos = (List <FCaso>)RecorrerArbol(Nodo.ChildNodes[2]);
//comprobamos si hay defecto
if (Nodo.ChildNodes[3].ChildNodes.Count > 0)
{
List <Simbolo> simbolodefecto = (List <Simbolo>)RecorrerArbol(Nodo.ChildNodes[3].ChildNodes[0].ChildNodes[1]);
Ambito ambitodefecto = new Ambito(Constante.TDefecto);
foreach (Simbolo hijo in simbolodefecto)
{
hijo.Ambito.Padre = ambitodefecto;
ambitodefecto.TablaSimbolo.Add(hijo);
}
fselecciona.Defecto = new FCaso(ambitodefecto, Constante.TDefecto, "");
}
Ambito ambitosele = new Ambito(Constante.TSelecciona);
fselecciona.Ambito = ambitosele;
listselecciona.Add(new Simbolo(Constante.TSelecciona, Constante.TSelecciona, Constante.TSelecciona, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, fselecciona.Ambito, fselecciona));
//retornamos la lsita
return(listselecciona);
case Constante.LISTA_CASOS:
List <FCaso> listacaso = new List <FCaso>();
foreach (ParseTreeNode hijo in Nodo.ChildNodes)
{
listacaso.Add((FCaso)RecorrerArbol(hijo));
}
return(listacaso);
case Constante.CASO:
Ambito ambitocaso = new Ambito(Constante.TCaso);
FCaso caso;
if (Nodo.ChildNodes[0].ChildNodes[0].Token.Terminal.ErrorAlias == Constante.Numero)
{
caso = new FCaso(ambitocaso, Constante.TNumber, Nodo.ChildNodes[0].ChildNodes[0].Token.ValueString);
}
else
{
caso = new FCaso(ambitocaso, Constante.TString, Nodo.ChildNodes[0].ChildNodes[0].Token.ValueString);
}
foreach (Simbolo hijo in (List <Simbolo>)RecorrerArbol(Nodo.ChildNodes[1]))
{
caso.ambito.TablaSimbolo.Add(hijo);
}
return(caso);
case Constante.PARA:
List <Simbolo> listapara = new List <Simbolo>();
FPara fpara = new FPara();
fpara.ambito = new Ambito(Constante.TPara);
fpara.Condicion = new FExpresion(Nodo.ChildNodes[5]);
fpara.Declaracion = new Simbolo(Nodo.ChildNodes[2].Token.ValueString, Constante.DECLARACION, Constante.TNumber, Nodo.ChildNodes[2].Token.Location.Line + 1, Nodo.ChildNodes[2].Token.Location.Column + 1, new Ambito(Constante.DECLARACION), new FExpresion(Nodo.ChildNodes[4]));
fpara.Operacion = Nodo.ChildNodes[6].Token.ValueString;
foreach (Simbolo hijo in (List <Simbolo>)RecorrerArbol(Nodo.ChildNodes[7]))
{
hijo.Ambito.Padre = fpara.ambito;
fpara.ambito.TablaSimbolo.Add(hijo);
}
listapara.Add(new Simbolo(Constante.TPara, Constante.TPara, Constante.TPara, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, fpara.ambito, fpara));
return(listapara);
case Constante.HASTA:
List <Simbolo> listahasta = new List <Simbolo>();
FHasta fhasta = new FHasta();
fhasta.ambito = new Ambito(Constante.THasta);
fhasta.Condicion = new FExpresion(Nodo.ChildNodes[1]);
foreach (Simbolo hijo in (List <Simbolo>)RecorrerArbol(Nodo.ChildNodes[2]))
{
hijo.Ambito.Padre = fhasta.ambito;
fhasta.ambito.TablaSimbolo.Add(hijo);
}
listahasta.Add(new Simbolo(Constante.THasta, Constante.THasta, Constante.THasta, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, fhasta.ambito, fhasta));
return(listahasta);
case Constante.MIENTRAS:
List <Simbolo> listamientras = new List <Simbolo>();
FMientras fmientras = new FMientras();
fmientras.ambito = new Ambito(Constante.THasta);
fmientras.Condicion = new FExpresion(Nodo.ChildNodes[1]);
foreach (Simbolo hijo in (List <Simbolo>)RecorrerArbol(Nodo.ChildNodes[2]))
{
hijo.Ambito.Padre = fmientras.ambito;
fmientras.ambito.TablaSimbolo.Add(hijo);
}
listamientras.Add(new Simbolo(Constante.TMientras, Constante.TMientras, Constante.TMientras, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, fmientras.ambito, fmientras));
return(listamientras);
case Constante.TDetener:
List <Simbolo> listadetener = new List <Simbolo>();
listadetener.Add(new Simbolo(Constante.TDetener, Constante.TDetener, Constante.TDetener, Nodo.Token.Location.Line + 1, Nodo.Token.Location.Line + 1, new Ambito(Constante.TDetener), null));
return(listadetener);
case Constante.TContinuar:
List <Simbolo> listacontinuar = new List <Simbolo>();
listacontinuar.Add(new Simbolo(Constante.TContinuar, Constante.TContinuar, Constante.TContinuar, Nodo.Token.Location.Line + 1, Nodo.Token.Location.Line + 1, new Ambito(Constante.TContinuar), null));
return(listacontinuar);
case Constante.FMOSTRAR:
FMostrar fmostrar = new FMostrar();
if (Nodo.ChildNodes.Count > 2)
{
foreach (ParseTreeNode hijo in Nodo.ChildNodes[2].ChildNodes)
{
fmostrar.Parametros.Add(new FExpresion(hijo));
}
}
fmostrar.Cadena = Nodo.ChildNodes[1].Token.ValueString;
List <Simbolo> listafmostrar = new List <Simbolo>();
listafmostrar.Add(new Simbolo(Constante.TMostrar, Constante.TMostrar, Constante.TMostrar, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, new Ambito(Constante.TMostrar), fmostrar));
return(listafmostrar);
case Constante.FDIBUJARAST:
FDibujarAST fdibujarast = new FDibujarAST();
fdibujarast.Id = Nodo.ChildNodes[1].Token.ValueString;
List <Simbolo> listafdibujarast = new List <Simbolo>();
listafdibujarast.Add(new Simbolo(Constante.TDibujarAST, Constante.TDibujarAST, Constante.TDibujarAST, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, new Ambito(Constante.TDibujarAST), fdibujarast));
return(listafdibujarast);
case Constante.FDIBUJAREXP:
FDibujarExpresion fdibujarexp = new FDibujarExpresion();
fdibujarexp.Expresion = new FExpresion(Nodo.ChildNodes[1]);
List <Simbolo> listafdibujarexp = new List <Simbolo>();
listafdibujarexp.Add(new Simbolo(Constante.TDibujarEXP, Constante.TDibujarEXP, Constante.TDibujarEXP, Nodo.ChildNodes[0].Token.Location.Line + 1, Nodo.ChildNodes[0].Token.Location.Column + 1, new Ambito(Constante.TDibujarEXP), fdibujarexp));
return(listafdibujarexp);
default:
return(null);
}
}