public static void SincronizarSimbolo(ComponenteLexico componente)
{
if (componente != null)
{
//TablaSimbolos.Agregar(componente);
switch (componente.Tipo)
{
case TipoComponente.SIMBOLO:
if (componente.Categoria.Equals(Categoria.VARIABLE))
{
TablaSimbolos.Agregar(componente);
}
else
{
componente.Tipo = TipoComponente.LITERAL;
TablaSimbolos.Agregar(componente);
}
break;
case TipoComponente.DUMMY:
TablaDummy.Agregar(componente);
break;
case TipoComponente.LITERAL:
TablaLiterales.Agregar(componente);
break;
case TipoComponente.PALABRA_RESERVADA:
TablaLiterales.Agregar(componente);
break;
}
}
}
private void Resetear()
{
EstadorActual = 0;
ContinuarAnalisis = true;
Componente = null;
ResetearLexema();
}
public string Identar()
{
StringBuilder strBlder = new StringBuilder();
ComponenteLexico comp = analizadorLexico.ObtenerProximoToken();
while (comp.Token != ComponenteLexico.TokenType.EOF)
{
if (esNuevaLineaDiferido && GeneraLineaNuevaDiferida(comp.Token))
{
strBlder.AppendLine();
esNuevaLineaDiferido = false;
}
if (GeneraLineaSeparadora(comp.Token))
{
strBlder.AppendLine();
}
if (GeneraMenosIdentacion(comp.Token))
{
cantTabs--;
}
if (esNuevaLinea)
{
for (int i = 0; i < cantTabs; i++)
{
strBlder.Append("\t");
}
esNuevaLinea = false;
}
strBlder.Append(comp.Lexema);
strBlder.Append(" ");
if (GeneraNuevaLinea(comp.Token))
{
strBlder.AppendLine();
esNuevaLinea = true;
}
if (GeneraNuevaLineaDiferido(comp.Token))
{
esNuevaLineaDiferido = true;
}
if (GeneraMasIdentacion(comp.Token))
{
cantTabs++;
}
comp = analizadorLexico.ObtenerProximoToken();
}
return(strBlder.ToString());
}
public static ComponenteLexico SincronizarTabla(ComponenteLexico Componente)
{
if (Componente != null)
{
//Componente = TablaPalabraReservadas.ComprobarPalabraReservada(Componente);
switch (Componente.ObtenerTipo())
{
case TipoComponente.DUMMY:
TablaDummys.Agregar(Componente);
break;
case TipoComponente.PALABRA_RESERVADA:
TablaPalabraReservadas.Agregar(Componente);
break;
case TipoComponente.LITERAL:
TablaLiterales.Agregar(Componente);
break;
case TipoComponente.SIMBOLO:
TablaSimbolos.Agregar(Componente);
break;
}
}
return(Componente);
}
private void MensajeRetorno(ComponenteLexico componente)
{
if (imprimirComponente)
{
MessageBox.Show(componente.ToString());
}
}
public static void Agregar(ComponenteLexico componente)
{
if (componente != null && !componente.Lexema.Equals("") && componente.Tipo.Equals(TipoComponente.SIMBOLO))
{
ObtenerSimbolos(componente.Lexema).Add(componente);
}
}
public void formarPalabra()
{
componente = anaLex.devolverComponenteLexico();
string cadena = "";
while (!"FIN DE ARCHIVO".Equals(componente.categoria))
{
if (componente.categoria.Equals("Letra"))
{
cadena += componente.letralexema;
}
else if (componente.categoria.Equals("Espacio"))
{
cadena += componente.letralexema;
}
else if (componente.categoria.Equals("Número"))
{
cadena += componente.letralexema;
}
else if (componente.categoria.Equals("ERROR SINTACTICO"))
{
cadena += componente.letralexema;
}
componente = anaLex.devolverComponenteLexico();
}
cadenafinal = cadena;
// return cadena;
}
private void Form1_Load(object sender, EventArgs e)
{
//Resetear
Resetear();
//Cargar a cacher los datos
try
{
//Disparar el proesamiento a nivel de analizador lexico
//Cache.ObtenerCache().AgregarLinea("1");
AnalizadorLexico analisisLexico = new AnalizadorLexico();
ComponenteLexico componente = analisisLexico.Analizar();
while (!componente.ObtenerCategoria().Equals(Categoria.FIN_ARCHIVO))
{
MessageBox.Show(componente.ToString());
componente = analisisLexico.Analizar();
}
if (ManejadorErrores.HayErrores())
{
MessageBox.Show("El proceso de compilación ha finalizado con errores");
}
else
{
MessageBox.Show("El proceso de compilación ha finalizado de forma exitosa");
}
}
catch (Exception exception)
{
MessageBox.Show(exception.Message);
}
}
public void Agregar(ComponenteLexico componente)
{
if (componente != null && componente.Tipo.Equals(TipoComponenteLexico.DUMMY))
{
ObtenerListaDummys(componente.Lexema).Add(componente);
}
}
public void Agregar(ComponenteLexico componente)
{
if (componente != null && componente.Tipo.Equals(TipoComponenteLexico.COMPONENTE_LEXICO))
{
ObtenerListaSimbolos(componente.Lexema).Add(componente);
}
}
private void Resetear()
{
CaracterActual = "";
ResetearLexema();
ContinuarAnalisis = true;
EstadoActual = 0;
Componente = null;
}
public static void validarSiEsPalabraReservada(ComponenteLexico componente)
{
if (componente != null && tabla.ContainsKey(componente.Lexema))
{
componente.Tipo = TipoComponente.PALABRA_RESERVADA;
componente.Categoria = tabla[componente.Lexema].Add(TipoComponente);
}
}
public void Agregar(ComponenteLexico componente)
{
if (componente != null && componente.Tipo.Equals(TipoComponenteLexico.LITERAL))
{
Console.WriteLine("Agregando componente a tabla de Literales " + componente.Lexema);
ObtenerListaLiterales(componente.Lexema).Add(componente);
}
}
public static void Agregar(ComponenteLexico componente)
{
if (componente != null &&
!componente.ObtenerLexema().Equals("") &&
componente.ObtenerTipo().Equals(TipoComponente.DUMMY))
{
INSTANCIA.ObetenerDummy(componente.ObtenerLexema()).Add(componente);
}
}
public static void Agregar(ComponenteLexico Componete)
{
if (Componete != null &&
!Componete.ObtenerLexema().Equals("") &&
Componete.ObtenerTipo().Equals(TipoComponente.LITERAL))
{
INSTANCIA.ObtenerLiterales(Componete.ObtenerLexema()).Add(Componete);
}
}
public static void Agregar(ComponenteLexico Componete)
{
if (Componete != null &&
!Componete.ObtenerLexema().Equals("") &&
Componete.ObtenerTipo().Equals(TipoComponente.PALABRA_RESERVADA))
{
INSTANCIA.ObtenerDummys(Componete.ObtenerLexema()).Add(Componete);
}
}
public static void Agregar(ComponenteLexico componente)
{
if (componente != null &&
!componente.ObtenerLexema().Equals("") &&
componente.ObtenerTipo().Equals(TipoComponente.PALABRA_RESERVADA))
{
INSTANCIA.ObetenerSimbolo(componente.ObtenerLexema()).Add(componente);
}
}
private void cargarInfoConsola_Click_1(object sender, EventArgs e)
{
String[] lineasEntradas = entradaDatosConsola.Lines;
//salidaDatos.Lines = lineasEntradas;
Resetear();
for (int i = 0; i < lineasEntradas.Length; i++)
{
Cache.obtenerCache().AgregarLinea(lineasEntradas[i]);
}
try
{
//AnalizadorLexico analizador = new AnalizadorLexico();
AnalizadorSintactico AnaSin = new AnalizadorSintactico();
Dictionary <string, object> Resultados = AnaSin.Analizar(depurar);
ComponenteLexico Componente = (ComponenteLexico)Resultados["COMPONENTE"];
Stack <double> Pila = (Stack <double>)Resultados["PILA"];
//while (!Componente.ObtenerCategoria().Equals(Categoria.FIN_DE_ARCHIVO))
//{
// //MessageBox.Show(componente.ToString());
// Componente = analizador.Analizar();
//}
LlenarTablas();
if (ManejadorErrores.HayErrores())
{
MessageBox.Show("Hay problemas de compilacion. Revise la información de los errores encontrados...");
}
else if (Categoria.FIN_DE_ARCHIVO.Equals(Componente.ObtenerCategoria()))
{
MessageBox.Show("El programa se encuentra bien escrito");
if (Pila.Count == 1)
{
string Resultado = Convert.ToString(Pila.Pop());
MessageBox.Show("La operación arrojó como resultado: " + Resultado);
salidaDatos.Text = Resultado;
}
else
{
MessageBox.Show("Faltaron números por evaluar");
}
}
else
{
MessageBox.Show("Aunque el programa se encuentra bien escrito, faltaron componente por evaluar...");
}
}
catch (Exception ex)
{
LlenarTablas();
MessageBox.Show(ex.Message);
}
}
public static void Agregar(ComponenteLexico Componete)
{
if (Componete != null &&
!Componete.ObtenerLexema().Equals("") &&
Componete.ObtenerTipo().Equals(TipoComponente.SIMBOLO))
{
INSTANCIA.ObtenerSimbolo(Componete.ObtenerLexema()).Add(Componete);
}
}
private TablaPalabraReservadas()
{
PALABRAS_RESERVADAS.Add("String", ComponenteLexico.CrearComponentePalabraReservada("String", Categoria.STRING));
PALABRAS_RESERVADAS.Add("string", ComponenteLexico.CrearComponentePalabraReservada("string", Categoria.STRING));
PALABRAS_RESERVADAS.Add("int", ComponenteLexico.CrearComponentePalabraReservada("int", Categoria.INT));
PALABRAS_RESERVADAS.Add("Integer", ComponenteLexico.CrearComponentePalabraReservada("Integer", Categoria.INTEGER));
PALABRAS_RESERVADAS.Add("float", ComponenteLexico.CrearComponentePalabraReservada("float", Categoria.FLOAT));
PALABRAS_RESERVADAS.Add("double", ComponenteLexico.CrearComponentePalabraReservada("double", Categoria.DOUBLE));
PALABRAS_RESERVADAS.Add("boolean", ComponenteLexico.CrearComponentePalabraReservada("boolena", Categoria.BOOLEAN));
}
public static bool ValidarSiEsPalabraReservada(ComponenteLexico componente)
{
if (componente != null && tabla.ContainsKey(componente.Lexema))
{
//componente.Tipo = TipoComponente.PALABRA_RESERVADA;
componente.Categoria = tabla[componente.Lexema].Categoria;
return(true);
}
return(false);
}
public static ComponenteLexico ComprobarPalabraReservada(ComponenteLexico Componente)
{
if (Componente != null && INSTANCIA.EsPalabraReservada(Componente.ObtenerLexema()))
{
Categoria Categoria = INSTANCIA.ObtenerPalabraReservada(Componente.ObtenerLexema()).ObtenerCategoria();
ComponenteLexico NuevoComponente = ComponenteLexico.CrearComponenteSimbolo(Componente.ObtenerLexema(), Categoria, Componente.ObtenerNumeroLinea(), Componente.ObetenerPosicionInicial(), Componente.ObtenerPosicionFinal());
return(NuevoComponente);
}
return(Componente);
}
private void button1_Click(object sender, EventArgs e)
{
AnalizadorLexico anaLex = new AnalizadorLexico();
ComponenteLexico componente = anaLex.Analizar();
while (!componente.Lexema.Equals("@EOF@"))
{
anaLex.Puntero = componente.PosicionFinalLinea + 1;
anaLex.estadoActual = 0;
componente = anaLex.Analizar();
}
}
private void button1_Click_1(object sender, EventArgs e)
{
// CODIGO
AnalisisLexico analex = new AnalisisLexico();
ComponenteLexico tmp = analex.analizar();
while (!"@EOF@".Equals(tmp.Lexema))
{
MessageBox.Show(tmp.Imprimir());
tmp = analex.analizar();
}
textBoxPorConsola.Clear();
}
private void Inicializar()
{
mapaPalabrasReservadas.Add("PARA", ComponenteLexico.CREATE(0, 0, "PARA", "PALABRA RESERVADA PARA"));
mapaPalabrasReservadas.Add("DESDE", ComponenteLexico.CREATE(0, 0, "DESDE", "PALABRA RESERVADA DESDE"));
mapaPalabrasReservadas.Add("HASTA", ComponenteLexico.CREATE(0, 0, "HASTA", "PALABRA RESERVADA HASTA"));
mapaPalabrasReservadas.Add("EN", ComponenteLexico.CREATE(0, 0, "EN", "PALABRA RESERVADA EN"));
mapaPalabrasReservadas.Add("INCREMENTOS", ComponenteLexico.CREATE(0, 0, "INCREMENTOS", "PALABRA RESERVADA INCREMENTOS"));
mapaPalabrasReservadas.Add("DE", ComponenteLexico.CREATE(0, 0, "DE", "PALABRA RESERVADA DE"));
mapaPalabrasReservadas.Add("CADA", ComponenteLexico.CREATE(0, 0, "CADA", "PALABRA RESERVADA CADA"));
mapaPalabrasReservadas.Add("PASO", ComponenteLexico.CREATE(0, 0, "PASO", "PALABRA RESERVADA PASO"));
mapaPalabrasReservadas.Add("HACER", ComponenteLexico.CREATE(0, 0, "HACER", "PALABRA RESERVADA HACER"));
mapaPalabrasReservadas.Add("FIN", ComponenteLexico.CREATE(0, 0, "FIN", "PALABRA RESERVADA FIN"));
mapaPalabrasReservadas.Add("DECREMENTOS", ComponenteLexico.CREATE(0, 0, "DECREMENTOS", "PALABRA RESERVADA DECREMENTOS"));
}
private void botonCargarInfo_Click_1(object sender, EventArgs e)
{
String ruta = textRuta.Text;
StreamReader lector = new StreamReader(@"" + ruta);
List <String> lineasEntrada = new List <string>();
String lineaActual;
while ((lineaActual = lector.ReadLine()) != null)
{
lineasEntrada.Add(lineaActual);
}
salidaDatos.Lines = lineasEntrada.ToArray();
Resetear();
for (int i = 0; i < lineasEntrada.Count(); i++)
{
Cache.obtenerCache().AgregarLinea(lineasEntrada[i]);
}
try
{
AnalizadorLexico analizador = new AnalizadorLexico();
ComponenteLexico componente = analizador.Analizador(opcion);
while (!componente.ObtenerCategoria().Equals(Categoria.FIN_DE_ARCHIVO))
{
//MessageBox.Show(componente.ToString());
componente = analizador.Analizador(opcion);
}
LlenarTablas();
if (ManejadorErrores.HayErrores())
{
MessageBox.Show("Hay problemas de compilacion. Revise la información de los errores encontrados...");
}
else if (Categoria.FIN_DE_ARCHIVO.Equals(componente.ObtenerCategoria()))
{
MessageBox.Show("El programa se encuentra bien escrito");
}
else
{
MessageBox.Show("Aunque el programa se encuentra bien escrito, faltaron componente por evaluar...");
}
}
catch (Exception ex)
{
LlenarTablas();
MessageBox.Show(ex.Message);
}
}
private void AgregarComponente(ComponenteLexico componente)
{
componente.numeroLinea = numeroLineaActual;
if (componente.categoria.Equals("FIN DE ARCHIVO"))
{
componente.posicionInicial = 1;
componente.posicionFinal = 1;
}
else
{
componente.posicionInicial = puntero - componente.lexema.Length;
componente.posicionFinal = (puntero - 1);
}
TablaSimbolos.ObtenerInstancia().agregar(componente);
}
public static void SincronizarSimbolo(ComponenteLexico componente)
{
if (componente != null)
{
switch (componente.Tipo)
{
case TipoComponente.DUMMY:
TablaDummys.Agregar(componente);
break;
case TipoComponente.SIMBOLO:
TablaSimbolos.Agregar(componente);
break;
}
}
}
private void pedirComponente(String categoriaValida)
{
if (componenteLexico.Categoria.Equals(categoriaValida))
{
imprimirDerivacion();
componenteLexico = analisisLexico.analizar();
}
else
{
//Errores SQL
String causa = "Se esperaba " + categoriaValida + " y recibí " + componenteLexico.Categoria;
String falla = "Problemas en la validacion de la gramatica que no la hace valida";
String solucion = "Asegure que se tenga " + categoriaValida + " en el lugar donde se ha presentado el problema";
ManejadorErrores.obtenerManejadorErrores().agregarError(formarError(componenteLexico.Lexema, causa, falla, solucion));
}
}
private void analisis()
{
dataGridView1.Rows.Clear();
AnalizadorLexico analex = new AnalizadorLexico();
ComponenteLexico tmp = analex.Analizar();
while (!"@EOF@".Equals(tmp.Lexema))
{
int n = dataGridView1.Rows.Add();
dataGridView1.Rows[n].Cells[0].Value = tmp.Tipo;
dataGridView1.Rows[n].Cells[1].Value = tmp.Lexema;
dataGridView1.Rows[n].Cells[2].Value = tmp.NumeroLinea;
dataGridView1.Rows[n].Cells[3].Value = tmp.PosicionInicial;
dataGridView1.Rows[n].Cells[4].Value = tmp.PosicionFinal;
tmp = analex.Analizar();
}
}
