示例#1
0
 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);
                }
            }
        }
示例#3
0
        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);
        }
示例#4
0
        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;
        }