//FINALIZA LA PARTE DEL MENU ARCHIVO
private void analizarToolStripMenuItem_Click(object sender, EventArgs e)
{
string linea = "";
//if(textBox.Lines)
if (textBox.Lines.Count() > 0)
{
for (int i = 0; i < textBox.Lines.Count(); i++)
{
//linea = textBox.Lines[i];
string[] partir = textBox.Lines[i].Split(' ');
//Console.WriteLine("Lineas : " + textBox.Lines.Count());
linea = AnalizadorLexico.analizarTokens(partir);
Console.WriteLine(linea);
}
//if()
// Console.WriteLine("Linea : " + linea);
// AnalizadorLexico.analizarTokens(linea);
}
}
public ComponenteLexico Analizar(bool depurar, bool Metodo)
{
AnaLex = new AnalizadorLexico();
this.Metodo = Metodo;
TrazaDerivacion = new StringBuilder();
if (this.Metodo)
{
Avanzar();
Morse();
}
else
{
Avanzar();
Latin();
}
return(Componente);
}
private void ChequearTokensRepetidosEnCadena(Terminal term)
{
if (CadenaEntrada.TieneTerminalRepetidoEnPrimerLugarErroneo(cantParentesisAbiertos))
{
if (term.Equals(Terminal.ElementoParentesisClausura()))
{
//Le sumo uno asi restauro el equilibrio
cantParentesisAbiertos++;
}
StringBuilder strbldr = new StringBuilder("Se encontro ");
strbldr.Append(EnumUtils.stringValueOf(term.Componente.Token));
strbldr.Append(" repetido.");
throw new ErrorSintacticoException(strbldr.ToString(),
AnalizadorLexico.FilaActual(),
AnalizadorLexico.ColumnaActual(),
false,
true,
false);
}
}
private void cargarInfoConsola_Click(object sender, EventArgs e)
{
String[] lineasEntradas = entradaDatosConsola.Lines;
String[] lineasSalidas = lineasEntradas;
for (int i = 0; i < lineasEntradas.Length; i++)
{
lineasSalidas[i] = i + " -> " + lineasEntradas[i];
}
salidaDatos.Lines = lineasSalidas;
Resetear();
for (int i = 0; i < lineasEntradas.Count(); i++)
{
Linea.Crear(i + 1, lineasEntradas[i]);
}
try
{
AnalizadorLexico analizador = new AnalizadorLexico();
ComponenteLexico componente = analizador.Analizar();
while (!componente.ObtenerCategoria().Equals(Categoria.FIN_DE_ARCHIVO))
{
MessageBox.Show(componente.ToString());
componente = analizador.Analizar();
}
if (ManejadorErrores.HayErrores())
{
MessageBox.Show("El proceso de compilacion ha finalizado con errores");
}
else
{
MessageBox.Show("El proceso de compilacion ha finalizado exitosamente");
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
salidaDatos.Lines = lineasSalidas.ToArray();
}
private void AnalizarLugarDeLaPilaYDescartarHastaTerminalQueCorresponda(NoTerminal nt, Terminal t, bool generaProdVacia)
{
Terminal termBuscar = BuscarTerminalApropiadoBasadoEnTopePila(nt);
//string error = CaptarMensajeErrorApropiado(nt, t);
Produccion prod = tabla.BuscarEnTablaProduccion(nt, termBuscar, false, generaProdVacia);
if (prod != null)
{
StringBuilder strbldr = new StringBuilder(string.Empty);
strbldr.Append("Se esperaba ");
strbldr.Append(termBuscar.Componente.Lexema);
throw new ErrorSintacticoException(strbldr.ToString(),
AnalizadorLexico.FilaActual(),
AnalizadorLexico.ColumnaActual(),
true,
false,
true,
true,
termBuscar
);
}
else
{
StringBuilder strbldr = new StringBuilder(string.Empty);
strbldr.Append(EnumUtils.stringValueOf(t.Componente.Token));
strbldr.Append(" no tiene lugar en la sentencia.");
throw new ErrorSintacticoException(strbldr.ToString(),
AnalizadorLexico.FilaActual(),
AnalizadorLexico.ColumnaActual(),
false,
true,
false);
}
}
public async Task <string> Compilar()
{
await Task.Yield();
this.ResultadosCompilacion.Clear();
//try
//{
//Fase 1 Analisis Lexico
Analizador analizador
= new AnalizadorLexico(this.Document, this.ResultadosCompilacion);
analizador.Analizar();
if (analizador.EsValido)
{
//Fase 2 Analisis Sintactico
analizador =
new AnalizadorSintactico((AnalizadorLexico)analizador, this.Document, this.ResultadosCompilacion);
analizador.Analizar();
if (analizador.EsValido)
{
// //Fase 4 Sintetizador
analizador =
new Sintesis((AnalizadorSintactico)analizador, this.Document, this.ResultadosCompilacion);
analizador.Analizar();
if (analizador.EsValido)
{
CodigoMaquina maquina = new CodigoMaquina((Sintesis)analizador);
maquina.Generar();
this.CodigoMaquina = maquina.Codigo;
this.Compilado = true;
this.CodeSegment = maquina.CodeSegment;
return("Compilación exitosa");
}
}
}
this.Compilado = false;
return("Se encontrarón errores previos a la compilación\n");
}
public AnalizadorSintactico(AnalizadorLexico Lexica, TextDocument Documento, ResultadosCompilacion Errores) : base(Documento, Errores)
{
this.Lexica = Lexica;
this.CodeSegment = new CodeSegment();
}
public AnalizadorSintactico(string src)
{
this.source = src;
al = new AnalizadorLexico(this.source);
}
internal void CargarAnalizadorLexicografico(string texto)
{
AnalizadorLexico.CargarTexto(texto);
}
private void RellenarCadenaEntrada()
{
if (!finArch)
{
Terminal t = Terminal.ElementoVacio();
while ((CadenaEntrada.Count < cantElementosCadenaEntrada) && (!t.Equals(Terminal.ElementoEOF())))
{
t = new Terminal();
t.Componente = AnalizadorLexico.ObtenerProximoToken();
//Controlo que no haya un error lexico en el token que acabo de traer.
//Si hay error directamente me salteo el paso, no se inserta en la cadena, y no toco la pila.
if (t.Equals(Terminal.ElementoError()))
{
//throw new ErrorLexicoException(string.Format("El caracter {0} no es reconocido por el lenguaje GarGar", t.Componente.Lexema), t.Componente.Fila, t.Componente.Columna);
string lexemaError;
if (string.IsNullOrEmpty(t.Componente.CaracterErroneo))
{
lexemaError = t.Componente.Lexema.Split(new char[] { ' ' })[0];
}
else
{
lexemaError = t.Componente.CaracterErroneo;
}
string errorMensaje = string.Format("El caracter {0} es invalido en este contexto", lexemaError);
if (t.Componente.Descripcion != null)
{
errorMensaje = t.Componente.Descripcion;
}
throw new ErrorLexicoException(errorMensaje, t.Componente.Fila, t.Componente.Columna);
}
if (t.Componente.Token == ComponenteLexico.TokenType.Numero)
{
if (t.Componente.Lexema.TrimStart()[0] == '-')
{
Terminal ultimoTerminal = CadenaEntrada.UltimoTerminalInsertado;
if (ultimoTerminal != null && TerminalesHelpers.EsTerminalConValor(ultimoTerminal))
{
//Para que no de error Sintactico, creo este otro token para que parezca que es una operacion negativa -
ComponenteLexico comp = new ComponenteLexico();
comp.Fila = t.Componente.Fila;
comp.Columna = t.Componente.Columna;
comp.Lexema = "-";
comp.Token = ComponenteLexico.TokenType.RestaEntero;
CadenaEntrada.InsertarTerminal(new Terminal()
{
Componente = comp
});
//Le sumo uno pq el menos ya no pertenece mas.
t.Componente.Columna++;
//Le saco el - del lexema
t.Componente.Lexema = t.Componente.Lexema.Remove(0, 1);
}
}
}
CadenaEntrada.InsertarTerminal(t);
}
if (t.Equals(Terminal.ElementoEOF()))
{
finArch = true;
}
}
}
internal List <ErrorCompilacion> AnalizarUnSoloPaso()
{
List <ErrorCompilacion> retorno = new List <ErrorCompilacion>();
if (!(CadenaEntrada.EsFinDeCadena() && Pila.EsFinDePila()))
{
RellenarCadenaEntrada();
if (Pila.ObtenerTope().GetType() == typeof(Terminal))
{
Terminal term = (Terminal)Pila.ObtenerTope();
if (CadenaEntrada.ObtenerPrimerTerminal().Equals(Pila.ObtenerTope()))
{
if (term.Componente.Token == ComponenteLexico.TokenType.ParentesisApertura)
{
cantParentesisAbiertos++;
}
else if (term.Componente.Token == ComponenteLexico.TokenType.ParentesisClausura)
{
cantParentesisAbiertos--;
}
//flanzani 8/1/2012
//tokens repetidos
//Antes de pasar por el semantico, lo que hago es fijarme si el terminal justo no esta repetido,
//pq eso me caga todo el parseo de errores del sintactico
//Esto puede arrojar una excepcion sintactica
ChequearTokensRepetidosEnCadena(term);
if (HabilitarSemantico)
{
retorno = ArbolSemantico.CalcularAtributos(CadenaEntrada.ObtenerPrimerTerminal());
}
Pila.DescartarTope();
GlobalesCompilador.UltFila = CadenaEntrada.ObtenerPrimerTerminal().Componente.Fila;
GlobalesCompilador.UltCol = CadenaEntrada.ObtenerPrimerTerminal().Componente.Columna;
EstadoSintactico.AgregarTerminal(term);
CadenaEntrada.EliminarPrimerTerminal();
}
else
{
if (term.NoEsLambda())
{
StringBuilder strbldr = new StringBuilder(string.Empty);
strbldr.Append("Se esperaba ");
strbldr.Append(EnumUtils.stringValueOf(term.Componente.Token));
strbldr.Append(" pero se encontro ");
strbldr.Append(EnumUtils.stringValueOf(CadenaEntrada.ObtenerPrimerTerminal().Componente.Token));
strbldr.Append(".");
if (term.Equals(Terminal.ElementoFinSentencia()))
{
//Descarto el ; de la pila pq asumo que simplemente se le olvido
strbldr.Append(" Se asume fin de sentencia para continuar con analisis.");
}
throw new ErrorSintacticoException(strbldr.ToString(),
AnalizadorLexico.FilaActual(),
AnalizadorLexico.ColumnaActual(),
true,
false,
false);
}
else
{
retorno = AnalizarPila();
}
}
}
else
{
retorno = AnalizarPila();
}
}
return(retorno);
}
private void aNALIZARToolStripMenuItem_Click(object sender, EventArgs e)
{
try
{
if (escritorsql.TEXTO() != null)
{
String miText = escritorsql.TEXTO();
if (escritorsql.TEXTOSELECCIONADO().Length > 0)
{
miText = escritorsql.TEXTOSELECCIONADO();
}
AnalizadorLexico lexico = new AnalizadorLexico();
//AnalizadorSintactico sintaxis = new AnalizadorSintactico();
tokens = lexico.ObtenerTokens(miText);
tokensAnalizar = lexico.tokensAnalizar;
errores = lexico.Errores;
Console.WriteLine("\n tama;o de tokens analizar " + tokensAnalizar.Count);
if (errores.Count() > 0)
{
vERTABLASToolStripMenuItem.Enabled = false;
}
else
{
vERTABLASToolStripMenuItem.Enabled = true;
}
for (int i = 0; i < tokens.Count(); i++)
{
Token miToken = tokens[i];
Console.WriteLine("Lexema: " + miToken.Lexema + " Token: " + miToken.Token1 + " Tipo: " + miToken.Tipo + " Color" + miToken.Color + " Fila" + miToken.Fila + " Columna" + miToken.Columna);
}
Console.WriteLine("\n ========iniciando analizador sintactico=============");
AnalizadorSintactico sintactico = new AnalizadorSintactico(tokensAnalizar);
sintactico.Tablas = tablas;
sintactico.analizar();
erroresSintacticos = sintactico.Errores;
escritorsql.InsertarErrores(erroresSintacticos);
Arbol arbol = new Arbol();
arbol.ImprimirNodos(sintactico.Principal, 1);
graficador.Raiz = sintactico.Principal;
// tokensAnalizar.Clear();
escritorsql.InsertarTexto(lexico.TokensArchivo);
if (erroresSintacticos.Count > 0 || errores.Count > 0)
{
vERTABLASToolStripMenuItem.Enabled = false;
bntArbol.Enabled = false;
}
else
{
vERTABLASToolStripMenuItem.Enabled = true;
bntArbol.Enabled = true;
}
}
}
catch (Exception ex)
{
MessageBox.Show("Debe Cargar un archivo primero");
Console.WriteLine(ex);
}
}
