lrama 0.7.0 → 0.7.1

data/lib/lrama/report/duration.rb

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

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Lrama
-  class Report
-    module Profile
-      # See "Profiling Lrama" in README.md for how to use.
-      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,4 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'report/duration'
-require_relative 'report/profile'

data/lib/lrama/state/reduce.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Lrama
-  class State
-    class Reduce
-      # https://www.gnu.org/software/bison/manual/html_node/Default-Reductions.html
-      attr_reader :item, :look_ahead, :not_selected_symbols
-      attr_accessor :default_reduction
-
-      def initialize(item)
-        @item = item
-        @look_ahead = nil
-        @not_selected_symbols = []
-      end
-
-      def rule
-        @item.rule
-      end
-
-      def look_ahead=(look_ahead)
-        @look_ahead = look_ahead.freeze
-      end
-
-      def add_not_selected_symbol(sym)
-        @not_selected_symbols << sym
-      end
-
-      def selected_look_ahead
-        if look_ahead
-          look_ahead - @not_selected_symbols
-        else
-          []
-        end
-      end
-    end
-  end
-end

data/lib/lrama/state/shift.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Lrama
-  class State
-    class Shift
-      attr_reader :next_sym, :next_items
-      attr_accessor :not_selected
-
-      def initialize(next_sym, next_items)
-        @next_sym = next_sym
-        @next_items = next_items
-      end
-    end
-  end
-end

data/lib/lrama/states_reporter.rb

@@ -1,362 +0,0 @@
-# frozen_string_literal: true
-
-module Lrama
-  class StatesReporter
-    include Lrama::Report::Duration
-
-    def initialize(states)
-      @states = states
-    end
-
-    def report(io, **options)
-      report_duration(:report) do
-        _report(io, **options)
-      end
-    end
-
-    private
-
-    def _report(io, grammar: false, rules: false, terms: false, states: false, itemsets: false, lookaheads: false, solved: false, counterexamples: false, verbose: false)
-      report_unused_rules(io) if rules
-      report_unused_terms(io) if terms
-      report_conflicts(io)
-      report_grammar(io) if grammar
-      report_states(io, itemsets, lookaheads, solved, counterexamples, verbose)
-    end
-
-    def report_unused_terms(io)
-      look_aheads = @states.states.each do |state|
-        state.reduces.flat_map do |reduce|
-          reduce.look_ahead unless reduce.look_ahead.nil?
-        end
-      end
-
-      next_terms = @states.states.flat_map do |state|
-        state.shifts.map(&:next_sym).select(&:term?)
-      end
-
-      unused_symbols = @states.terms.select do |term|
-        !(look_aheads + next_terms).include?(term)
-      end
-
-      unless unused_symbols.empty?
-        io << "#{unused_symbols.count} Unused Terms\n\n"
-        unused_symbols.each_with_index do |term, index|
-          io << sprintf("%5d %s\n", index, term.id.s_value)
-        end
-        io << "\n\n"
-      end
-    end
-
-    def report_unused_rules(io)
-      used_rules = @states.rules.flat_map(&:rhs)
-
-      unused_rules = @states.rules.map(&:lhs).select do |rule|
-        !used_rules.include?(rule) && rule.token_id != 0
-      end
-
-      unless unused_rules.empty?
-        io << "#{unused_rules.count} Unused Rules\n\n"
-        unused_rules.each_with_index do |rule, index|
-          io << sprintf("%5d %s\n", index, rule.display_name)
-        end
-        io << "\n\n"
-      end
-    end
-
-    def report_conflicts(io)
-      has_conflict = false
-
-      @states.states.each do |state|
-        messages = []
-        cs = state.conflicts.group_by(&:type)
-        if cs[:shift_reduce]
-          messages << "#{cs[:shift_reduce].count} shift/reduce"
-        end
-
-        if cs[:reduce_reduce]
-          messages << "#{cs[:reduce_reduce].count} reduce/reduce"
-        end
-
-        unless messages.empty?
-          has_conflict = true
-          io << "State #{state.id} conflicts: #{messages.join(', ')}\n"
-        end
-      end
-
-      if has_conflict
-        io << "\n\n"
-      end
-    end
-
-    def report_grammar(io)
-      io << "Grammar\n"
-      last_lhs = nil
-
-      @states.rules.each do |rule|
-        if rule.empty_rule?
-          r = "ε"
-        else
-          r = rule.rhs.map(&:display_name).join(" ")
-        end
-
-        if rule.lhs == last_lhs
-          io << sprintf("%5d %s| %s\n", rule.id, " " * rule.lhs.display_name.length, r)
-        else
-          io << "\n"
-          io << sprintf("%5d %s: %s\n", rule.id, rule.lhs.display_name, r)
-        end
-
-        last_lhs = rule.lhs
-      end
-      io << "\n\n"
-    end
-
-    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"
-
-        # Report item
-        last_lhs = nil
-        list = itemsets ? state.items : state.kernels
-        list.sort_by {|i| [i.rule_id, i.position] }.each do |item|
-          if item.empty_rule?
-            r = "ε •"
-          else
-            r = item.rhs.map(&:display_name).insert(item.position, "•").join(" ")
-          end
-          if item.lhs == last_lhs
-            l = " " * item.lhs.id.s_value.length + "|"
-          else
-            l = item.lhs.id.s_value + ":"
-          end
-          la = ""
-          if lookaheads && item.end_of_rule?
-            reduce = state.find_reduce_by_item!(item)
-            look_ahead = reduce.selected_look_ahead
-            unless look_ahead.empty?
-              la = "  [#{look_ahead.map(&:display_name).join(", ")}]"
-            end
-          end
-          last_lhs = item.lhs
-
-          io << sprintf("%5i %s %s%s\n", item.rule_id, l, r, la)
-        end
-        io << "\n"
-
-        # Report shifts
-        tmp = state.term_transitions.reject do |shift, _|
-          shift.not_selected
-        end.map do |shift, next_state|
-          [shift.next_sym, next_state.id]
-        end
-        max_len = tmp.map(&:first).map(&:display_name).map(&:length).max
-        tmp.each do |term, state_id|
-          io << "    #{term.display_name.ljust(max_len)}  shift, and go to state #{state_id}\n"
-        end
-        io << "\n" unless tmp.empty?
-
-        # Report error caused by %nonassoc
-        nl = false
-        tmp = state.resolved_conflicts.select do |resolved|
-          resolved.which == :error
-        end.map do |error|
-          error.symbol.display_name
-        end
-        max_len = tmp.map(&:length).max
-        tmp.each do |name|
-          nl = true
-          io << "    #{name.ljust(max_len)}  error (nonassociative)\n"
-        end
-        io << "\n" unless tmp.empty?
-
-        # Report reduces
-        nl = false
-        max_len = state.non_default_reduces.flat_map(&:look_ahead).compact.map(&:display_name).map(&:length).max || 0
-        max_len = [max_len, "$default".length].max if state.default_reduction_rule
-        ary = []
-
-        state.non_default_reduces.each do |reduce|
-          reduce.look_ahead.each do |term|
-            ary << [term, reduce]
-          end
-        end
-
-        ary.sort_by do |term, reduce|
-          term.number
-        end.each do |term, reduce|
-          rule = reduce.item.rule
-          io << "    #{term.display_name.ljust(max_len)}  reduce using rule #{rule.id} (#{rule.lhs.display_name})\n"
-          nl = true
-        end
-
-        if (r = state.default_reduction_rule)
-          nl = true
-          s = "$default".ljust(max_len)
-
-          if r.initial_rule?
-            io << "    #{s}  accept\n"
-          else
-            io << "    #{s}  reduce using rule #{r.id} (#{r.lhs.display_name})\n"
-          end
-        end
-        io << "\n" if nl
-
-        # Report nonterminal transitions
-        tmp = []
-        max_len = 0
-        state.nterm_transitions.each do |shift, next_state|
-          nterm = shift.next_sym
-          tmp << [nterm, next_state.id]
-          max_len = [max_len, nterm.id.s_value.length].max
-        end
-        tmp.uniq!
-        tmp.sort_by! do |nterm, state_id|
-          nterm.number
-        end
-        tmp.each do |nterm, state_id|
-          io << "    #{nterm.id.s_value.ljust(max_len)}  go to state #{state_id}\n"
-        end
-        io << "\n" unless tmp.empty?
-
-        if solved
-          # Report conflict resolutions
-          state.resolved_conflicts.each do |resolved|
-            io << "    #{resolved.report_message}\n"
-          end
-          io << "\n" unless 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}\n"
-            io << "        #{example.path2_item}\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
-          io << "  [Direct Read sets]\n"
-          direct_read_sets = @states.direct_read_sets
-          @states.nterms.each do |nterm|
-            terms = direct_read_sets[[state.id, nterm.token_id]]
-            next unless terms
-            next if terms.empty?
-
-            str = terms.map {|sym| sym.id.s_value }.join(", ")
-            io << "    read #{nterm.id.s_value}  shift #{str}\n"
-          end
-          io << "\n"
-
-          # Report reads_relation
-          io << "  [Reads Relation]\n"
-          @states.nterms.each do |nterm|
-            a = @states.reads_relation[[state.id, nterm.token_id]]
-            next unless a
-
-            a.each do |state_id2, nterm_id2|
-              n = @states.nterms.find {|n| n.token_id == nterm_id2 }
-              io << "    (State #{state_id2}, #{n.id.s_value})\n"
-            end
-          end
-          io << "\n"
-
-          # Report read_sets
-          io << "  [Read sets]\n"
-          read_sets = @states.read_sets
-          @states.nterms.each do |nterm|
-            terms = read_sets[[state.id, nterm.token_id]]
-            next unless terms
-            next if terms.empty?
-
-            terms.each do |sym|
-              io << "    #{sym.id.s_value}\n"
-            end
-          end
-          io << "\n"
-
-          # Report includes_relation
-          io << "  [Includes Relation]\n"
-          @states.nterms.each do |nterm|
-            a = @states.includes_relation[[state.id, nterm.token_id]]
-            next unless a
-
-            a.each do |state_id2, nterm_id2|
-              n = @states.nterms.find {|n| n.token_id == nterm_id2 }
-              io << "    (State #{state.id}, #{nterm.id.s_value}) -> (State #{state_id2}, #{n.id.s_value})\n"
-            end
-          end
-          io << "\n"
-
-          # Report lookback_relation
-          io << "  [Lookback Relation]\n"
-          @states.rules.each do |rule|
-            a = @states.lookback_relation[[state.id, rule.id]]
-            next unless a
-
-            a.each do |state_id2, nterm_id2|
-              n = @states.nterms.find {|n| n.token_id == nterm_id2 }
-              io << "    (Rule: #{rule.display_name}) -> (State #{state_id2}, #{n.id.s_value})\n"
-            end
-          end
-          io << "\n"
-
-          # Report follow_sets
-          io << "  [Follow sets]\n"
-          follow_sets = @states.follow_sets
-          @states.nterms.each do |nterm|
-            terms = follow_sets[[state.id, nterm.token_id]]
-
-            next unless terms
-
-            terms.each do |sym|
-              io << "    #{nterm.id.s_value} -> #{sym.id.s_value}\n"
-            end
-          end
-          io << "\n"
-
-          # Report LA
-          io << "  [Look-Ahead Sets]\n"
-          tmp = []
-          max_len = 0
-          @states.rules.each do |rule|
-            syms = @states.la[[state.id, rule.id]]
-            next unless syms
-
-            tmp << [rule, syms]
-            max_len = ([max_len] + syms.map {|s| s.id.s_value.length }).max
-          end
-          tmp.each do |rule, syms|
-            syms.each do |sym|
-              io << "    #{sym.id.s_value.ljust(max_len)}  reduce using rule #{rule.id} (#{rule.lhs.id.s_value})\n"
-            end
-          end
-          io << "\n" unless tmp.empty?
-        end
-
-        # End of Report State
-        io << "\n"
-      end
-    end
-  end
-end

data/lib/lrama/trace_reporter.rb

@@ -1,45 +0,0 @@
-# rbs_inline: enabled
-# frozen_string_literal: true
-
-module Lrama
-  class TraceReporter
-    # @rbs (Lrama::Grammar grammar) -> void
-    def initialize(grammar)
-      @grammar = grammar
-    end
-
-    # @rbs (**Hash[Symbol, bool] options) -> void
-    def report(**options)
-      _report(**options)
-    end
-
-    private
-
-    # @rbs rules: (bool rules, bool actions, bool only_explicit_rules, **untyped _) -> void
-    def _report(rules: false, actions: false, only_explicit_rules: false, **_)
-      report_rules if rules && !only_explicit_rules
-      report_only_explicit_rules if only_explicit_rules
-      report_actions if actions
-    end
-
-    # @rbs () -> void
-    def report_rules
-      puts "Grammar rules:"
-      @grammar.rules.each { |rule| puts rule.display_name }
-    end
-
-    # @rbs () -> void
-    def report_only_explicit_rules
-      puts "Grammar rules:"
-      @grammar.rules.each do |rule|
-        puts rule.display_name_without_action if rule.lhs.first_set.any?
-      end
-    end
-
-    # @rbs () -> void
-    def report_actions
-      puts "Grammar rules with actions:"
-      @grammar.rules.each { |rule| puts rule.with_actions }
-    end
-  end
-end

data/sig/generated/lrama/trace_reporter.rbs

@@ -1,25 +0,0 @@
-# Generated from lib/lrama/trace_reporter.rb with RBS::Inline
-
-module Lrama
-  class TraceReporter
-    # @rbs (Lrama::Grammar grammar) -> void
-    def initialize: (Lrama::Grammar grammar) -> void
-
-    # @rbs (**Hash[Symbol, bool] options) -> void
-    def report: (**Hash[Symbol, bool] options) -> void
-
-    private
-
-    # @rbs rules: (bool rules, bool actions, bool only_explicit_rules, **untyped _) -> void
-    def _report: (?rules: untyped, ?actions: untyped, ?only_explicit_rules: untyped, **untyped _) -> untyped
-
-    # @rbs () -> void
-    def report_rules: () -> void
-
-    # @rbs () -> void
-    def report_only_explicit_rules: () -> void
-
-    # @rbs () -> void
-    def report_actions: () -> void
-  end
-end

data/sig/lrama/counterexamples/derivation.rbs

@@ -1,33 +0,0 @@
-module Lrama
-  class Counterexamples
-    class Derivation
-      @item: States::Item
-
-      @left: Derivation?
-
-      @right: Derivation?
-
-      attr_reader item: States::Item
-
-      attr_reader left: Derivation?
-
-      attr_reader right: Derivation?
-
-      attr_writer right: Derivation?
-
-      def initialize: (States::Item item, Derivation? left, ?Derivation? right) -> void
-
-      def to_s: () -> ::String
-
-      alias inspect to_s
-
-      def render_strings_for_report: () -> Array[String]
-
-      def render_for_report: () -> String
-
-      private
-
-      def _render_for_report: (Derivation derivation, Integer offset, Array[String] strings, Integer index) -> Integer
-    end
-  end
-end

data/sig/lrama/counterexamples/example.rbs

@@ -1,45 +0,0 @@
-module Lrama
-  class Counterexamples
-    class Example
-      @path1: ::Array[StartPath | TransitionPath | ProductionPath]
-
-      @path2: ::Array[StartPath | TransitionPath | ProductionPath]
-
-      @conflict: (State::ShiftReduceConflict | State::ReduceReduceConflict)
-
-      @conflict_symbol: Grammar::Symbol
-
-      @counterexamples: Counterexamples
-
-      @derivations1: Derivation
-
-      @derivations2: Derivation
-
-      attr_reader path1: ::Array[StartPath | TransitionPath | ProductionPath]
-
-      attr_reader path2: ::Array[StartPath | TransitionPath | ProductionPath]
-
-      attr_reader conflict: (State::ShiftReduceConflict | State::ReduceReduceConflict)
-
-      attr_reader conflict_symbol: Grammar::Symbol
-
-      def initialize: (::Array[StartPath | TransitionPath | ProductionPath]? path1, ::Array[StartPath | TransitionPath | ProductionPath]? path2, (State::ShiftReduceConflict | State::ReduceReduceConflict) conflict, Grammar::Symbol conflict_symbol, Counterexamples counterexamples) -> void
-
-      def type: () -> (:shift_reduce | :reduce_reduce)
-
-      def path1_item: () -> States::Item
-
-      def path2_item: () -> States::Item
-
-      def derivations1: () -> Derivation
-
-      def derivations2: () -> Derivation
-
-      private
-
-      def _derivations: (::Array[StartPath | TransitionPath | ProductionPath] paths) -> Derivation
-
-      def find_derivation_for_symbol: (StateItem state_item, Grammar::Symbol sym) -> Derivation?
-    end
-  end
-end

data/sig/lrama/counterexamples/path.rbs

@@ -1,21 +0,0 @@
-module Lrama
-  class Counterexamples
-    class Path
-      @from_state_item: StateItem?
-
-      @to_state_item: StateItem
-
-      def initialize: (StateItem? from_state_item, StateItem to_state_item) -> void
-
-      def from: () -> StateItem?
-
-      def to: () -> StateItem
-
-      def to_s: () -> ::String
-
-      alias inspect to_s
-
-      def type: -> bot
-    end
-  end
-end

data/sig/lrama/counterexamples/production_path.rbs

@@ -1,11 +0,0 @@
-module Lrama
-  class Counterexamples
-    class ProductionPath < Path
-      def type: () -> :production
-
-      def transition?: () -> false
-
-      def production?: () -> true
-    end
-  end
-end

data/sig/lrama/counterexamples/start_path.rbs

@@ -1,13 +0,0 @@
-module Lrama
-  class Counterexamples
-    class StartPath < Path
-      def initialize: (StateItem to_state_item) -> void
-
-      def type: () -> :start
-
-      def transition?: () -> false
-
-      def production?: () -> false
-    end
-  end
-end

data/sig/lrama/counterexamples/state_item.rbs

@@ -1,10 +0,0 @@
-module Lrama
-  class Counterexamples
-    class StateItem
-     attr_accessor state: State
-     attr_accessor item: States::Item
-
-      def initialize: (State state, States::Item item) -> void
-    end
-  end
-end

data/sig/lrama/counterexamples/transition_path.rbs

@@ -1,11 +0,0 @@
-module Lrama
-  class Counterexamples
-    class TransitionPath < Path
-      def type: () -> :transition
-
-      def transition?: () -> true
-
-      def production?: () -> false
-    end
-  end
-end