lrama 0.5.3 → 0.5.5

data/lib/lrama/counterexamples.rb

@@ -0,0 +1,283 @@
+require "set"
+
+require "lrama/counterexamples/derivation"
+require "lrama/counterexamples/example"
+require "lrama/counterexamples/path"
+require "lrama/counterexamples/state_item"
+require "lrama/counterexamples/triple"
+
+module Lrama
+  # See: https://www.cs.cornell.edu/andru/papers/cupex/cupex.pdf
+  #      4. Constructing Nonunifying Counterexamples
+  class Counterexamples
+    attr_reader :transitions, :productions
+
+    def initialize(states)
+      @states = states
+      setup_transitions
+      setup_productions
+    end
+
+    def to_s
+      "#<Counterexamples>"
+    end
+    alias :inspect :to_s
+
+    def compute(conflict_state)
+      conflict_state.conflicts.flat_map do |conflict|
+        case conflict.type
+        when :shift_reduce
+          shift_reduce_example(conflict_state, conflict)
+        when :reduce_reduce
+          reduce_reduce_examples(conflict_state, conflict)
+        end
+      end.compact
+    end
+
+    private
+
+    def setup_transitions
+      # Hash [StateItem, Symbol] => StateItem
+      @transitions = {}
+      # Hash [StateItem, Symbol] => Set(StateItem)
+      @reverse_transitions = {}
+
+      @states.states.each do |src_state|
+        trans = {}
+
+        src_state.transitions.each do |shift, next_state|
+          trans[shift.next_sym] = next_state
+        end
+
+        src_state.items.each do |src_item|
+          next if src_item.end_of_rule?
+          sym = src_item.next_sym
+          dest_state = trans[sym]
+
+          dest_state.kernels.each do |dest_item|
+            next unless (src_item.rule == dest_item.rule) && (src_item.position + 1 == dest_item.position)
+            src_state_item = StateItem.new(src_state, src_item)
+            dest_state_item = StateItem.new(dest_state, dest_item)
+
+            @transitions[[src_state_item, sym]] = dest_state_item
+
+            key = [dest_state_item, sym]
+            @reverse_transitions[key] ||= Set.new
+            @reverse_transitions[key] << src_state_item
+          end
+        end
+      end
+    end
+
+    def setup_productions
+      # Hash [StateItem] => Set(Item)
+      @productions = {}
+      # Hash [State, Symbol] => Set(Item). Symbol is nterm
+      @reverse_productions = {}
+
+      @states.states.each do |state|
+        # LHS => Set(Item)
+        h = {}
+
+        state.closure.each do |item|
+          sym = item.lhs
+
+          h[sym] ||= Set.new
+          h[sym] << item
+        end
+
+        state.items.each do |item|
+          next if item.end_of_rule?
+          next if item.next_sym.term?
+
+          sym = item.next_sym
+          state_item = StateItem.new(state, item)
+          key = [state, sym]
+
+          @productions[state_item] = h[sym]
+
+          @reverse_productions[key] ||= Set.new
+          @reverse_productions[key] << item
+        end
+      end
+    end
+
+    def shift_reduce_example(conflict_state, conflict)
+      conflict_symbol = conflict.symbols.first
+      shift_conflict_item = conflict_state.items.find { |item| item.next_sym == conflict_symbol }
+      path2 = shortest_path(conflict_state, conflict.reduce.item, conflict_symbol)
+      path1 = find_shift_conflict_shortest_path(path2, conflict_state, shift_conflict_item)
+
+      Example.new(path1, path2, conflict, conflict_symbol, self)
+    end
+
+    def reduce_reduce_examples(conflict_state, conflict)
+      conflict_symbol = conflict.symbols.first
+      path1 = shortest_path(conflict_state, conflict.reduce1.item, conflict_symbol)
+      path2 = shortest_path(conflict_state, conflict.reduce2.item, conflict_symbol)
+
+      Example.new(path1, path2, conflict, conflict_symbol, self)
+    end
+
+    def find_shift_conflict_shortest_path(reduce_path, conflict_state, conflict_item)
+      state_items = find_shift_conflict_shortest_state_items(reduce_path, conflict_state, conflict_item)
+      build_paths_from_state_items(state_items)
+    end
+
+    def find_shift_conflict_shortest_state_items(reduce_path, conflict_state, conflict_item)
+      target_state_item = StateItem.new(conflict_state, conflict_item)
+      result = [target_state_item]
+      reversed_reduce_path = reduce_path.to_a.reverse
+      # Index for state_item
+      i = 0
+
+      while (path = reversed_reduce_path[i])
+        # Index for prev_state_item
+        j = i + 1
+        _j = j
+
+        while (prev_path = reversed_reduce_path[j])
+          if prev_path.production?
+            j += 1
+          else
+            break
+          end
+        end
+
+        state_item = path.to
+        prev_state_item = prev_path&.to
+
+        if target_state_item == state_item || target_state_item.item.start_item?
+          result.concat(reversed_reduce_path[_j..-1].map(&:to))
+          break
+        end
+
+        if target_state_item.item.beginning_of_rule?
+          queue = []
+          queue << [target_state_item]
+
+          # Find reverse production
+          while (sis = queue.shift)
+            si = sis.last
+
+            # Reach to start state
+            if si.item.start_item?
+              sis.shift
+              result.concat(sis)
+              target_state_item = si
+              break
+            end
+
+            if !si.item.beginning_of_rule?
+              key = [si, si.item.previous_sym]
+              @reverse_transitions[key].each do |prev_target_state_item|
+                next if prev_target_state_item.state != prev_state_item.state
+                sis.shift
+                result.concat(sis)
+                result << prev_target_state_item
+                target_state_item = prev_target_state_item
+                i = j
+                queue.clear
+                break
+              end
+            else
+              key = [si.state, si.item.lhs]
+              @reverse_productions[key].each do |item|
+                state_item = StateItem.new(si.state, item)
+                queue << (sis + [state_item])
+              end
+            end
+          end
+        else
+          # Find reverse transition
+          key = [target_state_item, target_state_item.item.previous_sym]
+          @reverse_transitions[key].each do |prev_target_state_item|
+            next if prev_target_state_item.state != prev_state_item.state
+            result << prev_target_state_item
+            target_state_item = prev_target_state_item
+            i = j
+            break
+          end
+        end
+      end
+
+      result.reverse
+    end
+
+    def build_paths_from_state_items(state_items)
+      state_items.zip([nil] + state_items).map do |si, prev_si|
+        case
+        when prev_si.nil?
+          StartPath.new(si)
+        when si.item.beginning_of_rule?
+          ProductionPath.new(prev_si, si)
+        else
+          TransitionPath.new(prev_si, si)
+        end
+      end
+    end
+
+    def shortest_path(conflict_state, conflict_reduce_item, conflict_term)
+      # queue: is an array of [Triple, [Path]]
+      queue = []
+      visited = {}
+      start_state = @states.states.first
+      raise "BUG: Start state should be just one kernel." if start_state.kernels.count != 1
+
+      start = Triple.new(start_state, start_state.kernels.first, Set.new([@states.eof_symbol]))
+
+      queue << [start, [StartPath.new(start.state_item)]]
+
+      while true
+        triple, paths = queue.shift
+
+        next if visited[triple]
+        visited[triple] = true
+
+        # Found
+        if triple.state == conflict_state && triple.item == conflict_reduce_item && triple.l.include?(conflict_term)
+          return paths
+        end
+
+        # transition
+        triple.state.transitions.each do |shift, next_state|
+          next unless triple.item.next_sym && triple.item.next_sym == shift.next_sym
+          next_state.kernels.each do |kernel|
+            next if kernel.rule != triple.item.rule
+            t = Triple.new(next_state, kernel, triple.l)
+            queue << [t, paths + [TransitionPath.new(triple.state_item, t.state_item)]]
+          end
+        end
+
+        # production step
+        triple.state.closure.each do |item|
+          next unless triple.item.next_sym && triple.item.next_sym == item.lhs
+          l = follow_l(triple.item, triple.l)
+          t = Triple.new(triple.state, item, l)
+          queue << [t, paths + [ProductionPath.new(triple.state_item, t.state_item)]]
+        end
+
+        break if queue.empty?
+      end
+
+      return nil
+    end
+
+    def follow_l(item, current_l)
+      # 1. follow_L (A -> X1 ... Xn-1 • Xn) = L
+      # 2. follow_L (A -> X1 ... Xk • Xk+1 Xk+2 ... Xn) = {Xk+2} if Xk+2 is a terminal
+      # 3. follow_L (A -> X1 ... Xk • Xk+1 Xk+2 ... Xn) = FIRST(Xk+2) if Xk+2 is a nonnullable nonterminal
+      # 4. follow_L (A -> X1 ... Xk • Xk+1 Xk+2 ... Xn) = FIRST(Xk+2) + follow_L (A -> X1 ... Xk+1 • Xk+2 ... Xn) if Xk+2 is a nullable nonterminal
+      case
+      when item.number_of_rest_symbols == 1
+        current_l
+      when item.next_next_sym.term?
+        Set.new([item.next_next_sym])
+      when !item.next_next_sym.nullable
+        item.next_next_sym.first_set
+      else
+        item.next_next_sym.first_set + follow_l(item.new_by_next_position, current_l)
+      end
+    end
+  end
+end

data/lib/lrama/digraph.rb

@@ -33,7 +33,7 @@ module Lrama
       @h[x] = d
       @result[x] = @base_function[x] # F x = F' x
 
-      @relation[x] && @relation[x].each do |y|
+      @relation[x]&.each do |y|
         traverse(y) if @h[y] == 0
         @h[x] = [@h[x], @h[y]].min
         @result[x] |= @result[y] # F x = F x + F y
@@ -43,9 +43,8 @@ module Lrama
         while true do
           z = @stack.pop
           @h[z] = Float::INFINITY
-          @result[z] = @result[x] # F (Top of S) = F x
-
           break if z == x
+          @result[z] = @result[x] # F (Top of S) = F x
         end
       end
     end

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

@@ -50,7 +50,6 @@ module Lrama
       end
       alias :translated_error_token_code :translated_printer_code
 
-
       private
 
       # * ($1) yyvsp[i]

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)
@@ -105,6 +103,10 @@ module Lrama
       set_precedence(sym, Precedence.new(type: :right, precedence: precedence))
     end
 
+    def add_precedence(sym, precedence)
+      set_precedence(sym, Precedence.new(type: :precedence, precedence: precedence))
+    end
+
     def set_precedence(sym, precedence)
       raise "" if sym.nterm?
       sym.precedence = precedence
@@ -215,6 +217,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
@@ -277,7 +314,6 @@ module Lrama
       end || (raise "Nterm not found: #{id}")
     end
 
-
     def append_special_symbols
       # YYEMPTY (token_id: -2, number: -2) is added when a template is evaluated
       # term = add_term(id: Token.new(Token::Ident, "YYEMPTY"), token_id: -2)
@@ -479,7 +515,7 @@ module Lrama
               sym.token_id = 11
             when "\""
               sym.token_id = 34
-            when "\'"
+            when "'"
               sym.token_id = 39
             when "\\\\"
               sym.token_id = 92

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
@@ -60,6 +61,7 @@ module Lrama
       define_type(:P_nonassoc)       # %nonassoc
       define_type(:P_left)           # %left
       define_type(:P_right)          # %right
+      define_type(:P_precedence)     # %precedence
       define_type(:P_prec)           # %prec
       define_type(:User_code)        # { ... }
       define_type(:Tag)              # <int>

data/lib/lrama/lexer.rb

@@ -30,7 +30,6 @@ module Lrama
       @grammar_rules = []
       @epilogue = []
 
-      #
       @bison_declarations_tokens = []
       @grammar_rules_tokens = []
 
@@ -155,6 +154,8 @@ module Lrama
           tokens << create_token(Token::P_left, ss[0], line, ss.pos - column)
         when ss.scan(/%right/)
           tokens << create_token(Token::P_right, ss[0], line, ss.pos - column)
+        when ss.scan(/%precedence/)
+          tokens << create_token(Token::P_precedence, ss[0], line, ss.pos - column)
         when ss.scan(/%prec/)
           tokens << create_token(Token::P_prec, ss[0], line, ss.pos - column)
         when ss.scan(/{/)
@@ -223,7 +224,7 @@ module Lrama
           references << [:dollar, ss[2], tag, str.length, str.length + ss[0].length - 1]
         when ss.scan(/@\$/) # @$
           references << [:at, "$", nil, str.length, str.length + ss[0].length - 1]
-        when ss.scan(/@(\d)+/) # @1
+        when ss.scan(/@(\d+)/) # @1
           references << [:at, Integer(ss[1]), nil, str.length, str.length + ss[0].length - 1]
         when ss.scan(/{/)
           brace_count += 1
@@ -314,8 +315,6 @@ module Lrama
           str << ss.getch
           next
         end
-
-        str << ss[0]
       end
 
       line # Reach to end of input

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]
+      param[/\b([a-zA-Z0-9_]+)(?=\s*\z)/]
     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
@@ -158,6 +159,14 @@ module Lrama
             grammar.add_right(sym, precedence_number)
           end
           precedence_number += 1
+        when T::P_precedence
+          # %precedence (ident|char|string)+
+          ts.next
+          while (id = ts.consume(T::Ident, T::Char, T::String)) do
+            sym = grammar.add_term(id: id)
+            grammar.add_precedence(sym, precedence_number)
+          end
+          precedence_number += 1
         when nil
           # end of input
           raise "Reach to end of input within declarations"

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
@@ -62,7 +62,6 @@ module Lrama
       @items_to_state[items] = next_state
     end
 
-    #
     def set_look_ahead(rule, look_ahead)
       reduce = reduces.find do |r|
         r.rule == rule
@@ -101,6 +100,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 +147,10 @@ module Lrama
       end
     end
 
+    def has_conflicts?
+      !@conflicts.empty?
+    end
+
     def sr_conflicts
       @conflicts.select do |conflict|
         conflict.type == :shift_reduce