Example #1
0
        /// <summary>
        /// Translation from concatenation (dot) (rule 3)
        /// </summary>
        /// <param name="reg">the regular expression created with the RegExp class</param>
        /// <param name="automaton">the NDFA</param>
        /// <param name="stateCounter">keeps track of the next state to add</param>
        /// <param name="leftState">From state</param>
        /// <param name="rightState">To state</param>
        public static void Regel3(RegExp reg, List <Node> automaton, int stateCounter, int leftState, int rightState)
        {
            var newState = stateCounter + 1;

            stateCounter = newState;
            //node c, a dot means that there is atleast 1 new node
            automaton.Add(new Node(new List <Connection>(), "q" + newState, NodeType.NormalNode));

            ModifyAutomaat(reg.left, automaton, stateCounter, leftState, newState);   //handle left side of the dot
            ModifyAutomaat(reg.right, automaton, stateCounter, newState, rightState); //handle right side of the dot
        }
Example #2
0
        /// <summary>
        /// create a NDFA given a RegExp
        /// </summary>
        /// <param name="reg">the given RegExp</param>
        /// <returns> a list of nodes from which to create a NDFA</returns>
        public static List <Node> CreateAutomaat(RegExp reg)
        {
            List <Node> automaton = new List <Node>()                        //our list of nodes, initialized with a start and end node, they are a given for any automaton
            {
                new Node(new List <Connection>(), "q0", NodeType.StartNode), //node a
                new Node(new List <Connection>(), "q1", NodeType.EndNode)    //node b
            };

            //leftstate is initially the startnode, rightstate the endnode, statecounter keeps track of the last node in automaton
            int stateCounter = 1, leftState = 0, rightState = 1;

            ModifyAutomaat(reg, automaton, stateCounter, leftState, rightState);

            return(automaton);
        }
Example #3
0
        /// <summary>
        /// The translation of the plus operator (+) (rule 5)
        /// </summary>
        /// <param name="reg">the regular expression created with the RegExp class</param>
        /// <param name="automaton">the NDFA</param>
        /// <param name="stateCounter">keeps track of the next state to add</param>
        /// <param name="leftState">From state</param>
        /// <param name="rightState">To state</param>
        public static void Regel5(RegExp reg, List <Node> automaton, int stateCounter, int leftState, int rightState)
        {
            var newLeftState  = stateCounter + 1;
            var newRightState = newLeftState + 1;

            stateCounter = newRightState;

            //add 2 new nodes for the + operator
            automaton.Add(new Node(new List <Connection>(), "q" + newLeftState, NodeType.NormalNode));  //node c
            automaton.Add(new Node(new List <Connection>(), "q" + newRightState, NodeType.NormalNode)); //node d

            automaton[leftState].AddConnection(new Connection('ϵ', automaton[newLeftState]));           //from a to c
            automaton[newRightState].AddConnection(new Connection('ϵ', automaton[rightState]));         //from d to b
            automaton[newRightState].AddConnection(new Connection('ϵ', automaton[newLeftState]));       //from d to c

            ModifyAutomaat(reg.left, automaton, stateCounter, newLeftState, newRightState);             //a plus operator has no right side
        }
Example #4
0
        /// <summary>
        /// The translation of the star operator (*) (rule 6)
        /// </summary>
        /// <param name="reg">the regular expression created with the RegExp class</param>
        /// <param name="automaton">the NDFA</param>
        /// <param name="stateCounter">keeps track of the next state to add</param>
        /// <param name="leftState">From state</param>
        /// <param name="rightState">To state</param>
        public static void Regel6(RegExp reg, List <Node> automaton, int stateCounter, int leftState, int rightState)
        {
            var newLeftState  = stateCounter + 1;
            var newRightState = newLeftState + 1;

            stateCounter = newRightState;

            automaton.Add(new Node(new List <Connection>(), "q" + newLeftState, NodeType.NormalNode));  //node c
            automaton.Add(new Node(new List <Connection>(), "q" + newRightState, NodeType.NormalNode)); //node d

            automaton[leftState].AddConnection(new Connection('ϵ', automaton[rightState]));             //from a to b
            automaton[leftState].AddConnection(new Connection('ϵ', automaton[newLeftState]));           //from a to c
            automaton[newRightState].AddConnection(new Connection('ϵ', automaton[rightState]));         //from d to b
            automaton[newRightState].AddConnection(new Connection('ϵ', automaton[newLeftState]));       //from d to c

            //rule 6 has no right state (*) so we only need to check the left state
            ModifyAutomaat(reg.left, automaton, stateCounter, newLeftState, newRightState);
        }
Example #5
0
        /// <summary>
        /// The translation of the choice operator (or) (rule 4)
        /// </summary>
        /// <param name="reg">the regular expression created with the RegExp class</param>
        /// <param name="automaton">the NDFA</param>
        /// <param name="stateCounter">keeps track of the next state to add</param>
        /// <param name="leftState">From state</param>
        /// <param name="rightState">To state</param>
        public static void Regel4(RegExp reg, List <Node> automaton, int stateCounter, int leftState, int rightState)
        {
            //the first path to handle (left side)
            var newLeftState  = stateCounter + 1;
            var newRightState = newLeftState + 1;

            stateCounter = newRightState;

            //node c, add a new node for the or left side(the first epsilon)
            automaton.Add(new Node(new List <Connection>(), "q" + newLeftState, NodeType.NormalNode));

            //node d, the new node has a connection to automaton[rightState] with epsilon (the last epsilon)
            automaton.Add(new Node(new List <Connection>()
            {
                new Connection('ϵ', automaton[rightState])
            }, "q" + newRightState, NodeType.NormalNode));                                    //from d to b
            automaton[leftState].AddConnection(new Connection('ϵ', automaton[newLeftState])); //from a to c

            ModifyAutomaat(reg.left, automaton, stateCounter, newLeftState, newRightState);   //handle left side of the or

            //there are 2 paths to handle, this handles the second one (right side)
            newLeftState  = stateCounter + 1;
            newRightState = newLeftState + 1;
            stateCounter  = newRightState;

            //node e, add a new node for the or right side (the first epsilon)
            automaton.Add(new Node(new List <Connection>(), "q" + newLeftState, NodeType.NormalNode));

            //node f, the new node has a connection to automaton[rightState] with epsilon (the last epsilon)
            automaton.Add(new Node(new List <Connection>()
            {
                new Connection('ϵ', automaton[rightState])
            }, "q" + newRightState, NodeType.NormalNode));                                    //from f to b
            automaton[leftState].AddConnection(new Connection('ϵ', automaton[newLeftState])); //from a to e

            ModifyAutomaat(reg.right, automaton, stateCounter, newLeftState, newRightState);  //handle right side of the or
        }
Example #6
0
        public void Regexparse(string s)
        {
            Console.WriteLine("entered string: " + s);
            RegexTester tester;

            try
            {
                tester = new RegexTester(s);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                return;
            }

            string answer = new String(s.Distinct().ToArray());

            answer = new String(answer.Where(Char.IsLetter).ToArray());
            List <string> strings = GenerateStrings.GenerateString(5, answer);

            RegExp      exp  = RegexParser.parse(s);
            List <Node> ndfa = Thompson.CreateAutomaat(exp);
            NDFA        NDFAregularexpression = new NDFA(new List <Node>()
            {
                ndfa[0]
            }, ndfa);
            List <string> regexcorrect   = tester.geefTaalTotN(5, answer);
            List <string> regexincorrect = tester.geefFoutieveTaalTotN(5, answer);

            CreateGraph(NDFAregularexpression.Nodes, "REGEX_NDFA");

            DFA DFAregularexpression = NDFAtoDFA.ToDFA2(NDFAregularexpression);

            CreateGraph(DFAregularexpression.Nodes, "REGEX_DFA");

            NDFA Reverse = DFAReverse.Reverse2(DFAregularexpression);

            CreateGraph(Reverse.Nodes, "REGEX_DFA_Reverse");


            Console.WriteLine("-------- Correct words Contains --------");
            foreach (String item in regexcorrect)
            {
                Console.WriteLine(item);
            }
            Console.WriteLine("-------- incorrect words --------");
            foreach (String item in regexincorrect)
            {
                Console.WriteLine(item);
            }


            Console.WriteLine("-------- regex/ndfa/dfa/ndfa Reversed --------");
            foreach (string item in strings)
            {
                Console.WriteLine(tester.Check(item));
                Console.WriteLine(NDFAregularexpression.Check(item));
                Console.WriteLine(DFAregularexpression.Check(item));
                Console.WriteLine("reverse " + Reverse.Check(item));
            }
        }
Example #7
0
        public void HardcodedExamples()
        {
            List <string> strings = GenerateStrings.GenerateString(5, "ab");

            #region DFA
            //------------------------------- DFA -------------------------------
            Console.WriteLine("---------- DFA -------------");
            Console.WriteLine("------- hardcoded ----------");
            Console.WriteLine("---- begins with babaa -----");
            List <Node> DFA_BWB_ABAA_Nodes = new List <Node>()
            {
                new Node("q0", NodeType.StartNode),
                new Node("q1", NodeType.NormalNode),
                new Node("q2", NodeType.NormalNode),
                new Node("q3", NodeType.NormalNode),
                new Node("q4", NodeType.NormalNode),
                new Node("q5", NodeType.EndNode),
                new Node("q6", NodeType.NormalNode)
            };
            DFA_BWB_ABAA_Nodes[0].AddConnections(new List <Connection>()
            {
                new Connection('b', DFA_BWB_ABAA_Nodes[1]),
                new Connection('a', DFA_BWB_ABAA_Nodes[6])
            });
            DFA_BWB_ABAA_Nodes[1].AddConnections(new List <Connection>()
            {
                new Connection('b', DFA_BWB_ABAA_Nodes[6]),
                new Connection('a', DFA_BWB_ABAA_Nodes[2])
            });
            DFA_BWB_ABAA_Nodes[2].AddConnections(new List <Connection>()
            {
                new Connection('b', DFA_BWB_ABAA_Nodes[3]),
                new Connection('a', DFA_BWB_ABAA_Nodes[6])
            });
            DFA_BWB_ABAA_Nodes[3].AddConnections(new List <Connection>()
            {
                new Connection('b', DFA_BWB_ABAA_Nodes[6]),
                new Connection('a', DFA_BWB_ABAA_Nodes[4])
            });
            DFA_BWB_ABAA_Nodes[4].AddConnections(new List <Connection>()
            {
                new Connection('b', DFA_BWB_ABAA_Nodes[6]),
                new Connection('a', DFA_BWB_ABAA_Nodes[5])
            });
            DFA_BWB_ABAA_Nodes[5].AddConnections(new List <Connection>()
            {
                new Connection('b', DFA_BWB_ABAA_Nodes[5]),
                new Connection('a', DFA_BWB_ABAA_Nodes[5])
            });
            DFA_BWB_ABAA_Nodes[6].AddConnections(new List <Connection>()
            {
                new Connection('b', DFA_BWB_ABAA_Nodes[6]),
                new Connection('a', DFA_BWB_ABAA_Nodes[6])
            });
            DFA BeginsWithBABAA = new DFA(DFA_BWB_ABAA_Nodes[0], DFA_BWB_ABAA_Nodes);
            foreach (string item in strings)
            {
                Console.WriteLine(BeginsWithBABAA.Check(item));
            }
            CreateGraph(DFA_BWB_ABAA_Nodes, "DFA_BWBABAA");

            Console.WriteLine("---- starts with abb or ends with baab -----");
            List <Node> DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes = new List <Node>()
            {
                new Node("q0", NodeType.StartNode),
                new Node("q1", NodeType.NormalNode),
                new Node("q2", NodeType.NormalNode),
                new Node("q3", NodeType.EndNode),
                new Node("q4", NodeType.NormalNode),
                new Node("q5", NodeType.NormalNode),
                new Node("q6", NodeType.NormalNode),
                new Node("q7", NodeType.NormalNode),
                new Node("q8", NodeType.EndNode)
            };
            DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes[0].AddConnections(new List <Connection>()
            {
                new Connection('a', DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes[1]),
                new Connection('b', DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes[4])
            });
            DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes[1].AddConnections(new List <Connection>()
            {
                new Connection('a', DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes[6]),
                new Connection('b', DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes[2])
            });
            DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes[2].AddConnections(new List <Connection>()
            {
                new Connection('a', DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes[6]),
                new Connection('b', DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes[3])
            });
            DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes[3].AddConnections(new List <Connection>()
            {
                new Connection('a', DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes[3]),
                new Connection('b', DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes[3])
            });
            DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes[4].AddConnections(new List <Connection>()
            {
                new Connection('a', DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes[4]),
                new Connection('b', DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes[5])
            });
            DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes[5].AddConnections(new List <Connection>()
            {
                new Connection('a', DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes[6]),
                new Connection('b', DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes[5])
            });
            DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes[6].AddConnections(new List <Connection>()
            {
                new Connection('a', DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes[7]),
                new Connection('b', DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes[5])
            });
            DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes[7].AddConnections(new List <Connection>()
            {
                new Connection('a', DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes[4]),
                new Connection('b', DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes[8])
            });
            DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes[8].AddConnections(new List <Connection>()
            {
                new Connection('a', DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes[4]),
                new Connection('b', DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes[5])
            });
            DFA StartsWithABBorEndsWithBAAB = new DFA(DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes[0], DFA_STARTW_ABB_OR_ENDSW_BAAB_Nodes);
            foreach (string item in strings)
            {
                Console.WriteLine(StartsWithABBorEndsWithBAAB.Check(item));
            }
            CreateGraph(StartsWithABBorEndsWithBAAB.Nodes, "DFA_STARTWABBORENDSWBAAB");

            #endregion

            #region HopCroft
            List <Node> HopCraftNodes = new List <Node>()
            {
                new Node("q0", NodeType.StartNode),
                new Node("q1", NodeType.NormalNode),
                new Node("q2", NodeType.EndNode),
                new Node("q3", NodeType.NormalNode),
                new Node("q4", NodeType.NormalNode)
            };

            HopCraftNodes[0].AddConnections(new List <Connection>()
            {
                new Connection('a', HopCraftNodes[1]),
                new Connection('b', HopCraftNodes[2])
            });
            HopCraftNodes[1].AddConnections(new List <Connection>()
            {
                new Connection('a', HopCraftNodes[3]),
                new Connection('b', HopCraftNodes[0])
            });
            HopCraftNodes[2].AddConnections(new List <Connection>()
            {
                new Connection('a', HopCraftNodes[2]),
                new Connection('b', HopCraftNodes[4])
            });
            HopCraftNodes[3].AddConnections(new List <Connection>()
            {
                new Connection('a', HopCraftNodes[2]),
                new Connection('b', HopCraftNodes[1])
            });
            HopCraftNodes[4].AddConnections(new List <Connection>()
            {
                new Connection('a', HopCraftNodes[2]),
                new Connection('b', HopCraftNodes[1])
            });

            DFA HopCraft = new DFA(HopCraftNodes[0], HopCraftNodes);
            HopCraft = HopCroft.MinimizeHopCroft(HopCraft);
            CreateGraph(HopCraft.Nodes, "DFA_HopCroft");
            #endregion

            #region NDFA
            //------------------------------- NDFA -------------------------------
            Console.WriteLine("---------- NDFA ------------");
            Console.WriteLine("---- Contains aa or bb -----");
            List <Node> NDFA_C_AAoBB_Nodes = new List <Node>()
            {
                new Node("q0", NodeType.StartNode),
                new Node("q1", NodeType.NormalNode),
                new Node("q2", NodeType.NormalNode),
                new Node("q3", NodeType.EndNode),
            };
            NDFA_C_AAoBB_Nodes[0].AddConnections(new List <Connection>()
            {
                new Connection('b', NDFA_C_AAoBB_Nodes[0]),
                new Connection('a', NDFA_C_AAoBB_Nodes[0]),
                new Connection('b', NDFA_C_AAoBB_Nodes[2]),
                new Connection('a', NDFA_C_AAoBB_Nodes[1])
            });
            NDFA_C_AAoBB_Nodes[1].AddConnections(new List <Connection>()
            {
                new Connection('a', NDFA_C_AAoBB_Nodes[3]),
                new Connection('b', NDFA_C_AAoBB_Nodes[0])
            });
            NDFA_C_AAoBB_Nodes[2].AddConnections(new List <Connection>()
            {
                new Connection('b', NDFA_C_AAoBB_Nodes[3]),
                new Connection('a', NDFA_C_AAoBB_Nodes[0])
            });
            NDFA_C_AAoBB_Nodes[3].AddConnections(new List <Connection>()
            {
                new Connection('b', NDFA_C_AAoBB_Nodes[3]),
                new Connection('a', NDFA_C_AAoBB_Nodes[3])
            });
            NDFA ContainsAAorBB = new NDFA(new List <Node>()
            {
                NDFA_C_AAoBB_Nodes[0]
            }, NDFA_C_AAoBB_Nodes);
            foreach (string item in strings)
            {
                Console.WriteLine(ContainsAAorBB.Check(item));
            }
            CreateGraph(NDFA_C_AAoBB_Nodes, "NDFA_CAAoBB");
            #endregion

            #region regex
            //---------------------------- regex -------------------------------
            List <string> regexstrings = GenerateStrings.GenerateString(5, "abc");
            Console.WriteLine("---------- regex ------------");
            Console.WriteLine("--------- (a|bc)*  ----------");
            RegexTester regexTester = new RegexTester(@"(a|bc)*");

            foreach (string item in regexstrings)
            {
                Console.WriteLine(regexTester.Check(item));
            }

            Console.WriteLine("--------- wrong  ----------");
            List <string> foutievetaal = regexTester.geefFoutieveTaalTotN(5, "abc");
            foreach (string item in foutievetaal)
            {
                Console.WriteLine(regexTester.Check(item));
            }
            Console.WriteLine("--------- correct  ----------");
            List <string> correctetaal = regexTester.geefTaalTotN(5, "abc");
            foreach (string item in correctetaal)
            {
                Console.WriteLine(regexTester.Check(item));
            }
            #endregion

            #region GenerateBeginsWith

            Console.WriteLine("-------- Generated --------");
            List <Node> BeginsWithBABAANodes = GenerateDFA.GenerateDFABeginsWith("babaa", "ab");
            Node        beginsstartnode      = null;
            foreach (Node item in BeginsWithBABAANodes)
            {
                if (item.nodeType == NodeType.StartNode)
                {
                    beginsstartnode = item;
                }
            }
            DFA GEN_BeginsWithBABAA = new DFA(beginsstartnode, BeginsWithBABAANodes);
            foreach (string item in strings)
            {
                Console.WriteLine(GEN_BeginsWithBABAA.Check(item));
            }

            List <String> correctWordsbw = GEN_BeginsWithBABAA.geefTaalTotN(5, "ab");
            Console.WriteLine("-------- Correct words BeginsWithBABAA --------");
            foreach (String s in correctWordsbw)
            {
                Console.WriteLine(s);
            }

            List <String> inCorrectWordsbw = GEN_BeginsWithBABAA.geefFoutieveTaalTotN(5, "ab");
            Console.WriteLine("-------- incorrect words BeginsWithBABAA --------");
            foreach (String s in inCorrectWordsbw)
            {
                Console.WriteLine(s);
            }
            CreateGraph(GEN_BeginsWithBABAA.Nodes, "GEN_DFABWBABAA");
            #endregion

            #region GenerateEndsWith
            List <Node> EndsWithBABAANodes = GenerateDFA.GenerateDFAEndsWith("aabab", "ab");
            Node        EndsWithstartnode  = null;
            foreach (Node item in EndsWithBABAANodes)
            {
                if (item.nodeType == NodeType.StartNode)
                {
                    EndsWithstartnode = item;
                }
            }
            DFA GEN_EndsWithBABAA = new DFA(EndsWithstartnode, EndsWithBABAANodes);
            foreach (string item in strings)
            {
                Console.WriteLine(GEN_EndsWithBABAA.Check(item));
            }

            List <String> correctWordsew = GEN_EndsWithBABAA.geefTaalTotN(5, "ab");
            Console.WriteLine("-------- Correct words EndsWithAABAB --------");
            foreach (String s in correctWordsew)
            {
                Console.WriteLine(s);
            }

            List <String> inCorrectWordsew = GEN_EndsWithBABAA.geefFoutieveTaalTotN(5, "ab");
            Console.WriteLine("-------- incorrect words EndsWithAABAB --------");
            foreach (String s in inCorrectWordsew)
            {
                Console.WriteLine(s);
            }
            CreateGraph(GEN_EndsWithBABAA.Nodes, "GEN_DFAEWAABAB");
            #endregion

            #region Contains
            List <Node> ContainsBABAANodes = GenerateDFA.GenerateDFAContains("bab", "ab");
            Node        Containsstartnode  = null;
            foreach (Node item in ContainsBABAANodes)
            {
                if (item.nodeType == NodeType.StartNode)
                {
                    Containsstartnode = item;
                }
            }
            DFA GEN_ContainsBABAA = new DFA(Containsstartnode, ContainsBABAANodes);
            foreach (string item in strings)
            {
                Console.WriteLine(GEN_ContainsBABAA.Check(item));
            }

            List <String> correctWordsc = GEN_ContainsBABAA.geefTaalTotN(5, "ab");
            Console.WriteLine("-------- Correct words ContainsBAB --------");
            foreach (String s in correctWordsc)
            {
                Console.WriteLine(s);
            }

            List <String> inCorrectWordsc = GEN_ContainsBABAA.geefFoutieveTaalTotN(5, "ab");
            Console.WriteLine("-------- incorrect words ContainsBAB --------");
            foreach (String s in inCorrectWordsc)
            {
                Console.WriteLine(s);
            }
            CreateGraph(GEN_ContainsBABAA.Nodes, "GEN_DFAEWBAB");
            #endregion

            #region Regex -> NDFA
            Console.WriteLine("---------- Regular expression tester with Regex and Thompson ------------");
            Console.WriteLine("----------                        (a|bc)*                    -----------");
            regexTester = new RegexTester(@"(a|bc)*");
            RegExp      reg  = new RegExp("a").or(new RegExp("b").dot(new RegExp("c"))).star();
            List <Node> ndfa = Thompson.CreateAutomaat(reg);
            NDFA        NDFAregularexpression2 = new NDFA(new List <Node>()
            {
                ndfa[0]
            }, ndfa);

            foreach (string item in strings)
            {
                Console.WriteLine(NDFAregularexpression2.Check(item));
                Console.WriteLine("Regex test: " + regexTester.Check(item));
            }

            CreateGraph(NDFAregularexpression2.Nodes, "NDFA_RegexThompsonToNDFA");
            #endregion

            #region NDFAtoDFA
            //--------------------------- NDFA -> DFA ---------------------------
            Console.WriteLine("---- test NDFA to DFA -----");
            Console.WriteLine("---------- NDFA -----------");
            List <Node> NDFATODFA = new List <Node>()
            {
                new Node("q1", NodeType.StartNode),
                new Node("q2", NodeType.EndNode),
                new Node("q3", NodeType.EndNode),
                new Node("q4", NodeType.NormalNode),
                new Node("q5", NodeType.NormalNode)
            };
            NDFATODFA[0].AddConnections(new List <Connection>()
            {
                new Connection('b', NDFATODFA[1]),
                new Connection('a', NDFATODFA[1]),
                new Connection('b', NDFATODFA[2]),
            });
            NDFATODFA[1].AddConnections(new List <Connection>()
            {
                new Connection('a', NDFATODFA[2]),
                new Connection('ϵ', NDFATODFA[3]),
                new Connection('b', NDFATODFA[3])
            });
            NDFATODFA[2].AddConnections(new List <Connection>()
            {
                new Connection('a', NDFATODFA[1])
            });
            NDFATODFA[3].AddConnections(new List <Connection>()
            {
                new Connection('a', NDFATODFA[4]),
                new Connection('a', NDFATODFA[1])
            });
            NDFATODFA[4].AddConnections(new List <Connection>()
            {
                new Connection('b', NDFATODFA[4]),
                new Connection('ϵ', NDFATODFA[2])
            });
            NDFA TESTNDFATODFA = new NDFA(new List <Node>()
            {
                NDFATODFA[0]
            }, NDFATODFA);
            CreateGraph(TESTNDFATODFA.Nodes, "NDFA_NDFAtoDFA");
            foreach (string item in strings)
            {
                //Console.WriteLine(TESTNDFATODFA.Check(item));
            }
            Console.WriteLine("----------- DFA -----------");
            DFA TESTDFA = NDFAtoDFA.ToDFA2(TESTNDFATODFA);
            CreateGraph(TESTDFA.Nodes, "DFA_NDFAtoDFA");
            foreach (string item in strings)
            {
                Console.WriteLine(TESTNDFATODFA.Check(item));
                Console.WriteLine(TESTDFA.Check(item));
            }
            #endregion

            #region Reverse
            Console.WriteLine("---- (NDFA) reverse begins with babaa -----");

            NDFA reversedBABAA = DFAReverse.Reverse2(BeginsWithBABAA);
            foreach (string item in strings)
            {
                Console.WriteLine(reversedBABAA.Check(item));
            }

            CreateGraph(reversedBABAA.Nodes, "ReversedBABAA");
            #endregion
        }
Example #8
0
        /// <summary>
        /// A basic parser that rewrites strings into a RegExp object.
        /// </summary>
        /// <param name="text">The text to create a RegExp from</param>
        /// <returns>a RegExp based on the text</returns>
        public static RegExp parse(string text)
        {
            RegExp regex = new RegExp();                 //the output RegExp object

            Mode        currentMode = 0;                 //no dot or or found yet
            List <Char> chars       = new List <char>(); //memory of all found characters, needed for ) and or

            //parse each letter
            foreach (char c in text.ToCharArray())
            {
                //What does the letter mean for the conversion?
                switch (c)
                {
                case '(':     //can be ignored
                    break;

                case ')':     //handle all leftover characters since we are going up in depth
                    RegExp reg = new RegExp();
                    foreach (Char ch in chars)
                    {
                        if (reg.left == null && reg.right == null && reg.terminals == "")
                        {
                            reg = new RegExp(ch.ToString());                                                                   //if it's the first charachter
                        }
                        else
                        {
                            reg = reg.dot(new RegExp(ch.ToString()));      //there was atleast 1 character before this one
                        }
                    }
                    chars.Clear();     //chars are used, array can be cleard
                    regex       = regex.or(reg);
                    currentMode = 0;   //or used to set mode back to nothing
                    break;

                case '|':     //or detected
                    currentMode = Mode.or;
                    break;

                case '+':     //+ detected
                    regex = regex.plus();
                    break;

                case '*':     //star detected
                    regex = regex.star();
                    break;

                case '.':     //dot detected
                    currentMode = Mode.dot;
                    break;

                default:                 //no special character detected
                    switch (currentMode) //the mode is important for handling the dot, or and one
                    {
                    case Mode.nothing:
                        if (regex.left == null && regex.right == null && regex.terminals == "")
                        {
                            regex = new RegExp(c.ToString());                                                                             //if it's the first charachter
                        }
                        else
                        {
                            regex = regex.dot(new RegExp(c.ToString()));          //there was atleast 1 character before this one
                        }
                        break;

                    case Mode.or:
                        chars.Add(c);         //an or expects all characters in one RegExp object, add them to an array first
                        break;

                    case Mode.dot:
                        regex = regex.dot(new RegExp(c.ToString()));
                        break;
                    }
                    break;
                }
            }
            if (chars.Count != 0) //makes sure a Regexp object is properly closed off.
            {
                RegExp reg = new RegExp();
                foreach (Char ch in chars)
                {
                    if (reg.left == null && reg.right == null && reg.terminals == "")
                    {
                        reg = new RegExp(ch.ToString());                                                               //if it's the first charachter
                    }
                    else
                    {
                        reg = reg.dot(new RegExp(ch.ToString()));  //there was atleast 1 character before this one
                    }
                }
                regex = regex.or(reg);
            }

            return(regex);
        }