enclave 0.1.0

data/ext/enclave/mruby/tools/lrama/lib/lrama/counterexamples/example.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Lrama
+  class Counterexamples
+    class Example
+      attr_reader :path1, :path2, :conflict, :conflict_symbol
+
+      # path1 is shift conflict when S/R conflict
+      # path2 is always reduce conflict
+      def initialize(path1, path2, conflict, conflict_symbol, counterexamples)
+        @path1 = path1
+        @path2 = path2
+        @conflict = conflict
+        @conflict_symbol = conflict_symbol
+        @counterexamples = counterexamples
+      end
+
+      def type
+        @conflict.type
+      end
+
+      def path1_item
+        @path1.last.to.item
+      end
+
+      def path2_item
+        @path2.last.to.item
+      end
+
+      def derivations1
+        @derivations1 ||= _derivations(path1)
+      end
+
+      def derivations2
+        @derivations2 ||= _derivations(path2)
+      end
+
+      private
+
+      def _derivations(paths)
+        derivation = nil #: Derivation
+        current = :production
+        last_path = paths.last #: Path
+        lookahead_sym = last_path.to.item.end_of_rule? ? @conflict_symbol : nil
+
+        paths.reverse_each do |path|
+          item = path.to.item
+
+          case current
+          when :production
+            case path
+            when StartPath
+              derivation = Derivation.new(item, derivation)
+              current = :start
+            when TransitionPath
+              derivation = Derivation.new(item, derivation)
+              current = :transition
+            when ProductionPath
+              derivation = Derivation.new(item, derivation)
+              current = :production
+            else
+              raise "Unexpected. #{path}"
+            end
+
+            if lookahead_sym && item.next_next_sym && item.next_next_sym.first_set.include?(lookahead_sym)
+              state_item = @counterexamples.transitions[[path.to, item.next_sym]]
+              derivation2 = find_derivation_for_symbol(state_item, lookahead_sym)
+              derivation.right = derivation2 # steep:ignore
+              lookahead_sym = nil
+            end
+
+          when :transition
+            case path
+            when StartPath
+              derivation = Derivation.new(item, derivation)
+              current = :start
+            when TransitionPath
+              # ignore
+              current = :transition
+            when ProductionPath
+              # ignore
+              current = :production
+            end
+          else
+            raise "BUG: Unknown #{current}"
+          end
+
+          break if current == :start
+        end
+
+        derivation
+      end
+
+      def find_derivation_for_symbol(state_item, sym)
+        queue = [] #: Array[Array[StateItem]]
+        queue << [state_item]
+
+        while (sis = queue.shift)
+          si = sis.last
+          next_sym = si.item.next_sym
+
+          if next_sym == sym
+            derivation = nil
+
+            sis.reverse_each do |si|
+              derivation = Derivation.new(si.item, derivation)
+            end
+
+            return derivation
+          end
+
+          if next_sym.nterm? && next_sym.first_set.include?(sym)
+            @counterexamples.productions[si].each do |next_item|
+              next if next_item.empty_rule?
+              next_si = StateItem.new(si.state, next_item)
+              next if sis.include?(next_si)
+              queue << (sis + [next_si])
+            end
+
+            if next_sym.nullable
+              next_si = @counterexamples.transitions[[si, next_sym]]
+              queue << (sis + [next_si])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/ext/enclave/mruby/tools/lrama/lib/lrama/counterexamples/path.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Lrama
+  class Counterexamples
+    class Path
+      def initialize(from_state_item, to_state_item)
+        @from_state_item = from_state_item
+        @to_state_item = to_state_item
+      end
+
+      def from
+        @from_state_item
+      end
+
+      def to
+        @to_state_item
+      end
+
+      def to_s
+        "#<Path(#{type})>"
+      end
+      alias :inspect :to_s
+
+      def type
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/ext/enclave/mruby/tools/lrama/lib/lrama/counterexamples/production_path.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lrama
+  class Counterexamples
+    class ProductionPath < Path
+      def type
+        :production
+      end
+
+      def transition?
+        false
+      end
+
+      def production?
+        true
+      end
+    end
+  end
+end

data/ext/enclave/mruby/tools/lrama/lib/lrama/counterexamples/start_path.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Lrama
+  class Counterexamples
+    class StartPath < Path
+      def initialize(to_state_item)
+        super nil, to_state_item
+      end
+
+      def type
+        :start
+      end
+
+      def transition?
+        false
+      end
+
+      def production?
+        false
+      end
+    end
+  end
+end

data/ext/enclave/mruby/tools/lrama/lib/lrama/counterexamples/state_item.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Lrama
+  class Counterexamples
+    class StateItem < Struct.new(:state, :item)
+    end
+  end
+end

data/ext/enclave/mruby/tools/lrama/lib/lrama/counterexamples/transition_path.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lrama
+  class Counterexamples
+    class TransitionPath < Path
+      def type
+        :transition
+      end
+
+      def transition?
+        true
+      end
+
+      def production?
+        false
+      end
+    end
+  end
+end

data/ext/enclave/mruby/tools/lrama/lib/lrama/counterexamples/triple.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Lrama
+  class Counterexamples
+    # s: state
+    # itm: item within s
+    # l: precise lookahead set
+    class Triple < Struct.new(:s, :itm, :l)
+      alias :state :s
+      alias :item :itm
+      alias :precise_lookahead_set :l
+
+      def state_item
+        StateItem.new(state, item)
+      end
+
+      def inspect
+        "#{state.inspect}. #{item.display_name}. #{l.map(&:id).map(&:s_value)}"
+      end
+      alias :to_s :inspect
+    end
+  end
+end

data/ext/enclave/mruby/tools/lrama/lib/lrama/counterexamples.rb

@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+require "set"
+
+require_relative "counterexamples/derivation"
+require_relative "counterexamples/example"
+require_relative "counterexamples/path"
+require_relative "counterexamples/production_path"
+require_relative "counterexamples/start_path"
+require_relative "counterexamples/state_item"
+require_relative "counterexamples/transition_path"
+require_relative "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
+          # @type var conflict: State::ShiftReduceConflict
+          shift_reduce_example(conflict_state, conflict)
+        when :reduce_reduce
+          # @type var conflict: State::ReduceReduceConflict
+          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 = {} #: Hash[Grammar::Symbol, State]
+
+        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
+
+            # @type var key: [StateItem, Grammar::Symbol]
+            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 = {} #: Hash[Grammar::Symbol, Set[States::Item]]
+
+        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)
+          # @type var key: [State, Grammar::Symbol]
+          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
+      # @type var shift_conflict_item: ::Lrama::States::Item
+      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] #: Array[StartPath|TransitionPath|ProductionPath]
+              .map(&:to))
+          break
+        end
+
+        if target_state_item.item.beginning_of_rule?
+          queue = [] #: Array[Array[StateItem]]
+          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?
+              # @type var key: [State, Grammar::Symbol]
+              key = [si.state, si.item.lhs]
+              @reverse_productions[key].each do |item|
+                state_item = StateItem.new(si.state, item)
+                queue << (sis + [state_item])
+              end
+            else
+              # @type var key: [StateItem, Grammar::Symbol]
+              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
+            end
+          end
+        else
+          # Find reverse transition
+          # @type var key: [StateItem, Grammar::Symbol]
+          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 = [] #: Array[[Triple, Array[StartPath|TransitionPath|ProductionPath]]]
+      visited = {} #: Hash[Triple, true]
+      start_state = @states.states.first #: Lrama::State
+      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/ext/enclave/mruby/tools/lrama/lib/lrama/diagnostics.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Lrama
+  class Diagnostics
+    def initialize(grammar, states, logger)
+      @grammar = grammar
+      @states = states
+      @logger = logger
+    end
+
+    def run(diagnostic)
+      if diagnostic
+        diagnose_conflict
+        diagnose_parameterizing_redefined
+      end
+    end
+
+    private
+
+    def diagnose_conflict
+      if @states.sr_conflicts_count != 0
+        @logger.warn("shift/reduce conflicts: #{@states.sr_conflicts_count} found")
+      end
+
+      if  @states.rr_conflicts_count != 0
+        @logger.warn("reduce/reduce conflicts: #{@states.rr_conflicts_count} found")
+      end
+    end
+
+    def diagnose_parameterizing_redefined
+      @grammar.parameterizing_rule_resolver.redefined_rules.each do |rule|
+        @logger.warn("parameterizing rule redefined: #{rule}")
+      end
+    end
+  end
+end

data/ext/enclave/mruby/tools/lrama/lib/lrama/digraph.rb

@@ -0,0 +1,83 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Lrama
+  # Algorithm Digraph of https://dl.acm.org/doi/pdf/10.1145/69622.357187 (P. 625)
+  #
+  # @rbs generic X < Object -- Type of a member of `sets`
+  # @rbs generic Y < _Or    -- Type of sets assigned to a member of `sets`
+  class Digraph
+    # TODO: rbs-inline 0.10.0 doesn't support instance variables.
+    #       Move these type declarations above instance variable definitions, once it's supported.
+    #
+    # @rbs!
+    #   interface _Or
+    #     def |: (self) -> self
+    #   end
+    #   @sets: Array[X]
+    #   @relation: Hash[X, Array[X]]
+    #   @base_function: Hash[X, Y]
+    #   @stack: Array[X]
+    #   @h: Hash[X, (Integer|Float)?]
+    #   @result: Hash[X, Y]
+
+    # @rbs sets: Array[X]
+    # @rbs relation: Hash[X, Array[X]]
+    # @rbs base_function: Hash[X, Y]
+    # @rbs return: void
+    def initialize(sets, relation, base_function)
+
+      # X in the paper
+      @sets = sets
+
+      # R in the paper
+      @relation = relation
+
+      # F' in the paper
+      @base_function = base_function
+
+      # S in the paper
+      @stack = []
+
+      # N in the paper
+      @h = Hash.new(0)
+
+      # F in the paper
+      @result = {}
+    end
+
+    # @rbs () -> Hash[X, Y]
+    def compute
+      @sets.each do |x|
+        next if @h[x] != 0
+        traverse(x)
+      end
+
+      return @result
+    end
+
+    private
+
+    # @rbs (X x) -> void
+    def traverse(x)
+      @stack.push(x)
+      d = @stack.count
+      @h[x] = d
+      @result[x] = @base_function[x] # F x = F' x
+
+      @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
+      end
+
+      if @h[x] == d
+        while (z = @stack.pop) do
+          @h[z] = Float::INFINITY
+          break if z == x
+          @result[z] = @result[x] # F (Top of S) = F x
+        end
+      end
+    end
+  end
+end

data/ext/enclave/mruby/tools/lrama/lib/lrama/grammar/auxiliary.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+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