public void cerradura(LinkedList <Estado> T, LinkedList <Estado> EstadosRecorridos)
        {
            foreach (Estado s in T)
            {
                if (!EstadosRecorridos.Contains(s))
                {
                    EstadosRecorridos.AddLast(s);
                }
            }

            Estado t;
            int    SizeT = T.Count();

            for (int i = 0; i < SizeT; i++)
            {
                t = T.ElementAt(i);
                foreach (Transicion TempTransicion in t.getTransiciones())
                {
                    //SI ES UNA TRANSICION CON EPSILON Y ES HACIA UN ESTADO AUN NO VISITADO
                    if (TempTransicion.getIDTerminal() == -1 && !EstadosRecorridos.Contains(TempTransicion.getDestino()))
                    {
                        EstadosRecorridos.AddLast(TempTransicion.getDestino());
                        cerradura(TempTransicion.getDestino(), EstadosRecorridos);
                    }
                }
                SizeT = T.Count();
            }
        }
        public void graphAFD()
        {
            SaveFileDialog saveFile = new SaveFileDialog();

            saveFile.Filter       = "Archivo DOT (*.dot)|*.dot";
            saveFile.DefaultExt   = "dot";
            saveFile.AddExtension = true;

            saveFile.Title = "Guardar AFD";
            if (saveFile.ShowDialog() == DialogResult.OK)
            {
                FileStream   MyStream = new FileStream(saveFile.FileName, FileMode.Create, FileAccess.Write, FileShare.None);
                StreamWriter MyWriter = new StreamWriter(MyStream);
                MyWriter.WriteLine("digraph G {\n nodesep=0.3;\n ranksep=0.2;\n    margin=0.1;\n   node [shape=circle];\n  edge [arrowsize=0.8];\n");
                MyWriter.WriteLine("rankdir = LR;\n");

                foreach (Estado TempEstado in EstadosAFD)
                {
                    if (TempEstado.getAceptacion())
                    {
                        MyWriter.WriteLine(TempEstado.getID() + "[shape=doublecircle];\n");
                    }
                    foreach (Transicion TempTransicion in TempEstado.getTransiciones())
                    {
                        //FORMA a -> b [label="TerminalString"];
                        MyWriter.WriteLine(TempEstado.getID() + "->" + TempTransicion.getDestino().getID() + " [label=\"" + TempTransicion.getTerminalAFD() + "\"];\n");
                    }
                }
                MyWriter.WriteLine("}");
                MyWriter.Close();
                MyStream.Close();
                MessageBox.Show("AFD Guardado Correctamente", "Grafico", MessageBoxButtons.OK, MessageBoxIcon.Information);

                //SE MANDO COMANDO AL SHELL DEL SISTEMA
                String RutaImg = Path.GetDirectoryName(saveFile.FileName) + "\\" + Path.GetFileNameWithoutExtension(saveFile.FileName);
                String Command = "dot.exe -Tpng " + saveFile.FileName + " -o " + RutaImg + ".png";
                Program.RutasAFD.AddLast(RutaImg + ".png");
                Process cmd = new Process();
                cmd.StartInfo.FileName = "cmd.exe";
                cmd.StartInfo.RedirectStandardInput  = true;
                cmd.StartInfo.RedirectStandardOutput = true;
                cmd.StartInfo.CreateNoWindow         = false;
                cmd.StartInfo.UseShellExecute        = false;
                cmd.Start();
                cmd.StandardInput.WriteLine(Command);
                cmd.StandardInput.Flush();
                cmd.StandardInput.Close();
                cmd.WaitForExit();
                Console.WriteLine(cmd.StandardOutput.ReadToEnd());
                Console.Read();
            }
        }
        public void cerradura(Estado s, LinkedList <Estado> EstadosRecorridos)
        {
            if (!EstadosRecorridos.Contains(s))
            {
                EstadosRecorridos.AddLast(s);
            }

            foreach (Transicion TempTransicion in s.getTransiciones())
            {
                //SI ES UNA TRANSICION CON EPSILON Y ES HACIA UN ESTADO AUN NO VISITADO
                if (TempTransicion.getIDTerminal() == -1 && !EstadosRecorridos.Contains(TempTransicion.getDestino()))
                {
                    EstadosRecorridos.AddLast(TempTransicion.getDestino());
                    cerradura(TempTransicion.getDestino(), EstadosRecorridos);
                }
            }
        }
        public void mover(LinkedList <Estado> T, String Terminal, LinkedList <Estado> EstadosRecorridos)
        {
            Estado t;
            int    SizeT = T.Count();

            for (int i = 0; i < SizeT; i++)
            {
                t = T.ElementAt(i);
                foreach (Transicion TempTransicion in t.getTransiciones())
                {
                    //SI ES UNA TRANSICION CON EL TERMINAL Y ES HACIA UN ESTADO AUN NO VISITADO
                    if (getTerminalString(TempTransicion.getIDTerminal()).Equals(Terminal) && !EstadosRecorridos.Contains(TempTransicion.getDestino()))
                    {
                        EstadosRecorridos.AddLast(TempTransicion.getDestino());
                    }
                }
                SizeT = T.Count();
            }
        }
Exemplo n.º 5
0
        public void createConcatenacionAFN(AFN AFN1, AFN AFN2, LinkedList <Estado> Estados)
        {
            EstadoInicial = AFN1.getEstadoInicial();
            EstadoFinal   = AFN2.getEstadoFinal();

            //SE COMBINAN ESTADO FINAL DE AFN1 CON ESTADO INICIAL DE AFN2
            Estado TempEstado = new Estado();

            TempEstado.setID(Estado.Contador++);
            //TRANSICIONES ENTRANTES
            foreach (Estado AuxEstado in Estados)
            {
                foreach (Transicion TempTransicion in AuxEstado.getTransiciones())
                {
                    if (TempTransicion.getDestino() == AFN1.getEstadoFinal() || TempTransicion.getDestino() == AFN2.getEstadoInicial())
                    {
                        TempTransicion.setDestino(TempEstado);
                    }
                }
            }
            //TRANSICIONES SALIENTES
            foreach (Transicion TempTransicion in AFN1.getEstadoFinal().getTransiciones())
            {
                TempEstado.addTransicion((Transicion)TempTransicion.Clone());
            }
            foreach (Transicion TempTransicion in AFN2.getEstadoInicial().getTransiciones())
            {
                TempEstado.addTransicion((Transicion)TempTransicion.Clone());
            }

            //SE AÑADE NUEVO ESTADO Y SE ELIMINAN LOS DOS USADOS PARA EL NUEVO ESTADO
            Estados.Remove(AFN1.getEstadoFinal());
            Estados.Remove(AFN2.getEstadoInicial());
            Estados.AddLast(TempEstado);
            AFN1.setEstadoFinal(TempEstado);
            AFN2.setEstadoInicial(TempEstado);
        }
Exemplo n.º 6
0
        //REGRESA -1 SI NO HAY TRANSICION , DE NO SER ASI REGRESA ID DEL ESTADO DESTINO
        public int testChar(String arg1, LinkedList <Nodo> ListaNodos, LinkedList <Estado> Estados)
        {
            Nodo       TempNodo;
            Estado     TempEstado;
            int        EstadoID = 0;
            int        Largo;
            int        TransicionesSize = this.ListaTransiciones.Count;
            String     Lexema;
            Boolean    Validacion;
            Transicion TempTransicion;

            //BUSCA SI EXISTE UNA TRANSICION PARA EL LEXEMA
            for (int i = 0; i < TransicionesSize; i++)
            {
                //SE OBTIENE LA TRANSICION i DEL ESTADO ACTUAL
                TempEstado     = Estados.ElementAt(EstadoID);
                TempTransicion = TempEstado.getTransiciones().ElementAt(i);
                //OBTIENE NODO TERMINAL DE LA TRANSICION
                TempNodo = TempEstado.getNodoTerminal(ListaNodos, TempTransicion.getIDTerminal());
                //VERIFICAR SI VA VALIDAR UN TERMINAL O CONJUNTO
                if (TempNodo.getConjunto() == null)
                {
                    //SI SE VALIDA UN TERMINAL VALIDAR CUANTOS CARACTERES NECESITA
                    Largo = TempNodo.getTerminal().Length;
                    if (Largo > 1)
                    {
                        //SE VALIDA QUE HAYA LA CANTIDAD DE CARACTERES REQUERIDOS
                        if (Largo <= arg1.Length)
                        {
                            Lexema = arg1.Substring(0, Largo);
                        }
                        else
                        {
                            //SI NO RETORNAR ESTADO ID -1
                            return(-1);
                        }
                    }
                    else
                    {
                        Lexema = Char.ToString(arg1[0]);
                    }
                }
                else
                {
                    //SI NO VALIDAR UN SOLO CARACTER
                    Lexema = Char.ToString(arg1[0]);
                }

                //SE VALIDA EN EL NODO TERMINAL DE LA TRANSICION
                Validacion = TempNodo.testChar(Lexema);

                //SI LA TRANSICION LO ACEPTA , ACTUALIZAR NODO,TRANSICIONES Y Lexema
                if (Validacion)
                {
                    i                = -1;
                    EstadoID         = TempTransicion.getDestino().getID();
                    TransicionesSize = Estados.ElementAt(EstadoID).getTransiciones().Count;

                    //SE VERIFICA SI LA CADENA QUEDARA VACIA
                    if (Lexema.Length == arg1.Length)
                    {
                        return(EstadoID);
                    }
                    //SI SE ACEPTO UNA CADENA
                    else if (Lexema.Length > 1)
                    {
                        arg1 = arg1.Substring(Lexema.Length, arg1.Length);
                    }
                    //SI SE VALIDO UN CARACTER
                    else
                    {
                        arg1 = arg1.Substring(1, arg1.Length);
                    }
                }
                //SI NO SEGUIR ITERANDO EN LA TRANSICIONES
            }
            //NO EXISTE TRANSICION EN EL ESTADO PARA EL LEXEMA
            if (arg1.Length != 0)
            {
                return(-1);
            }
            return(EstadoID);
        }