示例#1
0
        private AFN Alternancia(AFN operando1, AFN operando2)
        {
            Estado     estadoInicial = new Estado(0);
            Transicion Opcion1       = new Transicion(estadoInicial, operando1.Inicial, "epsilon");
            Transicion Opcion2       = new Transicion(estadoInicial, operando2.Inicial, "epsilon");

            //Metiendo las transiciones
            estadoInicial.SetTransicionDer(Opcion2);
            estadoInicial.SetTransicionIzq(Opcion1);
            Estado     estadoFinal = new Estado(6); //6 -> si fuera el mas simple existente
            Transicion Opcion1F    = new Transicion(operando1.Final, estadoFinal, "epsilon");
            Transicion Opcion2F    = new Transicion(operando2.Final, estadoFinal, "epsilon");

            //Metiendo las transiciones
            operando1.Final.SetTransicionIzq(Opcion1F);
            operando2.Final.SetTransicionIzq(Opcion2F);

            AFN alternancia = new AFN();

            alternancia.Inicial = estadoInicial;
            alternancia.Final   = estadoFinal;
            alternancia.Meter_EstNormales(operando1);
            alternancia.Meter_EstNormales(operando2);

            return(alternancia);
        }
示例#2
0
        private AFN CerraduraPositiva(AFN operando)
        {
            //Operando(operando.);
            //CerraduraKleen(operando);
            Estado     estadoInicial = new Estado(0);
            Estado     estadoFinal   = new Estado(3); //3 -> si fuera el mas simple existente
            Transicion transicion    = new Transicion(estadoInicial, operando.Inicial, "epsilon");

            estadoInicial.SetTransicionIzq(transicion);
            //REPETICION
            Transicion repeticion = new Transicion(operando.Final, operando.Inicial, "epsilon");
            //UNIENDO OPERANDO CON EL FINAL
            Transicion unionFinal = new Transicion(operando.Final, estadoFinal, "epsilon");

            operando.Final.SetTransicionIzq(unionFinal);
            operando.Final.SetTransicionDer(repeticion);
            //CREANDO AFN
            AFN cerraduraPositiva = new AFN();

            cerraduraPositiva.Inicial = estadoInicial;
            cerraduraPositiva.Final   = estadoFinal;
            cerraduraPositiva.Meter_EstNormales(operando);

            return(cerraduraPositiva);
        }
示例#3
0
        public string GraphvizAFN(Stack <AFN> stackAFN)
        {
            AFN Thompson = stackAFN.Peek();

            EnOrder(Thompson.GetEstadoInicial().GetTransicionIzq());
            EnOrder(Thompson.GetEstadoInicial().GetTransicionDer());
            //  EnOrderDer(Thompson.GetEstadoInicial().GetTransicionIzq());
            return(Graficar(text));
        }
示例#4
0
        private void GenerarThompson(Token token)
        {
            switch (token.GetTipoToken())
            {
            case Token.Tipo.PUNTO:     //CONCATENACION
            {
                AFN opIzquierdo = stackAFN.Pop();
                AFN opDerecho   = stackAFN.Pop();
                AFN concat      = Concatenacion(opIzquierdo, opDerecho);
                stackAFN.Push(concat);
                break;
            }

            case Token.Tipo.PALITO_OR:      //ALTERNANCIA
            {
                AFN opIzquierdo = stackAFN.Pop();
                AFN opDerecho   = stackAFN.Pop();
                AFN alternancia = Alternancia(opIzquierdo, opDerecho);
                stackAFN.Push(alternancia);
                break;
            }

            //case Token.Tipo.OP_SUMA: //CERRADURA POSITIVA
            //    {
            //        AFN clonar = stackAFN.Pop();
            //        AFN kleen = CerraduraKleen(clonar);
            //        AFN nuevo = ObjectExtension.CopyObject<AFN>(clonar);
            //        AFN concat = Concatenacion(nuevo, kleen);
            //        stackAFN.Push(concat);
            //        break;
            //    }
            case Token.Tipo.ASTERISCO:     //CERRADURA DE KLEEN
            {
                AFN kleen = CerraduraKleen(stackAFN.Pop());
                stackAFN.Push(kleen);
                break;
            }

            case Token.Tipo.PREGUNTA_CIERRE:     //APARICION
            {
                AFN aparicion = Aparicion(stackAFN.Pop());
                stackAFN.Push(aparicion);
                break;
            }

            default:
            {         //operando
                AFN thompson_simple = Operando(token.GetValorToken());
                stackAFN.Push(thompson_simple);
                break;
            }
            }
        }
示例#5
0
        private void Meter_EstNormales(AFN estados)
        { //METE TODOS LOS ESTADOS QUE TIENE UN AFN A LOS ESTADOS NORMALES DE OTRO AFN
            int contador = 2;

            Inicial.SetNumeroEstado(0);
            estados.Inicial.SetNumeroEstado(1);
            conjuntoEst_Normales.Add(estados.Inicial);
            foreach (var item in estados.conjuntoEst_Normales)
            {
                item.SetNumeroEstado(contador);
                contador++;
                conjuntoEst_Normales.Add(item);
            }
            estados.Final.SetNumeroEstado(contador);
            conjuntoEst_Normales.Add(estados.Final);
        }
示例#6
0
        private AFN Concatenacion(AFN operando1, AFN operando2) // S1 ---tran1_2--->> S2 ---tran2_3--->> S3
        {
            //MODIFICAR TRANSICION: LOS QUE APUNTAN A ULTIMO YA NO LO HACEN
            Transicion cambioIzq = operando1.GetEstadoInicial().GetTransicionIzq();
            Transicion cambioDer = operando1.GetEstadoInicial().GetTransicionDer();

            if (cambioIzq != null && cambioIzq.GetSegundo() == operando1.GetEstadoFinal())
            {
                cambioIzq.SetSegundoEstado(operando2.GetEstadoInicial());
            }
            if (cambioDer != null && cambioDer.GetSegundo() == operando1.GetEstadoFinal())
            {
                cambioDer.SetSegundoEstado(operando2.GetEstadoInicial());
            }
            foreach (var estado in operando1.GetListaEstados())
            {
                cambioIzq = estado.GetTransicionIzq();
                cambioDer = estado.GetTransicionDer();
                if (cambioIzq != null && cambioIzq.GetSegundo() == operando1.GetEstadoFinal())
                {
                    cambioIzq.SetSegundoEstado(operando2.GetEstadoInicial());
                }
                if (cambioDer != null && cambioDer.GetSegundo() == operando1.GetEstadoFinal())
                {
                    cambioDer.SetSegundoEstado(operando2.GetEstadoInicial());
                }
            }
            //LO UNICO QUE HAY QUE HACER ES UNIR EL ULTIMO DEL PRIMERO CON EL PRIMERO DEL ULTIMO
            operando1.Final = operando2.Inicial;
            AFN concatenacion = new AFN();

            concatenacion.Inicial = operando1.Inicial;
            concatenacion.Final   = operando2.Final;

            //METIENDO EL RESTO DE ESTADOS AFN NUMERO 1
            foreach (var estado in operando1.GetListaEstados())
            {
                concatenacion.GetListaEstados().Add(estado);
            }
            concatenacion.GetListaEstados().Add(operando1.Final);
            //METIENDO EL RESTO DE ESTADOS AFN NUMERO 2
            foreach (var estado in operando2.GetListaEstados())
            {
                concatenacion.GetListaEstados().Add(estado);
            }
            return(concatenacion);
        }
示例#7
0
        public string[] CrearAFD()
        {
            string[] hola       = new string[2];
            AFN      automataAF = stackAFN.Peek();
            AFD      automata   = new AFD(automataAF, automataAF.GetListaTerminales(), listaConjuntos);

            automata.CrearAFD();
            hola[0] = automata.GenerarGraphvizAFD();
            hola[1] = automata.GenerarGraphivizAFDTabla();
            foreach (var item in cadenas)
            {
                if (item.GetNombre().Equals(expresion.GetNombre()))
                {
                    Form1.textConsola += automata.validarCadena(item);
                }
            }
            return(hola);
        }
示例#8
0
        //ESTE SE VUELVE UNA HOJA
        private AFN Operando(string simbolo) // S1 --- transicion(simbolo) --- >> S2
        {
            //ELEMENTOS DEL AFN
            Estado     estado1    = new Estado(0);
            Estado     estado2    = new Estado(1);
            Transicion transicion = new Transicion(estado1, estado2, simbolo);

            //LLENANDO LISTA DE TERMINALES

            estado1.SetTransicionIzq(transicion); //el primero debe saber a donde jodidos va
            //CREANDO EL AFN
            AFN operando = new AFN();

            operando.Inicial = estado1;
            operando.Final   = estado2;
            //operando.conjuntoEst_Aceptacion.Add(estado2);

            return(operando);
        }
示例#9
0
        private AFN Aparicion(AFN operando)
        {
            Estado     estadoInicial = new Estado(0);
            Estado     estadoFinal   = new Estado(3); //3 -> si fuera el mas simple existente
            Transicion transicion    = new Transicion(estadoInicial, operando.Inicial, "epsilon");
            //QUE NO APAREZCA NADA
            Transicion inicial_final = new Transicion(estadoInicial, estadoFinal, "epsilon");

            estadoInicial.SetTransicionIzq(transicion);
            estadoInicial.SetTransicionDer(inicial_final);
            //UNIENDO OPERANDO CON EL FINAL
            Transicion unionFinal = new Transicion(operando.Final, estadoFinal, "epsilon");

            operando.Final.SetTransicionIzq(unionFinal);
            //CREANDO AFN
            AFN aparicion = new AFN();

            aparicion.Inicial = estadoInicial;
            aparicion.Final   = estadoFinal;
            aparicion.Meter_EstNormales(operando);

            return(aparicion);
        }
示例#10
0
 public AFD(AFN automata, List <string> listaTerminales, Dictionary <string, Conjunto> listaConjuntos)
 {
     automataND           = automata;
     this.listaTerminales = listaTerminales;
     this.listaConjuntos  = listaConjuntos;
 }
示例#11
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;
                }
                }
            }
        }
示例#12
0
        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;
        }