lrama 0.1.0 → 0.2.0

data/lib/lrama/states_reporter.rb

@@ -0,0 +1,310 @@
+module Lrama
+  class StatesReporter
+    include Lrama::Report::Duration
+
+    def initialize(states)
+      @states = states
+    end
+
+    def report(io, **options)
+      report_duration(:report) do
+        _report(io, **options)
+      end
+    end
+
+    private
+
+    def _report(io, grammar: false, states: false, itemsets: false, lookaheads: false, solved: false, verbose: false)
+      # TODO: Unused terms
+      # TODO: Unused rules
+
+      report_conflicts(io)
+      report_grammar(io) if grammar
+      report_states(io, itemsets, lookaheads, solved, verbose)
+    end
+
+    def report_conflicts(io)
+      has_conflict = false
+
+      @states.states.each do |state|
+        messages = []
+        cs = state.conflicts.group_by(&:type)
+        if cs[:shift_reduce]
+          messages << "#{cs[:shift_reduce].count} shift/reduce"
+        end
+
+        if cs[:reduce_reduce]
+          messages << "#{cs[:reduce_reduce].count} reduce/reduce"
+        end
+
+        if !messages.empty?
+          has_conflict = true
+          io << "State #{state.id} conflicts: #{messages.join(', ')}\n"
+        end
+      end
+
+      if has_conflict
+        io << "\n\n"
+      end
+    end
+
+    def report_grammar(io)
+      io << "Grammar\n"
+      last_lhs = nil
+
+      @states.rules.each do |rule|
+        if rule.rhs.empty?
+          r = "ε"
+        else
+          r = rule.rhs.map(&:display_name).join(" ")
+        end
+
+        if rule.lhs == last_lhs
+          io << sprintf("%5d %s| %s\n", rule.id, " " * rule.lhs.display_name.length, r)
+        else
+          io << "\n"
+          io << sprintf("%5d %s: %s\n", rule.id, rule.lhs.display_name, r)
+        end
+
+        last_lhs = rule.lhs
+      end
+      io << "\n\n"
+    end
+
+    def report_states(io, itemsets, lookaheads, solved, verbose)
+      @states.states.each do |state|
+        # Report State
+        io << "State #{state.id}\n\n"
+
+        # Report item
+        last_lhs = nil
+        list = itemsets ? state.items : state.kernels
+        list.sort_by {|i| [i.rule_id, i.position] }.each do |item|
+          rule = item.rule
+          position = item.position
+          if rule.rhs.empty?
+            r = "ε •"
+          else
+            r = rule.rhs.map(&:display_name).insert(position, "•").join(" ")
+          end
+          if rule.lhs == last_lhs
+            l = " " * rule.lhs.id.s_value.length + "|"
+          else
+            l = rule.lhs.id.s_value + ":"
+          end
+          la = ""
+          if lookaheads && item.end_of_rule?
+            reduce = state.find_reduce_by_item!(item)
+            look_ahead = reduce.selected_look_ahead
+            if !look_ahead.empty?
+              la = "  [#{look_ahead.map(&:display_name).join(", ")}]"
+            end
+          end
+          last_lhs = rule.lhs
+
+          io << sprintf("%5i %s %s%s\n", rule.id, l, r, la)
+        end
+        io << "\n"
+
+
+        # Report shifts
+        tmp = state.term_transitions.select do |shift, _|
+          !shift.not_selected
+        end.map do |shift, next_state|
+          [shift.next_sym, next_state.id]
+        end
+        max_len = tmp.map(&:first).map(&:display_name).map(&:length).max
+        tmp.each do |term, state_id|
+          io << "    #{term.display_name.ljust(max_len)}  shift, and go to state #{state_id}\n"
+        end
+        io << "\n" if !tmp.empty?
+
+
+        # Report error caused by %nonassoc
+        nl = false
+        tmp = state.resolved_conflicts.select do |resolved|
+          resolved.which == :error
+        end.map do |error|
+          error.symbol.display_name
+        end
+        max_len = tmp.map(&:length).max
+        tmp.each do |name|
+          nl = true
+          io << "    #{name.ljust(max_len)}  error (nonassociative)\n"
+        end
+        io << "\n" if !tmp.empty?
+
+
+        # Report reduces
+        nl = false
+        max_len = state.non_default_reduces.flat_map(&:look_ahead).compact.map(&:display_name).map(&:length).max || 0
+        max_len = [max_len, "$default".length].max if state.default_reduction_rule
+        ary = []
+
+        state.non_default_reduces.each do |reduce|
+          reduce.look_ahead.each do |term|
+            ary << [term, reduce]
+          end
+        end
+
+        ary.sort_by do |term, reduce|
+          term.number
+        end.each do |term, reduce|
+          rule = reduce.item.rule
+          io << "    #{term.display_name.ljust(max_len)}  reduce using rule #{rule.id} (#{rule.lhs.display_name})\n"
+          nl = true
+        end
+
+        if r = state.default_reduction_rule
+          nl = true
+          s = "$default".ljust(max_len)
+
+          if r.initial_rule?
+            io << "    #{s}  accept\n"
+          else
+            io << "    #{s}  reduce using rule #{r.id} (#{r.lhs.display_name})\n"
+          end
+        end
+        io << "\n" if nl
+
+
+        # Report nonterminal transitions
+        tmp = []
+        max_len = 0
+        state.nterm_transitions.each do |shift, next_state|
+          nterm = shift.next_sym
+          tmp << [nterm, next_state.id]
+          max_len = [max_len, nterm.id.s_value.length].max
+        end
+        tmp.uniq!
+        tmp.sort_by! do |nterm, state_id|
+          nterm.number
+        end
+        tmp.each do |nterm, state_id|
+          io << "    #{nterm.id.s_value.ljust(max_len)}  go to state #{state_id}\n"
+        end
+        io << "\n" if !tmp.empty?
+
+
+        if solved
+          # Report conflict resolutions
+          state.resolved_conflicts.each do |resolved|
+            io << "    #{resolved.report_message}\n"
+          end
+          io << "\n" if !state.resolved_conflicts.empty?
+        end
+
+
+        if verbose
+          # Report direct_read_sets
+          io << "  [Direct Read sets]\n"
+          direct_read_sets = @states.direct_read_sets
+          @states.nterms.each do |nterm|
+            terms = direct_read_sets[[state.id, nterm.token_id]]
+            next if !terms
+            next if terms.empty?
+
+            str = terms.map {|sym| sym.id.s_value }.join(", ")
+            io << "    read #{nterm.id.s_value}  shift #{str}\n"
+          end
+          io << "\n"
+
+
+          # Reprot reads_relation
+          io << "  [Reads Relation]\n"
+          @states.nterms.each do |nterm|
+            a = @states.reads_relation[[state.id, nterm.token_id]]
+            next if !a
+
+            a.each do |state_id2, nterm_id2|
+              n = @states.nterms.find {|n| n.token_id == nterm_id2 }
+              io << "    (State #{state_id2}, #{n.id.s_value})\n"
+            end
+          end
+          io << "\n"
+
+
+          # Reprot read_sets
+          io << "  [Read sets]\n"
+          read_sets = @states.read_sets
+          @states.nterms.each do |nterm|
+            terms = read_sets[[state.id, nterm.token_id]]
+            next if !terms
+            next if terms.empty?
+
+            terms.each do |sym|
+              io << "    #{sym.id.s_value}\n"
+            end
+          end
+          io << "\n"
+
+
+          # Reprot includes_relation
+          io << "  [Includes Relation]\n"
+          @states.nterms.each do |nterm|
+            a = @states.includes_relation[[state.id, nterm.token_id]]
+            next if !a
+
+            a.each do |state_id2, nterm_id2|
+              n = @states.nterms.find {|n| n.token_id == nterm_id2 }
+              io << "    (State #{state.id}, #{nterm.id.s_value}) -> (State #{state_id2}, #{n.id.s_value})\n"
+            end
+          end
+          io << "\n"
+
+
+          # Report lookback_relation
+          io << "  [Lookback Relation]\n"
+          @states.rules.each do |rule|
+            a = @states.lookback_relation[[state.id, rule.id]]
+            next if !a
+
+            a.each do |state_id2, nterm_id2|
+              n = @states.nterms.find {|n| n.token_id == nterm_id2 }
+              io << "    (Rule: #{rule.to_s}) -> (State #{state_id2}, #{n.id.s_value})\n"
+            end
+          end
+          io << "\n"
+
+
+          # Reprot follow_sets
+          io << "  [Follow sets]\n"
+          follow_sets = @states.follow_sets
+          @states.nterms.each do |nterm|
+            terms = follow_sets[[state.id, nterm.token_id]]
+
+            next if !terms
+
+            terms.each do |sym|
+              io << "    #{nterm.id.s_value} -> #{sym.id.s_value}\n"
+            end
+          end
+          io << "\n"
+
+
+          # Report LA
+          io << "  [Look-Ahead Sets]\n"
+          tmp = []
+          max_len = 0
+          @states.rules.each do |rule|
+            syms = @states.la[[state.id, rule.id]]
+            next if !syms
+
+            tmp << [rule, syms]
+            max_len = ([max_len] + syms.map {|s| s.id.s_value.length }).max
+          end
+          tmp.each do |rule, syms|
+            syms.each do |sym|
+              io << "    #{sym.id.s_value.ljust(max_len)}  reduce using rule #{rule.id} (#{rule.lhs.id.s_value})\n"
+            end
+          end
+          io << "\n" if !tmp.empty?
+        end
+
+
+        # End of Report State
+        io << "\n"
+      end
+    end
+  end
+end

data/lib/lrama/version.rb

@@ -1,3 +1,3 @@
 module Lrama
-  VERSION = "0.1.0".freeze
+  VERSION = "0.2.0".freeze
 end

data/lib/lrama/warning.rb

@@ -0,0 +1,25 @@
+module Lrama
+  class Warning
+    attr_reader :errors, :warns
+
+    def initialize(out = STDERR)
+      @out = out
+      @errors = []
+      @warns = []
+    end
+
+    def error(message)
+      @out << message << "\n"
+      @errors << message
+    end
+
+    def warn(message)
+      @out << message << "\n"
+      @warns << message
+    end
+
+    def has_error?
+      !@errors.empty?
+    end
+  end
+end

data/lib/lrama.rb

@@ -1,9 +1,13 @@
+require "lrama/bitmap"
 require "lrama/command"
 require "lrama/context"
+require "lrama/digraph"
 require "lrama/grammar"
 require "lrama/lexer"
 require "lrama/output"
 require "lrama/parser"
 require "lrama/report"
 require "lrama/states"
+require "lrama/states_reporter"
 require "lrama/version"
+require "lrama/warning"

data/sample/parse.y

@@ -0,0 +1,58 @@
+/*
+ * This is comment for this file.
+ */
+
+%{
+// Prologue
+
+#include "y.tab.h"
+
+static enum yytokentype yylex(YYSTYPE *lval, YYLTYPE *yylloc);
+static void yyerror(YYLTYPE *yylloc, const char *msg);
+
+%}
+
+%expect 0
+%define api.pure
+%define parse.error verbose
+
+%union {
+    int i;
+}
+
+%token <i> number
+
+%%
+
+program         : expr
+                ;
+
+expr            : term '+' expr
+                | term
+                ;
+
+term            : factor '*' term
+                | factor
+                ;
+
+factor          : number
+                ;
+
+%%
+
+// Epilogue
+
+static enum yytokentype
+yylex(YYSTYPE *lval, YYLTYPE *yylloc)
+{
+    return 0;
+}
+
+static void yyerror(YYLTYPE *yylloc, const char *msg)
+{
+    (void) msg;
+}
+
+int main(int argc, char *argv[])
+{
+}

data/template/bison/yacc.c

@@ -668,7 +668,7 @@ enum { YYENOMEM = -2 };
       }                                                           \
     else                                                          \
       {                                                           \
-        yyerror (&yylloc, p, YY_("syntax error: cannot back up")); \
+        yyerror (<%= output.yyerror_args %>, YY_("syntax error: cannot back up")); \
         YYERROR;                                                  \
       }                                                           \
   while (0)
@@ -802,9 +802,7 @@ yy_symbol_value_print (FILE *yyo,
                        yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp<%= output.user_formals %>)
 {
   FILE *yyoutput = yyo;
-  YY_USE (yyoutput);
-  YY_USE (yylocationp);
-  YY_USE (p);
+<%= output.parse_param_use("yyoutput", "yylocationp") %>
   if (!yyvaluep)
     return;
   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
@@ -1199,9 +1197,7 @@ static void
 yydestruct (const char *yymsg,
             yysymbol_kind_t yykind, YYSTYPE *yyvaluep, YYLTYPE *yylocationp<%= output.user_formals %>)
 {
-  YY_USE (yyvaluep);
-  YY_USE (yylocationp);
-  YY_USE (p);
+<%= output.parse_param_use("yyvaluep", "yylocationp") %>
   if (!yymsg)
     yymsg = "Deleting";
   YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
@@ -1301,10 +1297,7 @@ YYLTYPE yylloc = yyloc_default;
 
 
 <%# b4_user_initial_action -%>
-/* User initialization code.  */
-#line <%= output.grammar.initial_action.line %> "<%= output.grammar_file_path %>"
-<%= output.grammar.initial_action.translated_code %>
-
+<%= output.user_initial_action("/* User initialization code.  */") %>
 #line [@oline@] [@ofile@]
 
   yylsp[0] = yylloc;
@@ -1424,7 +1417,7 @@ yybackup:
   if (yychar == YYEMPTY)
     {
       YYDPRINTF ((stderr, "Reading a token\n"));
-      yychar = yylex (&yylval, &yylloc, p);
+      yychar = yylex <%= output.yylex_formals %>;
     }
 
   if (yychar <= <%= output.eof_symbol.id.s_value %>)
@@ -1590,7 +1583,7 @@ yyerrlab:
                 yysyntax_error_status = YYENOMEM;
               }
           }
-        yyerror (&yylloc, p, yymsgp);
+        yyerror (<%= output.yyerror_args %>, yymsgp);
         if (yysyntax_error_status == YYENOMEM)
           YYNOMEM;
       }
@@ -1611,7 +1604,7 @@ yyerrlab:
       else
         {
           yydestruct ("Error: discarding",
-                      yytoken, &yylval, &yylloc, p);
+                      yytoken, &yylval, &yylloc<%= output.user_args %>);
           yychar = YYEMPTY;
         }
     }
@@ -1667,7 +1660,7 @@ yyerrlab1:
 
       yyerror_range[1] = *yylsp;
       yydestruct ("Error: popping",
-                  YY_ACCESSING_SYMBOL (yystate), yyvsp, yylsp, p);
+                  YY_ACCESSING_SYMBOL (yystate), yyvsp, yylsp<%= output.user_args %>);
       YYPOPSTACK (1);
       yystate = *yyssp;
       YY_STACK_PRINT (yyss, yyssp);
@@ -1708,7 +1701,7 @@ yyabortlab:
 | yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here.  |
 `-----------------------------------------------------------*/
 yyexhaustedlab:
-  yyerror (&yylloc, p, YY_("memory exhausted"));
+  yyerror (<%= output.yyerror_args %>, YY_("memory exhausted"));
   yyresult = 2;
   goto yyreturnlab;
 
@@ -1723,7 +1716,7 @@ yyreturnlab:
          user semantic actions for why this is necessary.  */
       yytoken = YYTRANSLATE (yychar);
       yydestruct ("Cleanup: discarding lookahead",
-                  yytoken, &yylval, &yylloc, p);
+                  yytoken, &yylval, &yylloc<%= output.user_args %>);
     }
   /* Do not reclaim the symbols of the rule whose action triggered
      this YYABORT or YYACCEPT.  */
@@ -1732,7 +1725,7 @@ yyreturnlab:
   while (yyssp != yyss)
     {
       yydestruct ("Cleanup: popping",
-                  YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yylsp, p);
+                  YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yylsp<%= output.user_args %>);
       YYPOPSTACK (1);
     }
 #ifndef yyoverflow

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lrama
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Yuichiro Kaneko
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-01-31 00:00:00.000000000 Z
+date: 2023-05-10 00:00:00.000000000 Z
 dependencies: []
 description: LALR (1) parser generator written by Ruby
 email:
@@ -29,16 +29,21 @@ files:
 - doc/TODO.md
 - exe/lrama
 - lib/lrama.rb
+- lib/lrama/bitmap.rb
 - lib/lrama/command.rb
 - lib/lrama/context.rb
+- lib/lrama/digraph.rb
 - lib/lrama/grammar.rb
 - lib/lrama/lexer.rb
 - lib/lrama/output.rb
 - lib/lrama/parser.rb
 - lib/lrama/report.rb
 - lib/lrama/states.rb
+- lib/lrama/states_reporter.rb
 - lib/lrama/version.rb
+- lib/lrama/warning.rb
 - lrama.gemspec
+- sample/parse.y
 - template/bison/yacc.c
 - template/bison/yacc.h
 homepage: https://github.com/yui-knk/lrama