lrama 0.5.2 → 0.5.4

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

@@ -1,4 +1,4 @@
-require "lrama/report"
+require "lrama/report/duration"
 require "lrama/parser/token_scanner"
 
 module Lrama
@@ -22,6 +22,7 @@ module Lrama
         process_epilogue(grammar, lexer)
         grammar.prepare
         grammar.compute_nullable
+        grammar.compute_first_set
         grammar.validate!
 
         grammar
@@ -59,6 +60,13 @@ module Lrama
           code = grammar.build_code(:printer, code)
           ident_or_tags = ts.consume_multi(T::Ident, T::Tag)
           grammar.add_printer(ident_or_tags: ident_or_tags, code: code, lineno: lineno)
+        when T::P_error_token
+          lineno = ts.current_token.line
+          ts.next
+          code = ts.consume!(T::User_code)
+          code = grammar.build_code(:printer, code)
+          ident_or_tags = ts.consume_multi(T::Ident, T::Tag)
+          grammar.add_error_token(ident_or_tags: ident_or_tags, code: code, lineno: lineno)
         when T::P_lex_param
           ts.next
           code = ts.consume!(T::User_code)

data/lib/lrama/report/duration.rb

@@ -0,0 +1,25 @@
+module Lrama
+  class Report
+    module Duration
+      def self.enable
+        @_report_duration_enabled = true
+      end
+
+      def self.enabled?
+        !!@_report_duration_enabled
+      end
+
+      def report_duration(method_name)
+        time1 = Time.now.to_f
+        result = yield
+        time2 = Time.now.to_f
+
+        if Duration.enabled?
+          puts sprintf("%s %10.5f s", method_name, time2 - time1)
+        end
+
+        return result
+      end
+    end
+  end
+end

data/lib/lrama/report/profile.rb

@@ -0,0 +1,25 @@
+module Lrama
+  class Report
+    module Profile
+      # 1. Wrap target method with Profile.report_profile like below:
+      #
+      #   Lrama::Report::Profile.report_profile { method }
+      #
+      # 2. Run lrama command, for example
+      #
+      #   $ ./exe/lrama --trace=time spec/fixtures/integration/ruby_3_2_0/parse.tmp.y
+      #
+      # 3. Generate html file
+      #
+      #   $ stackprof --d3-flamegraph tmp/stackprof-cpu-myapp.dump > tmp/flamegraph.html
+      #
+      def self.report_profile
+        require "stackprof"
+
+        StackProf.run(mode: :cpu, raw: true, out: 'tmp/stackprof-cpu-myapp.dump') do
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/lrama/report.rb

@@ -1,47 +1,2 @@
-module Lrama
-  class Report
-    module Profile
-      # 1. Wrap target method with Profile.report_profile like below:
-      #
-      #   Lrama::Report::Profile.report_profile { method }
-      #
-      # 2. Run lrama command, for example
-      #
-      #   $ ./exe/lrama --trace=time spec/fixtures/integration/ruby_3_2_0/parse.tmp.y
-      #
-      # 3. Generate html file
-      #
-      #   $ stackprof --d3-flamegraph tmp/stackprof-cpu-myapp.dump > tmp/flamegraph.html
-      #
-      def self.report_profile
-        require "stackprof"
-
-        StackProf.run(mode: :cpu, raw: true, out: 'tmp/stackprof-cpu-myapp.dump') do
-          yield
-        end
-      end
-    end
-
-    module Duration
-      def self.enable
-        @_report_duration_enabled = true
-      end
-
-      def self.enabled?
-        !!@_report_duration_enabled
-      end
-
-      def report_duration(method_name)
-        time1 = Time.now.to_f
-        result = yield
-        time2 = Time.now.to_f
-
-        if Duration.enabled?
-          puts sprintf("%s %10.5f s", method_name, time2 - time1)
-        end
-
-        return result
-      end
-    end
-  end
-end
+require 'lrama/report/duration'
+require 'lrama/report/profile'

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/resolved_conflict.rb

@@ -0,0 +1,29 @@
+module Lrama
+  class State
+    # * symbol: A symbol under discussion
+    # * reduce: A reduce under discussion
+    # * which: For which a conflict is resolved. :shift, :reduce or :error (for nonassociative)
+    class ResolvedConflict < Struct.new(:symbol, :reduce, :which, :same_prec, keyword_init: true)
+      def report_message
+        s = symbol.display_name
+        r = reduce.rule.precedence_sym.display_name
+        case
+        when which == :shift && same_prec
+          msg = "resolved as #{which} (%right #{s})"
+        when which == :shift
+          msg = "resolved as #{which} (#{r} < #{s})"
+        when which == :reduce && same_prec
+          msg = "resolved as #{which} (%left #{s})"
+        when which == :reduce
+          msg = "resolved as #{which} (#{s} < #{r})"
+        when which == :error
+          msg = "resolved as an #{which} (%nonassoc #{s})"
+        else
+          raise "Unknown direction. #{self}"
+        end
+
+        "Conflict between rule #{reduce.rule.id} and token #{s} #{msg}."
+      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,36 +1,11 @@
 require "lrama/state/reduce"
+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
-    # * symbol: A symbol under discussion
-    # * reduce: A reduce under discussion
-    # * which: For which a conflict is resolved. :shift, :reduce or :error (for nonassociative)
-    ResolvedConflict = Struct.new(:symbol, :reduce, :which, :same_prec, keyword_init: true) do
-      def report_message
-        s = symbol.display_name
-        r = reduce.rule.precedence_sym.display_name
-        case
-        when which == :shift && same_prec
-          msg = "resolved as #{which} (%right #{s})"
-        when which == :shift
-          msg = "resolved as #{which} (#{r} < #{s})"
-        when which == :reduce && same_prec
-          msg = "resolved as #{which} (%left #{s})"
-        when which == :reduce
-          msg = "resolved as #{which} (#{s} < #{r})"
-        when which == :error
-          msg = "resolved as an #{which} (%nonassoc #{s})"
-        else
-          raise "Unknown direction. #{self}"
-        end
-
-        "Conflict between rule #{reduce.rule.id} and token #{s} #{msg}."
-      end
-    end
-
-    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
@@ -96,7 +71,7 @@ module Lrama
       reduce.look_ahead = look_ahead
     end
 
-    # Returns array of [nterm, next_state]
+    # Returns array of [Shift, next_state]
     def nterm_transitions
       return @nterm_transitions if @nterm_transitions
 
@@ -111,7 +86,7 @@ module Lrama
       @nterm_transitions
     end
 
-    # Returns array of [term, next_state]
+    # Returns array of [Shift, next_state]
     def term_transitions
       return @term_transitions if @term_transitions
 
@@ -126,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
@@ -169,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

@@ -0,0 +1,79 @@
+# TODO: Validate position is not over rule rhs
+
+module Lrama
+  class States
+    class Item < Struct.new(:rule, :position, keyword_init: true)
+      # Optimization for States#setup_state
+      def hash
+        [rule.id, position].hash
+      end
+
+      def rule_id
+        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 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
+        r = rule.rhs.map(&:display_name).insert(position, "•").join(" ")
+        "#{r}  (rule #{rule.id})"
+      end
+
+      # Right after position
+      def display_rest
+        r = rule.rhs[position..-1].map(&:display_name).join(" ")
+        ". #{r}  (rule #{rule.id})"
+      end
+    end
+  end
+end

data/lib/lrama/states.rb

@@ -1,5 +1,6 @@
 require "forwardable"
-require "lrama/report"
+require "lrama/report/duration"
+require "lrama/states/item"
 
 module Lrama
   # States is passed to a template file
@@ -11,46 +12,7 @@ module Lrama
     include Lrama::Report::Duration
 
     def_delegators "@grammar", :symbols, :terms, :nterms, :rules,
-      :accept_symbol, :eof_symbol, :find_symbol_by_s_value!
-
-    # TODO: Validate position is not over rule rhs
-    Item = Struct.new(:rule, :position, keyword_init: true) do
-      # Optimization for States#setup_state
-      def hash
-        [rule.id, position].hash
-      end
-
-      def rule_id
-        rule.id
-      end
-
-      def next_sym
-        rule.rhs[position]
-      end
-
-      def end_of_rule?
-        rule.rhs.count == position
-      end
-
-      def new_by_next_position
-        Item.new(rule: rule, position: position + 1)
-      end
-
-      def previous_sym
-        rule.rhs[position - 1]
-      end
-
-      def display_name
-        r = rule.rhs.map(&:display_name).insert(position, "•").join(" ")
-        "#{r}  (rule #{rule.id})"
-      end
-
-      # Right after position
-      def display_rest
-        r = rule.rhs[position..-1].map(&:display_name).join(" ")
-        ". #{r}  (rule #{rule.id})"
-      end
-    end
+      :accept_symbol, :eof_symbol, :undef_symbol, :find_symbol_by_s_value!
 
     attr_reader :states, :reads_relation, :includes_relation, :lookback_relation
 
@@ -140,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
@@ -490,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
 
@@ -539,16 +485,21 @@ module Lrama
 
     def compute_reduce_reduce_conflicts
       states.each do |state|
-        a = []
+        count = state.reduces.count
+
+        for i in 0...count do
+          reduce1 = state.reduces[i]
+          next if reduce1.look_ahead.nil?
 
-        state.reduces.each do |reduce|
-          next if reduce.look_ahead.nil?
+          for j in (i+1)...count do
+            reduce2 = state.reduces[j]
+            next if reduce2.look_ahead.nil?
 
-          intersection = a & reduce.look_ahead
-          a += reduce.look_ahead
+            intersection = reduce1.look_ahead & reduce2.look_ahead
 
-          if !intersection.empty?
-            state.conflicts << State::Conflict.new(symbols: intersection.dup, reduce: reduce, type: :reduce_reduce)
+            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.2".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"

data/lrama.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.description   = "LALR (1) parser generator written by Ruby"
   spec.homepage      = "https://github.com/ruby/lrama"
   # See LEGAL.md file for detail
-  spec.license       = "GNU GPLv3"
+  spec.license       = "GPL-3.0-or-later"
   spec.required_ruby_version = Gem::Requirement.new(">= 2.5.0")
 
   spec.files = Dir.chdir(File.expand_path(__dir__)) do

data/sig/lrama/{report.rbs → report/duration.rbs}

@@ -1,9 +1,5 @@
 module Lrama
   class Report
-    module Profile
-      def self.report_profile: { -> void } -> StackProf::result
-    end
-
     module Duration
       self.@_report_duration_enabled: bool | nil
 

data/sig/lrama/report/profile.rbs

@@ -0,0 +1,7 @@
+module Lrama
+  class Report
+    module Profile
+      def self.report_profile: { -> void } -> StackProf::result
+    end
+  end
+end