public void separarLineas(String Lineas)
{
Lineas += "Ç";
String[] lines = Lineas.Split('\n');
foreach (var line in lines)
{
Leer(line);
}
if (listaErrores.Count != 0)
{
Console.WriteLine("LISTA DE ERRORES");
foreach (var Token in listaErrores)
{
Console.WriteLine(Token.GetValorToken() + "<------>" + Token.GetTipoToken());
}
}
if (listaTokens.Count != 0)
{
RecConjunto rec = new RecConjunto();
rec.ReconocerConjuntos(listaTokens);
listaER = rec.GetExpresiones();
listaCadenas = rec.GetCadenasEvaluacion();
Console.WriteLine("LISTA DE EXPRESIONES REGULARES");
foreach (var elementoG in listaER)
{
Expresiones_Regulares elemento = elementoG.Value;
Console.WriteLine("Nombre Expresion: " + elemento.GetNombre());
foreach (var item in elemento.GetTokens())
{
Console.WriteLine("Token: " + item.GetValorToken());
}
}
listaConjuntos = rec.GetConjuntos();
Console.WriteLine("LISTA DE CONJUNTOS DECLARADOS");
foreach (var conjunto in listaConjuntos)
{
Conjunto conjunto1 = conjunto.Value;
Console.WriteLine("Nombre Conjunto: " + conjunto1.GetNombre());
Console.WriteLine("Elementos: ");
byte contador = 0;
foreach (var item in conjunto1.GetElementos())
{
Console.WriteLine(contador + ". " + item);
contador++;
}
}
foreach (var Token in listaTokens)
{
Console.WriteLine(Token.GetValorToken() + "<------>" + Token.GetTipoToken());
}
}
}
private void EXPRESION()
{
Expresiones_Regulares expresion = new Expresiones_Regulares(tokenActual.GetValorToken());
emparejar(Token.Tipo.IDENTIFICADOR);
if (tokenActual.GetTipoToken() == Token.Tipo.GUION)
{
emparejar(Token.Tipo.GUION);
emparejar(Token.Tipo.MAYOR);
while (tokenActual.GetTipoToken() != Token.Tipo.PUNTO_COMA && dentroExpresion == true)
{
expresion.AñadirElemento(tokenActual);
controlToken++;
tokenActual = listaTokens.ElementAt(controlToken);
}
emparejar(Token.Tipo.PUNTO_COMA);
if (!listaER.ContainsKey(expresion.GetNombre()))
{
listaER.Add(expresion.GetNombre(), expresion);
}
}
else if (tokenActual.GetTipoToken() == Token.Tipo.DOS_PUNTOS)
{
emparejar(Token.Tipo.DOS_PUNTOS);
while (tokenActual.GetTipoToken() != Token.Tipo.PUNTO_COMA)
{
expresion.AñadirElemento(tokenActual);
controlToken++;
tokenActual = listaTokens.ElementAt(controlToken);
}
emparejar(Token.Tipo.PUNTO_COMA);
if (listaER.ContainsKey(expresion.GetNombre()))
{
listaCadenasEv.Add(expresion);
}
}
}
public string validarCadena(Expresiones_Regulares expresionEv)
{
int estadoActual = 0;
bool valido = false;
List <int> estadosFinales = new List <int>();
foreach (var item in mueves)
{
EstadoAFD estado = item.GetEstadoInicial();
if (!estadosFinales.Contains(estado.GetNombreEstadoAFD()))
{
if (estado.GetTipo() == EstadoAFD.Tipo.FINAL)
{
estadosFinales.Add(estado.GetNombreEstadoAFD());
}
}
estado = item.GetEstadoLlegada();
if (!estadosFinales.Contains(estado.GetNombreEstadoAFD()))
{
if (estado.GetTipo() == EstadoAFD.Tipo.FINAL)
{
estadosFinales.Add(estado.GetNombreEstadoAFD());
}
}
}
string impresion = "";
// Mueve mueveActual = mueveSinVacio.First();
string evaluar = expresionEv.GetTokens().Last().GetValorToken();//como es una cadena solo tiene uno
List <Mueve> listaTemp = new List <Mueve>();
if (evaluar.Length == 0 && estadosFinales.Contains(0))
{
valido = true;
}
for (int i = 0; i < evaluar.Length; i++)//evaluando letra por letra
{
listaTemp.Clear();
char letra = evaluar[i];
valido = false; //reiniciando variable
foreach (var mov in mueveSinVacio)
{
if (mov.GetEstadoInicial().GetNombreEstadoAFD() == estadoActual)
{
listaTemp.Add(mov);
}
}
//obtenemos solo los mueves que tienen de estado inicial al estado actual
List <Mueve> listOrdernada = listaTemp.OrderByDescending(o => o.GetSimbolo().Length).ToList();
Console.WriteLine("LISTA ORDENADA");
foreach (var item in listOrdernada)
{
Console.WriteLine("estadoInicial " + item.GetInicialString() + "simbolo: " + item.GetSimbolo() + " final: " + item.GetLlegadaString());
}
//los mueves se orden de mayor a menor, segun la longitud de su transicion
for (int j = 0; j < listOrdernada.Count; j++)
{
Mueve mueve = listOrdernada.ElementAt(j);
string simboloTransicion = mueve.GetSimbolo();
//bool esConjunto = true;
if (simboloTransicion.Length > 1) //cadenas mayores a uno
{
int longitud = simboloTransicion.Length + i;
if (longitud <= evaluar.Length)
{
longitud -= i;
string subCadena = evaluar.Substring(i, longitud);
Console.WriteLine("subcadena " + subCadena + " simbolo " + simboloTransicion);
if (subCadena.Equals(mueve.GetSimbolo()))
{
estadoActual = mueve.GetEstadoLlegada().GetNombreEstadoAFD();
i += subCadena.Length - 1;
valido = true;
break;
}
if (simboloTransicion.Equals("[:todo:]") && !subCadena.Equals("\\n"))
{
estadoActual = mueve.GetEstadoLlegada().GetNombreEstadoAFD();
i += subCadena.Length - 1;
valido = true;
break;
}
}
}
if (listaConjuntos.ContainsKey(simboloTransicion)) //comparando si es un conjunto
{
Conjunto conjunto = listaConjuntos[simboloTransicion];
if (conjunto.GetElementos().Contains(letra.ToString()))//iguala con algun elemento de un conjunto
{
estadoActual = mueve.GetEstadoLlegada().GetNombreEstadoAFD();
valido = true;
break;
}
}
else if (simboloTransicion == letra.ToString())
{
estadoActual = mueve.GetEstadoLlegada().GetNombreEstadoAFD();
valido = true;
break;
}
else if (simboloTransicion.Equals("[:todo:]"))
{
estadoActual = mueve.GetEstadoLlegada().GetNombreEstadoAFD();
valido = true;
break;
}
// Console.WriteLine("valida: " + valido);
}
Console.WriteLine("valida: " + valido);
//si sale del segundo for sin encontrar una coincidencia es que no se puede, y la cadena no es valida
if (valido == false)
{
break; //No vale la pena seguir evaluando la expresion entonces para
}
}
//Al salir la variable estadoActual debe ser un estado final para que la expresion sea valida
if (valido == false)
{
impresion += expresionEv.GetNombre() + ": \"" + evaluar + "\" NO ES VALIDA, para la expresion regular evaluada\n";
}
else
{
if (estadosFinales.Contains(estadoActual))
{
impresion += expresionEv.GetNombre() + ": \"" + evaluar + "\" ES VALIDA, para la expresion regular evaluada\n";
}
else
{
impresion += expresionEv.GetNombre() + ": \"" + evaluar + "\" NO ES VALIDA, para la expresion regular evaluada\n";
}
}
return(impresion);
}
public void GenerarAFN(Expresiones_Regulares expresion)
{
this.expresion = expresion;
bool suma = true;
Token token1;
List <Token> nuevaER = expresion.GetTokens().ToList();
List <Token> auxiliar = new List <Token>();
foreach (var item in nuevaER)
{
if (item.GetTipoToken() == Token.Tipo.LLAVE_APERTURA || item.GetTipoToken() == Token.Tipo.LLAVE_CIERRE)
{
}
else
{
auxiliar.Add(item);
}
}
nuevaER = auxiliar;
while (suma)
{
for (int i = 0; i < nuevaER.Count; i++)
{
token1 = nuevaER.ElementAt(i);
if (token1.GetTipoToken() == Token.Tipo.OP_SUMA)
{
suma = true;
break;
}
else
{
suma = false;
}
}
if (suma)
{
nuevaER = SustituirCerraduraPositiva(nuevaER);
}
}
foreach (var item in nuevaER)
{
Console.WriteLine(item.GetValorToken());
}
//AFN inicial = Operando("epsilon");
for (int i = nuevaER.Count - 1; i >= 0; i--)
{
GenerarThompson(nuevaER.ElementAt(i));
}
//ORDENANDO LOS ESTADOS
AFN final = stackAFN.Pop();
int contadorEst = 1;
//final = Concatenacion(inicial, final);
//stackAFN.Push(final);
final.Inicial.SetNumeroEstado(0);
foreach (var item in final.GetListaEstados())
{
item.SetNumeroEstado(contadorEst);
contadorEst++;
}
final.Final.SetNumeroEstado(contadorEst);
stackAFN.Push(final);
foreach (var token in nuevaER)
{
switch (token.GetTipoToken())
{
case Token.Tipo.PUNTO: //CONCATENACION
{
break;
}
case Token.Tipo.PALITO_OR: //ALTERNANCIA
{
break;
}
case Token.Tipo.ASTERISCO: //CERRADURA DE KLEEN
{
break;
}
case Token.Tipo.OP_SUMA: //CERRADURA POSITIVA
{
break;
}
case Token.Tipo.PREGUNTA_CIERRE: //APARICION
{
break;
}
default:
{ //operando
if (!final.listaTerminales.Contains(token.GetValorToken()))
{
final.listaTerminales.Add(token.GetValorToken());
}
break;
}
}
}
}
private void cargarTomhsonToolStripMenuItem_Click(object sender, EventArgs e)
{
ListaTokens = new LinkedList <Token>();
ListaErrores = new LinkedList <Token>();
//FALTA AGREGAR LAS IMAGENES
pictureBox1.Image = null;
pictureBox2.Image = null;
textConsola = "";
richTextBox2.Text = textConsola;
//LEE LA PESTAÑA SELECCIONADA
TabPage selectedTab = editor.SelectedTab;
if (selectedTab.Controls.ContainsKey("rtb"))
{
RichTextBox rtb = (RichTextBox)selectedTab.Controls["rtb"];
string text = rtb.Text;
Analizador = new Analizador_Lexico();
Analizador.separarLineas(text);//mandar a analizar
ListaTokens = Analizador.getlistaTokens();
ListaErrores = Analizador.getlistaErrores();
Console.WriteLine("PRUEBA THOMPSON------------------------------------------------------------");
AFN Thompson = new AFN(Analizador.GetCadenasEv(), Analizador.GetConjuntos());
if (Analizador.GetListaER() != null)
{
foreach (var item in Analizador.GetListaER())
{
Expresiones_Regulares expresion = item.Value;
Thompson.GenerarAFN(expresion);
rutaAFN = Thompson.GenerarGraphviz();
if (System.IO.File.Exists(rutaAFN))
{
listaAutomatas.Add(rutaAFN);
//Image image = Image.FromFile(rutaAFN);
//pictureBox1.Image = image;
}
//GENERANDO AFD APARTIR DE UN AFN
string[] imagenesAFD = Thompson.CrearAFD(); //posicion 0 = afd; posicion 1 = tabla afd
rutaAFD_Tabla = imagenesAFD[1];
if (System.IO.File.Exists(rutaAFD_Tabla))
{
listaTablas.Add(rutaAFD_Tabla);
System.Drawing.Image image = System.Drawing.Image.FromFile(rutaAFD_Tabla);
pictureBox2.Image = image;
}
if (System.IO.File.Exists(imagenesAFD[0]))
{
listaAutomatas.Add(imagenesAFD[0]);
System.Drawing.Image image = System.Drawing.Image.FromFile(imagenesAFD[0]);
pictureBox1.Image = image;
}
contadorIMG++;
}
}
}
richTextBox2.Text = textConsola;
contador = listaAutomatas.Count - 1;
contadorTablas = listaTablas.Count - 1;
}