Fix hopcroft DFA minimization and add plot graph function

Author: rollrat

ParserGenerator.cs

@@ -1,4 +1,4 @@
-/*
+/*
 
    Copyright (C) 2019. rollrat All Rights Reserved.
 
@@ -13,41 +13,24 @@
 
 namespace ParserGenerator
 {
-    public class ParserAction
-    {
-        public Action<ParsingTree.ParsingTreeNode> SemanticAction;
-        public static ParserAction Create(Action<ParsingTree.ParsingTreeNode> action)
-            => new ParserAction { SemanticAction = action };
-    }
-
     public class ParserProduction
     {
         public int index;
         public string production_name;
         public bool isterminal;
         public List<ParserProduction> contents = new List<ParserProduction>();
         public List<List<ParserProduction>> sub_productions = new List<List<ParserProduction>>();
-        public List<ParserAction> temp_actions = new List<ParserAction>();
-        public List<ParserAction> actions = new List<ParserAction>();
 
         public static ParserProduction operator +(ParserProduction p1, ParserProduction p2)
         {
             p1.contents.Add(p2);
             return p1;
         }
 
-        public static ParserProduction operator +(ParserProduction pp, ParserAction ac)
-        {
-            pp.temp_actions.Add(ac);
-            return pp;
-        }
-
         public static ParserProduction operator |(ParserProduction p1, ParserProduction p2)
         {
             p2.contents.Insert(0, p2);
             p1.sub_productions.Add(new List<ParserProduction>(p2.contents));
-            p1.actions.AddRange(p2.temp_actions);
-            p2.temp_actions.Clear();
             p2.contents.Clear();
             return p1;
         }
@@ -1283,7 +1266,6 @@ public ShiftReduceParser CreateShiftReduceParserInstance()
             var grammar = new List<List<int>>();
             var grammar_group = new List<int>();
             var production_mapping = new List<List<int>>();
-            var semantic_rules = new List<ParserAction>();
             var pm_count = 0;
 
             foreach (var pr in production_rules)
@@ -1298,7 +1280,6 @@ public ShiftReduceParser CreateShiftReduceParserInstance()
                 }
                 grammar.AddRange(ll);
                 production_mapping.Add(pm);
-                semantic_rules.AddRange(pr.actions);
             }
 
             for (int i = 0; i < number_of_states; i++)
@@ -1335,7 +1316,7 @@ public ShiftReduceParser CreateShiftReduceParserInstance()
                     }
                 }
 
-            return new ShiftReduceParser(symbol_table, jump_table, goto_table, grammar_group.ToArray(), grammar.Select(x => x.ToArray()).ToArray(), semantic_rules);
+            return new ShiftReduceParser(symbol_table, jump_table, goto_table, grammar_group.ToArray(), grammar.Select(x => x.ToArray()).ToArray());
         }
     }
 
@@ -1358,7 +1339,7 @@ public static ParsingTreeNode NewNode(string production, string contents)
                 => new ParsingTreeNode { Parent = null, Childs = new List<ParsingTreeNode>(), Produnction = production, Contents = contents };
         }
 
-        public ParsingTreeNode root;
+        ParsingTreeNode root;
 
         public ParsingTree(ParsingTreeNode root)
         {
@@ -1375,7 +1356,6 @@ public class ShiftReduceParser
         List<string> symbol_index_name = new List<string>();
         Stack<int> state_stack = new Stack<int>();
         Stack<ParsingTree.ParsingTreeNode> treenode_stack = new Stack<ParsingTree.ParsingTreeNode>();
-        List<ParserAction> actions;
 
         // 3       1      2       0
         // Accept? Shift? Reduce? Error?
@@ -1384,14 +1364,13 @@ public class ShiftReduceParser
         int[][] production;
         int[] group_table;
 
-        public ShiftReduceParser(Dictionary<string, int> symbol_table, int[][] jump_table, int[][] goto_table, int[] group_table, int[][] production, List<ParserAction> actions)
+        public ShiftReduceParser(Dictionary<string, int> symbol_table, int[][] jump_table, int[][] goto_table, int[] group_table, int[][] production)
         {
             symbol_name_index = symbol_table;
             this.jump_table = jump_table;
             this.goto_table = goto_table;
             this.production = production;
             this.group_table = group_table;
-            this.actions = actions;
             var l = symbol_table.ToList().Select(x => new Tuple<int, string>(x.Value, x.Key)).ToList();
             l.Sort();
             l.ForEach(x => symbol_index_name.Add(x.Item2));
@@ -1472,7 +1451,6 @@ private void reduce(int index)
             reduction_parent.Contents = string.Join("", reduce_treenodes.Select(x => x.Contents));
             reduction_parent.Childs = reduce_treenodes;
             treenode_stack.Push(reduction_parent);
-            actions[reduction_parent.ProductionRuleIndex].SemanticAction(reduction_parent);
         }
     }
-}
+}

ScannerGenerator.cs

@@ -62,10 +62,11 @@ public class diagram
         public void MakeNFA(string pattern) { Diagram = make_nfa("(" + pattern + ")"); }
         public void OptimizeNFA() { while (opt_nfa(Diagram)) ; }
         public void NFAtoDFA() { Diagram = nfa2dfa(Diagram); }
-        public void MinimizeDFA() { opt_dfa(Diagram); }
+        public void MinimizeDFA() { opt_dfa_hopcroft(Diagram); }
         public string PrintDiagram() { return print_diagram(Diagram); }
 
         public static string PrintDiagram(diagram dia) { return print_diagram(dia); }
+        public static string PrintGraph(diagram dia) { return print_diagram_for_graphviz(dia); }
 
         /// <summary>
         /// Try simple-regular-expression to optimized DFA
@@ -342,6 +343,86 @@ private static string print_diagram(diagram d)
             return builder.ToString();
         }
 
+        private static string print_diagram_for_graphviz(diagram d)
+        {
+            var builder = new StringBuilder();
+            var used = new HashSet<int>();
+
+            var stack_used = new Stack<transition_node>();
+            var check_used = new List<bool>(d.count_of_vertex);
+            check_used.AddRange(Enumerable.Repeat(false, d.count_of_vertex));
+
+            stack_used.Push(d.start_node);
+            used.Add(d.start_node.index);
+
+            while (stack_used.Count != 0)
+            {
+                var tn = stack_used.Pop();
+                if (check_used[tn.index]) continue;
+                check_used[tn.index] = true;
+
+                used.Add(tn.index);
+
+                tn.transition.ForEach(x => stack_used.Push(x.Item2));
+            }
+
+            builder.Append("digraph finite_state_machine {\r\n");
+            builder.Append("    rankdir=LR;\r\n");
+            builder.Append("    size=\"20,30\"\r\n");
+
+            // print doublecircle
+            builder.Append("    node [shape = doublecircle]; ");
+            foreach (var dd in d.nodes)
+                if (dd.is_acceptable && used.Contains(dd.index))
+                    builder.Append(dd.index + "; ");
+            builder.Append("\r\n");
+
+            // print point
+            builder.Append("    node [shape = point]; ss\r\n");
+            
+            // print circle
+            builder.Append("    node [shape = circle];\r\n");
+
+            var stack = new Stack<transition_node>();
+            var check = new List<bool>(d.count_of_vertex);
+            check.AddRange(Enumerable.Repeat(false, d.count_of_vertex));
+
+            stack.Push(d.start_node);
+            builder.Append($"    ss -> {d.start_node.index}");
+
+            while (stack.Count != 0)
+            {
+                var tn = stack.Pop();
+                if (check[tn.index]) continue;
+                check[tn.index] = true;
+                
+                foreach (var j in tn.transition)
+                {
+                    string v = "";
+                    if (j.Item1 == e_closure)
+                        v = "&epsilon;";
+                    else if (j.Item1 == '"')
+                        v = "\"";
+                    else if (j.Item1 == '\n')
+                        v = "\\n";
+                    else if (j.Item1 == '\r')
+                        v = "\\r";
+                    else if (j.Item1 == '\t')
+                        v = "\\t";
+                    else
+                        v = new string(j.Item1, 1);
+
+                    builder.Append($@"    {tn.index} -> {j.Item2.index} [ label = ""{v}"" ];" + "\r\n");
+                }
+
+                tn.transition.ForEach(x => stack.Push(x.Item2));
+            }
+
+            builder.Append("}");
+
+            return builder.ToString();
+        }
+
         /// <summary>
         /// Get inverse array of diagram nodes
         /// </summary>
@@ -612,8 +693,7 @@ private diagram nfa2dfa(diagram dia)
                         break;
                     }
             }
-
-
+            
             diagram.count_of_vertex = transition_node_list.Count;
             diagram.nodes = transition_node_list;
             diagram.start_node = transition_node_list[0];
@@ -661,7 +741,7 @@ private void opt_dfa(diagram dia)
                 }
 
             color_count++;
-
+            
             while (true)
             {
                 // Collect transition color
@@ -700,6 +780,93 @@ private void opt_dfa(diagram dia)
 
                 previous_group = group;
             }
+            
+            var dicc = new Dictionary<int, int>();
+            var inverse_transition = get_inverse_transtition(dia);
+            for (int i = 0; i < color.Count; i++)
+                if (!dicc.ContainsKey(color[i]))
+                    dicc.Add(color[i], i);
+                else if (inverse_transition.ContainsKey(i))
+                {
+                    foreach (var inv in inverse_transition[i])
+                        for (int j = 0; j < dia.nodes[inv].transition.Count; j++)
+                            if (dia.nodes[inv].transition[j].Item2.index == i)
+                                dia.nodes[inv].transition[j] = new Tuple<char, transition_node>(dia.nodes[inv].transition[j].Item1, dia.nodes[dicc[color[i]]]);
+                }
+        }
+
+        /// <summary>
+        /// Minimization DFA using Hopcroft Algorithm
+        /// </summary>
+        /// <param name="dia"></param>
+        /// <returns></returns>
+        private void opt_dfa_hopcroft(diagram dia)
+        {
+            var visit = new HashSet<string>();
+            var queue = new Queue<List<int>>();
+
+            // Enqueue Nodes
+            var acc_nodes = new List<int>();
+            var nacc_nodes = new List<int>();
+            foreach (var node in dia.nodes)
+                if (node.is_acceptable)
+                    acc_nodes.Add(node.index);
+                else
+                    nacc_nodes.Add(node.index);
+
+            queue.Enqueue(acc_nodes);
+            queue.Enqueue(nacc_nodes);
+
+            var color = new List<int>();
+            var color_count = 1;
+            color.AddRange(Enumerable.Repeat(0, dia.count_of_vertex));
+
+            acc_nodes.ForEach(x => color[x] = color_count);
+            color_count = 1;
+
+            while (queue.Count > 0)
+            {
+                var front = queue.Dequeue();
+                front.Sort();
+                var str = string.Join(",", front);
+
+                if (visit.Contains(str)) continue;
+                visit.Add(str);
+
+                //foreach (var node in front)
+                //    color[node] = color_count;
+                //color_count++;
+
+                // Collect transition color
+                var dic = new Dictionary<int, SortedDictionary<char, int>>();
+                foreach (var index in front)
+                {
+                    var node = dia.nodes[index];
+                    foreach (var ts in node.transition)
+                    {
+                        if (!dic.ContainsKey(node.index))
+                            dic.Add(node.index, new SortedDictionary<char, int>());
+                        dic[node.index].Add(ts.Item1, color[ts.Item2.index]);
+                    }
+                }
+
+                var list = dic.ToList();
+                var group = new Dictionary<string, List<int>>();
+                for (int i = 0; i < list.Count; i++)
+                {
+                    var ds = dic2str(list[i].Value);
+                    if (!group.ContainsKey(ds))
+                        group.Add(ds, new List<int>());
+                    group[ds].Add(list[i].Key);
+                }
+
+                foreach (var gi in group)
+                {
+                    queue.Enqueue(gi.Value);
+                    gi.Value.ForEach(x => color[x] = color_count);
+                    color_count++;
+                }
+            }
 
             var dicc = new Dictionary<int, int>();
             var inverse_transition = get_inverse_transtition(dia);
@@ -1004,4 +1171,4 @@ public Tuple<string, string, int, int> Lookahead()
             return result;
         }
     }
-}
+}