rusa 0.1.0

data/lib/rusa/analysis/first_follow.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Rusa
+  module Analysis
+    # FIRST/FOLLOW sets drive lookahead computation for parser construction.
+    class FirstFollow
+      EMPTY = :$empty
+
+      attr_reader :first_sets #: Hash[Symbol, Set[Symbol]]
+      attr_reader :follow_sets #: Hash[Symbol, Set[Symbol]]
+
+      #: (Grammar::Grammar) -> void
+      def initialize(grammar)
+        @grammar = grammar
+        @first_sets = {} #: Hash[Symbol, Set[Symbol]]
+        @follow_sets = {} #: Hash[Symbol, Set[Symbol]]
+        initialize_sets
+        compute_first_sets
+        compute_follow_sets
+      end
+
+      #: (Array[Symbol]) -> Set[Symbol]
+      def first_of_sequence(symbols)
+        return Set[EMPTY] if symbols.empty?
+
+        result = Set.new
+
+        symbols.each do |symbol|
+          first = first_sets.fetch(symbol) { Set[symbol] }
+          result.merge(first - Set[EMPTY])
+          return result unless first.include?(EMPTY)
+        end
+
+        result.add(EMPTY)
+        result
+      end
+
+      private
+
+      attr_reader :grammar #: Grammar::Grammar
+
+      #: () -> void
+      def initialize_sets
+        grammar.terminals.each_key do |name|
+          first_sets[name] = Set[name]
+        end
+
+        grammar.nonterminals.each_key do |name|
+          first_sets[name] = Set.new
+          follow_sets[name] = Set.new
+        end
+      end
+
+      #: () -> void
+      def compute_first_sets
+        loop do
+          changed = false
+
+          grammar.productions.each do |production|
+            additions = if production.empty?
+                          Set[EMPTY]
+                        else
+                          first_of_sequence(production.rhs)
+                        end
+
+            before = first_sets[production.lhs].dup
+            first_sets[production.lhs].merge(additions)
+            changed ||= before != first_sets[production.lhs]
+          end
+
+          break unless changed
+        end
+      end
+
+      #: () -> void
+      def compute_follow_sets
+        start_symbol = grammar.start_symbol or raise NoStartSymbolError, "start symbol is not set"
+        follow_sets[start_symbol].add(Grammar::Grammar::END_OF_INPUT)
+
+        loop do
+          changed = false
+
+          grammar.productions.each do |production|
+            production.rhs.each_with_index do |symbol, index|
+              next unless grammar.nonterminal?(symbol)
+
+              suffix = production.rhs[(index + 1)..] || []
+              suffix_first = first_of_sequence(suffix)
+
+              before = follow_sets[symbol].dup
+              follow_sets[symbol].merge(suffix_first - Set[EMPTY])
+              if suffix.empty? || suffix_first.include?(EMPTY)
+                follow_sets[symbol].merge(follow_sets[production.lhs])
+              end
+              changed ||= before != follow_sets[symbol]
+            end
+          end
+
+          break unless changed
+        end
+      end
+    end
+  end
+end

data/lib/rusa/analysis/item.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Rusa
+  module Analysis
+    # Item represents a single LR(0) production with a dot position.
+    class Item
+      attr_reader :production #: Grammar::Production
+      attr_reader :dot #: Integer
+
+      #: (Grammar::Production, ?Integer) -> void
+      def initialize(production, dot = 0)
+        @production = production
+        @dot = dot
+      end
+
+      #: () -> Symbol?
+      def next_symbol
+        production.rhs[dot]
+      end
+
+      #: () -> Item
+      def advance
+        self.class.new(production, dot + 1)
+      end
+
+      #: () -> bool
+      def reduce?
+        dot >= production.rhs.length
+      end
+
+      #: (Object) -> bool
+      def ==(other)
+        other.is_a?(self.class) && other.production.id == production.id && other.dot == dot
+      end
+      alias eql? ==
+
+      #: () -> Integer
+      def hash
+        [production.id, dot].hash
+      end
+
+      #: () -> String
+      def to_s
+        rhs = production.rhs.dup
+        rhs.insert(dot, :"·")
+        rendered_rhs = rhs.empty? ? "·" : rhs.join(" ")
+        "#{production.lhs} -> #{rendered_rhs}"
+      end
+    end
+  end
+end

data/lib/rusa/analysis/item_set.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Rusa
+  module Analysis
+    # ItemSet is a parser state identified by its LR(0) kernel items.
+    class ItemSet
+      attr_reader :id #: Integer
+      attr_reader :items #: Set[Item]
+      attr_reader :kernel_items #: Set[Item]
+
+      #: (Integer, Enumerable[Item], Grammar::Grammar) -> void
+      def initialize(id, kernel_items, grammar)
+        @id = id
+        @kernel_items = kernel_items.to_set.freeze
+        @items = self.class.closure(@kernel_items, grammar).freeze
+      end
+
+      #: (Object) -> bool
+      def ==(other)
+        other.is_a?(self.class) && other.kernel_items == kernel_items
+      end
+      alias eql? ==
+
+      #: () -> Integer
+      def hash
+        kernel_items.hash
+      end
+
+      #: () -> String
+      def to_s
+        lines = items.to_a.sort_by { |item| [item.production.id, item.dot] }.map(&:to_s)
+        "State #{id}\n#{lines.join("\n")}"
+      end
+
+      #: (Enumerable[Item], Grammar::Grammar) -> Set[Item]
+      def self.closure(kernel_items, grammar)
+        result = kernel_items.to_a.to_set
+
+        loop do
+          changed = false
+
+          result.to_a.each do |item|
+            symbol = item.next_symbol
+            next unless symbol && grammar.nonterminal?(symbol)
+
+            grammar.productions_for(symbol).each do |production|
+              candidate = Item.new(production, 0)
+              next if result.include?(candidate)
+
+              result.add(candidate)
+              changed = true
+            end
+          end
+
+          break unless changed
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/rusa/analysis/lalr_table.rb

@@ -0,0 +1,460 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Rusa
+  module Analysis
+    # LALRTable merges canonical LR(1) states with the same LR(0) core.
+    class LALRTable
+      class LR1Item
+        attr_reader :production #: Grammar::Production
+        attr_reader :dot #: Integer
+        attr_reader :lookahead #: Symbol
+
+        #: (Grammar::Production, Integer, Symbol) -> void
+        def initialize(production, dot, lookahead)
+          @production = production
+          @dot = dot
+          @lookahead = lookahead
+          freeze
+        end
+
+        #: () -> Symbol?
+        def next_symbol
+          production.rhs[dot]
+        end
+
+        #: () -> LR1Item
+        def advance
+          self.class.new(production, dot + 1, lookahead)
+        end
+
+        #: () -> bool
+        def reduce?
+          dot >= production.rhs.length
+        end
+
+        #: () -> [Integer?, Integer]
+        def core
+          [production.id, dot]
+        end
+
+        #: (Object) -> bool
+        def ==(other)
+          other.is_a?(self.class) &&
+            other.production.id == production.id &&
+            other.dot == dot &&
+            other.lookahead == lookahead
+        end
+        alias eql? ==
+
+        #: () -> Integer
+        def hash
+          [production.id, dot, lookahead].hash
+        end
+      end
+
+      class MergedItem
+        attr_reader :production #: Grammar::Production
+        attr_reader :dot #: Integer
+        attr_reader :lookaheads #: Set[Symbol]
+
+        #: (Grammar::Production, Integer, Set[Symbol]) -> void
+        def initialize(production, dot, lookaheads)
+          @production = production
+          @dot = dot
+          @lookaheads = lookaheads
+        end
+
+        #: () -> Symbol?
+        def next_symbol
+          production.rhs[dot]
+        end
+
+        #: () -> bool
+        def reduce?
+          dot >= production.rhs.length
+        end
+
+        #: () -> [Integer?, Integer]
+        def core
+          [production.id, dot]
+        end
+      end
+
+      class MergedState
+        attr_reader :id #: Integer
+        attr_reader :items #: Array[MergedItem]
+
+        #: (Integer, Array[MergedItem]) -> void
+        def initialize(id, items)
+          @id = id
+          @items = items.freeze
+          freeze
+        end
+      end
+
+      attr_reader :action_table #: Hash[Integer, Hash[Symbol, Shift | Reduce | Accept]]
+      attr_reader :goto_table #: Hash[Integer, Hash[Symbol, Integer]]
+      attr_reader :conflicts #: Array[ConflictReport]
+      attr_reader :states #: Array[MergedState]
+      attr_reader :transitions #: Hash[Integer, Hash[Symbol, Integer]]
+
+      #: (Grammar::Grammar, ?first_follow: FirstFollow) -> void
+      def initialize(grammar, first_follow: FirstFollow.new(grammar))
+        @grammar = grammar
+        @first_follow = first_follow
+        @resolver = ConflictResolver.new
+        @action_table = Hash.new do |hash, key|
+          hash[key] = {} #: Hash[Symbol, Shift | Reduce | Accept]
+        end
+        @goto_table = Hash.new do |hash, key|
+          hash[key] = {} #: Hash[Symbol, Integer]
+        end
+        @conflicts = []
+        @states = []
+        @transitions = Hash.new do |hash, key|
+          hash[key] = {} #: Hash[Symbol, Integer]
+        end
+        build_tables
+      end
+
+      #: () -> String
+      def report
+        lines = [] #: Array[String]
+        lines << "states: #{states.length}"
+        conflicts.each do |conflict|
+          lines << conflict_message(conflict)
+        end
+        lines.join("\n")
+      end
+
+      private
+
+      attr_reader :grammar #: Grammar::Grammar
+      attr_reader :first_follow #: FirstFollow
+      attr_reader :resolver #: ConflictResolver
+
+      #: () -> void
+      def build_tables
+        canonical_states, canonical_transitions = build_canonical_automaton
+        merge_states(canonical_states, canonical_transitions)
+        populate_tables
+      end
+
+      #: () -> [Array[Set[LR1Item]], Hash[Integer, Hash[Symbol, Integer]]]
+      def build_canonical_automaton
+        state0 = initial_lr1_state
+        states = [state0] #: Array[Set[LR1Item]]
+        transitions = empty_transition_table
+        known = { lr1_state_key(state0) => 0 }
+        worklist = [0]
+
+        until worklist.empty?
+          state_id = worklist.shift
+          build_canonical_transitions_for(
+            states,
+            transitions,
+            known,
+            worklist,
+            state_id
+          )
+        end
+
+        [states, transitions]
+      end
+
+      #: (Enumerable[LR1Item]) -> Set[LR1Item]
+      def lr1_closure(items)
+        result = items.to_set
+
+        loop do
+          changed = false
+
+          result.to_a.each do |item|
+            symbol = item.next_symbol
+            next unless symbol && grammar.nonterminal?(symbol)
+
+            changed ||= add_closure_items(result, item, symbol)
+          end
+
+          break unless changed
+        end
+
+        result
+      end
+
+      #: (Enumerable[LR1Item]) -> Array[Array[Integer | nil | Symbol]]
+      def lr1_state_key(items)
+        items.map { |item| [item.production.id, item.dot, item.lookahead] }.sort.freeze
+      end
+
+      #: (Array[Set[LR1Item]], Hash[Integer, Hash[Symbol, Integer]]) -> void
+      def merge_states(canonical_states, canonical_transitions)
+        merged_ids = {} #: Hash[Integer, Integer]
+        grouped_states = group_states_by_lr0_core(canonical_states)
+
+        grouped_states.each_with_index do |(_, canonical_indexes), merged_id|
+          states << merge_state_group(
+            canonical_states,
+            canonical_indexes,
+            merged_ids,
+            merged_id
+          )
+        end
+
+        merge_transitions(canonical_transitions, merged_ids)
+      end
+
+      #: (Enumerable[LR1Item]) -> Array[Array[Integer?]]
+      def lr0_core_key(items)
+        items.map(&:core).sort.freeze
+      end
+
+      #: () -> void
+      def populate_tables
+        productions_by_id = index_productions_by_id
+
+        states.each do |state|
+          populate_actions_for(state, productions_by_id)
+          populate_gotos_for(state)
+        end
+      end
+
+      #: (Integer, Symbol, Shift | Reduce | Accept, Hash[Integer?, Grammar::Production]) -> void
+      def add_action(state_id, lookahead, action, productions_by_id)
+        existing = action_table[state_id][lookahead]
+        if existing.nil?
+          action_table[state_id][lookahead] = action
+          return
+        end
+
+        return if existing == action
+
+        resolved, report = resolver.resolve(
+          existing,
+          action,
+          lookahead,
+          grammar,
+          state_id: state_id,
+          productions_by_id: productions_by_id
+        )
+        conflicts << report
+        if resolved.nil?
+          action_table[state_id].delete(lookahead)
+        else
+          action_table[state_id][lookahead] = resolved
+        end
+      end
+
+      #: () -> Set[LR1Item]
+      def initial_lr1_state
+        start_item = LR1Item.new(
+          grammar.augmented_production,
+          0,
+          Grammar::Grammar::END_OF_INPUT
+        )
+        lr1_closure(Set[start_item])
+      end
+
+      #: () -> Hash[Integer, Hash[Symbol, Integer]]
+      def empty_transition_table
+        Hash.new do |hash, key|
+          hash[key] = {} #: Hash[Symbol, Integer]
+        end
+      end
+
+      #: (Array[Set[LR1Item]], Hash[Integer, Hash[Symbol, Integer]], Hash[Array[Array[Integer | nil | Symbol]], Integer], Array[Integer], Integer) -> void
+      def build_canonical_transitions_for(states, transitions, known, worklist, state_id)
+        state = states.fetch(state_id)
+
+        next_symbols_for(state).each do |symbol|
+          target = target_state_for(state, symbol)
+          target_id = register_state(states, known, worklist, target)
+          transitions[state_id][symbol] = target_id
+        end
+      end
+
+      #: (Set[LR1Item]) -> Array[Symbol]
+      def next_symbols_for(state)
+        state.map(&:next_symbol).compact.uniq
+      end
+
+      #: (Set[LR1Item], Symbol) -> Set[LR1Item]
+      def target_state_for(state, symbol)
+        advanced_items = state
+          .select { |item| item.next_symbol == symbol }
+          .map(&:advance)
+          .to_set
+
+        lr1_closure(advanced_items)
+      end
+
+      #: (Array[Set[LR1Item]], Hash[Array[Array[Integer | nil | Symbol]], Integer], Array[Integer], Set[LR1Item]) -> Integer
+      def register_state(states, known, worklist, target)
+        key = lr1_state_key(target)
+        target_id = known[key]
+        return target_id if target_id
+
+        target_id = states.length
+        states << target
+        known[key] = target_id
+        worklist << target_id
+        target_id
+      end
+
+      #: (Set[LR1Item], LR1Item, Symbol) -> bool
+      def add_closure_items(result, item, symbol)
+        lookaheads = closure_lookaheads_for(item)
+        changed = false
+
+        grammar.productions_for(symbol).each do |production|
+          lookaheads.each do |lookahead|
+            candidate = LR1Item.new(production, 0, lookahead)
+            next if result.include?(candidate)
+
+            result.add(candidate)
+            changed = true
+          end
+        end
+
+        changed
+      end
+
+      #: (LR1Item) -> Set[Symbol]
+      def closure_lookaheads_for(item)
+        beta = item.production.rhs[(item.dot + 1)..] || []
+        symbols = beta + [item.lookahead]
+
+        first_follow.first_of_sequence(symbols) - Set[FirstFollow::EMPTY]
+      end
+
+      #: (Array[Set[LR1Item]]) -> Hash[Array[Array[Integer?]], Array[Integer]]
+      def group_states_by_lr0_core(canonical_states)
+        canonical_states
+          .each_with_index
+          .with_object(grouped_state_index) do |(items, index), grouped_states|
+          grouped_states[lr0_core_key(items)] << index
+        end
+      end
+
+      #: () -> Hash[Array[Array[Integer?]], Array[Integer]]
+      def grouped_state_index
+        Hash.new do |hash, key|
+          hash[key] = [] #: Array[Integer]
+        end
+      end
+
+      #: (Array[Set[LR1Item]], Array[Integer], Hash[Integer, Integer], Integer) -> MergedState
+      def merge_state_group(canonical_states, canonical_indexes, merged_ids, merged_id)
+        merged_items = {} #: Hash[[Integer?, Integer], MergedItem]
+
+        canonical_indexes.each do |canonical_id|
+          merged_ids[canonical_id] = merged_id
+          merge_items_from_state(merged_items, canonical_states.fetch(canonical_id))
+        end
+
+        MergedState.new(merged_id, sorted_merged_items(merged_items))
+      end
+
+      #: (Hash[[Integer?, Integer], MergedItem], Set[LR1Item]) -> void
+      def merge_items_from_state(merged_items, items)
+        items.each do |item|
+          merged_items[item.core] ||= MergedItem.new(item.production, item.dot, Set.new)
+          merged_items[item.core].lookaheads.add(item.lookahead)
+        end
+      end
+
+      #: (Hash[[Integer?, Integer], MergedItem]) -> Array[MergedItem]
+      def sorted_merged_items(merged_items)
+        merged_items.values.sort_by { |item| [item.production.id, item.dot] }
+      end
+
+      #: (Hash[Integer, Hash[Symbol, Integer]], Hash[Integer, Integer]) -> void
+      def merge_transitions(canonical_transitions, merged_ids)
+        canonical_transitions.each do |from_id, edges|
+          edges.each do |symbol, to_id|
+            transitions[merged_ids.fetch(from_id)][symbol] = merged_ids.fetch(to_id)
+          end
+        end
+      end
+
+      #: () -> Hash[Integer?, Grammar::Production]
+      def index_productions_by_id
+        productions_by_id = {} #: Hash[Integer?, Grammar::Production]
+
+        grammar.productions.each_with_object(productions_by_id) do |production, indexed_productions|
+          indexed_productions[production.id] = production
+        end
+      end
+
+      #: (MergedState, Hash[Integer?, Grammar::Production]) -> void
+      def populate_actions_for(state, productions_by_id)
+        state.items.each do |item|
+          symbol = item.next_symbol
+          if symbol && grammar.terminal?(symbol)
+            add_shift_action(state.id, symbol, productions_by_id)
+            next
+          end
+
+          next unless item.reduce?
+
+          populate_reduce_actions(state.id, item, productions_by_id)
+        end
+      end
+
+      #: (Integer, Symbol, Hash[Integer?, Grammar::Production]) -> void
+      def add_shift_action(state_id, symbol, productions_by_id)
+        target_state = transitions.fetch(state_id).fetch(symbol)
+        add_action(state_id, symbol, Shift.new(target_state), productions_by_id)
+      end
+
+      #: (Integer, MergedItem, Hash[Integer?, Grammar::Production]) -> void
+      def populate_reduce_actions(state_id, item, productions_by_id)
+        if item.production.lhs == grammar.augmented_start
+          add_accept_action(state_id, productions_by_id)
+          return
+        end
+
+        item.lookaheads.each do |lookahead|
+          add_reduce_action(state_id, lookahead, item, productions_by_id)
+        end
+      end
+
+      #: (Integer, Hash[Integer?, Grammar::Production]) -> void
+      def add_accept_action(state_id, productions_by_id)
+        add_action(
+          state_id,
+          Grammar::Grammar::END_OF_INPUT,
+          Accept.new,
+          productions_by_id
+        )
+      end
+
+      #: (Integer, Symbol, MergedItem, Hash[Integer?, Grammar::Production]) -> void
+      def add_reduce_action(state_id, lookahead, item, productions_by_id)
+        add_action(
+          state_id,
+          lookahead,
+          Reduce.new(item.production.id),
+          productions_by_id
+        )
+      end
+
+      #: (MergedState) -> void
+      def populate_gotos_for(state)
+        transitions[state.id].each do |symbol, target_state|
+          next unless grammar.nonterminal?(symbol)
+
+          goto_table[state.id][symbol] = target_state
+        end
+      end
+
+      #: (ConflictReport) -> String
+      def conflict_message(conflict)
+        "state #{conflict.state_id}, " \
+          "lookahead #{conflict.lookahead}: #{conflict.message}"
+      end
+    end
+  end
+end