lrama 0.5.3 → 0.5.4

data/lib/lrama/grammar/auxiliary.rb

@@ -0,0 +1,7 @@
+module Lrama
+  class Grammar
+    # Grammar file information not used by States but by Output
+    class Auxiliary < Struct.new(:prologue_first_lineno, :prologue, :epilogue_first_lineno, :epilogue, keyword_init: true)
+    end
+  end
+end

data/lib/lrama/grammar/rule.rb

@@ -17,6 +17,12 @@ module Lrama
         "#{l}: #{r}"
       end
 
+      # opt_nl: ε     <-- empty_rule
+      #       | '\n'  <-- not empty_rule
+      def empty_rule?
+        rhs.empty?
+      end
+
       def precedence
         precedence_sym&.precedence
       end

data/lib/lrama/grammar/symbol.rb

@@ -7,6 +7,7 @@
 module Lrama
   class Grammar
     class Symbol < Struct.new(:id, :alias_name, :number, :tag, :term, :token_id, :nullable, :precedence, :printer, :error_token, keyword_init: true)
+      attr_accessor :first_set, :first_set_bitmap
       attr_writer :eof_symbol, :error_symbol, :undef_symbol, :accept_symbol
 
       def term?
@@ -34,11 +35,7 @@ module Lrama
       end
 
       def display_name
-        if alias_name
-          alias_name
-        else
-          id.s_value
-        end
+        alias_name || id.s_value
       end
 
       # name for yysymbol_kind_t
@@ -51,11 +48,7 @@ module Lrama
         when eof_symbol?
           name = "YYEOF"
         when term? && id.type == Token::Char
-          if alias_name
-            name = number.to_s + alias_name
-          else
-            name = number.to_s + id.s_value
-          end
+          name = number.to_s + display_name
         when term? && id.type == Token::Ident
           name = id.s_value
         when nterm? && (id.s_value.include?("$") || id.s_value.include?("@"))
@@ -66,7 +59,7 @@ module Lrama
           raise "Unexpected #{self}"
         end
 
-        "YYSYMBOL_" + name.gsub(/[^a-zA-Z_0-9]+/, "_")
+        "YYSYMBOL_" + name.gsub(/\W+/, "_")
       end
 
       # comment for yysymbol_kind_t

data/lib/lrama/grammar.rb

@@ -1,3 +1,4 @@
+require "lrama/grammar/auxiliary"
 require "lrama/grammar/code"
 require "lrama/grammar/error_token"
 require "lrama/grammar/precedence"
@@ -7,16 +8,13 @@ require "lrama/grammar/rule"
 require "lrama/grammar/symbol"
 require "lrama/grammar/union"
 require "lrama/lexer"
+require "lrama/type"
 
 module Lrama
-  Type = Struct.new(:id, :tag, keyword_init: true)
   Token = Lrama::Lexer::Token
 
   # Grammar is the result of parsing an input grammar file
   class Grammar
-    # Grammar file information not used by States but by Output
-    Aux = Struct.new(:prologue_first_lineno, :prologue, :epilogue_first_lineno, :epilogue, keyword_init: true)
-
     attr_reader :eof_symbol, :error_symbol, :undef_symbol, :accept_symbol, :aux
     attr_accessor :union, :expect,
                   :printers, :error_tokens,
@@ -38,7 +36,7 @@ module Lrama
       @error_symbol = nil
       @undef_symbol = nil
       @accept_symbol = nil
-      @aux = Aux.new
+      @aux = Auxiliary.new
 
       append_special_symbols
     end
@@ -48,7 +46,7 @@ module Lrama
     end
 
     def add_error_token(ident_or_tags:, code:, lineno:)
-      @error_tokens << ErrorToken.new(ident_or_tags, code, lineno)
+      @error_tokens << ErrorToken.new(ident_or_tags: ident_or_tags, code: code, lineno: lineno)
     end
 
     def add_term(id:, alias_name: nil, tag: nil, token_id: nil, replace: false)
@@ -215,6 +213,41 @@ module Lrama
       end
     end
 
+    def compute_first_set
+      terms.each do |term|
+        term.first_set = Set.new([term]).freeze
+        term.first_set_bitmap = Lrama::Bitmap.from_array([term.number])
+      end
+
+      nterms.each do |nterm|
+        nterm.first_set = Set.new([]).freeze
+        nterm.first_set_bitmap = Lrama::Bitmap.from_array([])
+      end
+
+      while true do
+        changed = false
+
+        @rules.each do |rule|
+          rule.rhs.each do |r|
+            if rule.lhs.first_set_bitmap | r.first_set_bitmap != rule.lhs.first_set_bitmap
+              changed = true
+              rule.lhs.first_set_bitmap = rule.lhs.first_set_bitmap | r.first_set_bitmap
+            end
+
+            break unless r.nullable
+          end
+        end
+
+        break unless changed
+      end
+
+      nterms.each do |nterm|
+        nterm.first_set = Lrama::Bitmap.to_array(nterm.first_set_bitmap).map do |number|
+          find_symbol_by_number!(number)
+        end.to_set
+      end
+    end
+
     def find_symbol_by_s_value(s_value)
       @symbols.find do |sym|
         sym.id.s_value == s_value

data/lib/lrama/lexer/token/type.rb

@@ -0,0 +1,8 @@
+module Lrama
+  class Lexer
+    class Token < Struct.new(:type, :s_value, :alias, keyword_init: true)
+      class Type < Struct.new(:id, :name, keyword_init: true)
+      end
+    end
+  end
+end

data/lib/lrama/lexer/token.rb

@@ -1,7 +1,8 @@
+require 'lrama/lexer/token/type'
+
 module Lrama
   class Lexer
-    class Token < Struct.new(:type, :s_value, :alias, keyword_init: true)
-      Type = Struct.new(:id, :name, keyword_init: true)
+    class Token
 
       attr_accessor :line, :column, :referred
       # For User_code

data/lib/lrama/output.rb

@@ -252,7 +252,7 @@ module Lrama
     end
 
     def extract_param_name(param)
-      /\A(.)+([a-zA-Z0-9_]+)\z/.match(param)[2]
+      /\A(\W*)([a-zA-Z0-9_]+)\z/.match(param.split.last)[2]
     end
 
     def parse_param_name

data/lib/lrama/parser/token_scanner.rb

@@ -11,7 +11,7 @@ module Lrama
       end
 
       def current_type
-        current_token && current_token.type
+        current_token&.type
       end
 
       def previous_token
@@ -26,9 +26,7 @@ module Lrama
 
       def consume(*token_types)
         if token_types.include?(current_type)
-          token = current_token
-          self.next
-          return token
+          return self.next
         end
 
         return nil
@@ -42,8 +40,7 @@ module Lrama
         a = []
 
         while token_types.include?(current_type)
-          a << current_token
-          self.next
+          a << self.next
         end
 
         raise "No token is consumed. #{token_types}" if a.empty?

data/lib/lrama/parser.rb

@@ -22,6 +22,7 @@ module Lrama
         process_epilogue(grammar, lexer)
         grammar.prepare
         grammar.compute_nullable
+        grammar.compute_first_set
         grammar.validate!
 
         grammar

data/lib/lrama/state/reduce_reduce_conflict.rb

@@ -0,0 +1,9 @@
+module Lrama
+  class State
+    class ReduceReduceConflict < Struct.new(:symbols, :reduce1, :reduce2, keyword_init: true)
+      def type
+        :reduce_reduce
+      end
+    end
+  end
+end

data/lib/lrama/state/shift_reduce_conflict.rb

@@ -0,0 +1,9 @@
+module Lrama
+  class State
+    class ShiftReduceConflict < Struct.new(:symbols, :shift, :reduce, keyword_init: true)
+      def type
+        :shift_reduce
+      end
+    end
+  end
+end

data/lib/lrama/state.rb

@@ -1,11 +1,11 @@
 require "lrama/state/reduce"
-require "lrama/state/shift"
+require "lrama/state/reduce_reduce_conflict"
 require "lrama/state/resolved_conflict"
+require "lrama/state/shift"
+require "lrama/state/shift_reduce_conflict"
 
 module Lrama
   class State
-    Conflict = Struct.new(:symbols, :reduce, :type, keyword_init: true)
-
     attr_reader :id, :accessing_symbol, :kernels, :conflicts, :resolved_conflicts,
                 :default_reduction_rule, :closure, :items
     attr_accessor :shifts, :reduces
@@ -101,6 +101,10 @@ module Lrama
       @term_transitions
     end
 
+    def transitions
+      term_transitions + nterm_transitions
+    end
+
     def selected_term_transitions
       term_transitions.select do |shift, next_state|
         !shift.not_selected
@@ -144,6 +148,10 @@ module Lrama
       end
     end
 
+    def has_conflicts?
+      !@conflicts.empty?
+    end
+
     def sr_conflicts
       @conflicts.select do |conflict|
         conflict.type == :shift_reduce

data/lib/lrama/states/item.rb

@@ -12,20 +12,56 @@ module Lrama
         rule.id
       end
 
+      def empty_rule?
+        rule.empty_rule?
+      end
+
+      def number_of_rest_symbols
+        rule.rhs.count - position
+      end
+
+      def lhs
+        rule.lhs
+      end
+
       def next_sym
         rule.rhs[position]
       end
 
+      def next_next_sym
+        rule.rhs[position + 1]
+      end
+
+      def previous_sym
+        rule.rhs[position - 1]
+      end
+
       def end_of_rule?
         rule.rhs.count == position
       end
 
+      def beginning_of_rule?
+        position == 0
+      end
+
+      def start_item?
+        rule.id == 0 && position == 0
+      end
+
       def new_by_next_position
         Item.new(rule: rule, position: position + 1)
       end
 
-      def previous_sym
-        rule.rhs[position - 1]
+      def symbols_before_dot
+        rule.rhs[0...position]
+      end
+
+      def symbols_after_dot
+        rule.rhs[position..-1]
+      end
+
+      def to_s
+        "#{lhs.id.s_value}: #{display_name}"
       end
 
       def display_name

data/lib/lrama/states.rb

@@ -102,43 +102,27 @@ module Lrama
     end
 
     def direct_read_sets
-      h = {}
-
-      @direct_read_sets.each do |k, v|
-        h[k] = bitmap_to_terms(v)
+      @direct_read_sets.transform_values do |v|
+        bitmap_to_terms(v)
       end
-
-      return h
     end
 
     def read_sets
-      h = {}
-
-      @read_sets.each do |k, v|
-        h[k] = bitmap_to_terms(v)
+      @read_sets.transform_values do |v|
+        bitmap_to_terms(v)
       end
-
-      return h
     end
 
     def follow_sets
-      h = {}
-
-      @follow_sets.each do |k, v|
-        h[k] = bitmap_to_terms(v)
+      @follow_sets.transform_values do |v|
+        bitmap_to_terms(v)
       end
-
-      return h
     end
 
     def la
-      h = {}
-
-      @la.each do |k, v|
-        h[k] = bitmap_to_terms(v)
+      @la.transform_values do |v|
+        bitmap_to_terms(v)
       end
-
-      return h
     end
 
     private
@@ -452,7 +436,7 @@ module Lrama
 
             # Can resolve only when both have prec
             unless shift_prec && reduce_prec
-              state.conflicts << State::Conflict.new(symbols: [sym], reduce: reduce, type: :shift_reduce)
+              state.conflicts << State::ShiftReduceConflict.new(symbols: [sym], shift: shift, reduce: reduce)
               next
             end
 
@@ -501,16 +485,21 @@ module Lrama
 
     def compute_reduce_reduce_conflicts
       states.each do |state|
-        a = []
+        count = state.reduces.count
 
-        state.reduces.each do |reduce|
-          next if reduce.look_ahead.nil?
+        for i in 0...count do
+          reduce1 = state.reduces[i]
+          next if reduce1.look_ahead.nil?
 
-          intersection = a & reduce.look_ahead
-          a += reduce.look_ahead
+          for j in (i+1)...count do
+            reduce2 = state.reduces[j]
+            next if reduce2.look_ahead.nil?
 
-          if !intersection.empty?
-            state.conflicts << State::Conflict.new(symbols: intersection.dup, reduce: reduce, type: :reduce_reduce)
+            intersection = reduce1.look_ahead & reduce2.look_ahead
+
+            if !intersection.empty?
+              state.conflicts << State::ReduceReduceConflict.new(symbols: intersection, reduce1: reduce1, reduce2: reduce2)
+            end
           end
         end
       end

data/lib/lrama/states_reporter.rb

@@ -14,13 +14,13 @@ module Lrama
 
     private
 
-    def _report(io, grammar: false, states: false, itemsets: false, lookaheads: false, solved: false, verbose: false)
+    def _report(io, grammar: false, states: false, itemsets: false, lookaheads: false, solved: false, counterexamples: false, verbose: false)
       # TODO: Unused terms
       # TODO: Unused rules
 
       report_conflicts(io)
       report_grammar(io) if grammar
-      report_states(io, itemsets, lookaheads, solved, verbose)
+      report_states(io, itemsets, lookaheads, solved, counterexamples, verbose)
     end
 
     def report_conflicts(io)
@@ -71,7 +71,11 @@ module Lrama
       io << "\n\n"
     end
 
-    def report_states(io, itemsets, lookaheads, solved, verbose)
+    def report_states(io, itemsets, lookaheads, solved, counterexamples, verbose)
+      if counterexamples
+        cex = Counterexamples.new(@states)
+      end
+
       @states.states.each do |state|
         # Report State
         io << "State #{state.id}\n\n"
@@ -194,6 +198,27 @@ module Lrama
           io << "\n" if !state.resolved_conflicts.empty?
         end
 
+        if counterexamples && state.has_conflicts?
+          # Report counterexamples
+          examples = cex.compute(state)
+          examples.each do |example|
+            label0 = example.type == :shift_reduce ? "shift/reduce"  : "reduce/reduce"
+            label1 = example.type == :shift_reduce ? "Shift derivation"  : "First Reduce derivation"
+            label2 = example.type == :shift_reduce ? "Reduce derivation" : "Second Reduce derivation"
+
+            io << "    #{label0} conflict on token #{example.conflict_symbol.id.s_value}:\n"
+            io << "        #{example.path1_item.to_s}\n"
+            io << "        #{example.path2_item.to_s}\n"
+            io << "      #{label1}\n"
+            example.derivations1.render_strings_for_report.each do |str|
+              io << "        #{str}\n"
+            end
+            io << "      #{label2}\n"
+            example.derivations2.render_strings_for_report.each do |str|
+              io << "        #{str}\n"
+            end
+          end
+        end
 
         if verbose
           # Report direct_read_sets

data/lib/lrama/type.rb

@@ -0,0 +1,4 @@
+module Lrama
+  class Type < Struct.new(:id, :tag, keyword_init: true)
+  end
+end

data/lib/lrama/version.rb

@@ -1,3 +1,3 @@
 module Lrama
-  VERSION = "0.5.3".freeze
+  VERSION = "0.5.4".freeze
 end

data/lib/lrama.rb

@@ -1,6 +1,7 @@
 require "lrama/bitmap"
 require "lrama/command"
 require "lrama/context"
+require "lrama/counterexamples"
 require "lrama/digraph"
 require "lrama/grammar"
 require "lrama/lexer"
@@ -10,5 +11,6 @@ require "lrama/report"
 require "lrama/state"
 require "lrama/states"
 require "lrama/states_reporter"
+require "lrama/type"
 require "lrama/version"
 require "lrama/warning"