lrama 0.5.3 → 0.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32eaf486545ca4143a227a34cee2bfdb94928e002a85fcb2e098dba3dedb71c7
-  data.tar.gz: b80a7402d9f6caf9f0e8b5396e4bd6b80d84487a35c8cd4b4d711e51ffb56601
+  metadata.gz: d79363afacc07dac12ab5c1a861123e099626591104079c962e02f3df74a24f3
+  data.tar.gz: d8ddf78087e27510ab9da808301505a10ec0151ef55d1df3a59cc80ffde81b53
 SHA512:
-  metadata.gz: 1d118074af8984d85e27485a0c9fb2f8c7eab9a55b771ea3eff17e26d84fe56316404f6316ba5a9c83e61591c83ff9048c6625a904529aa686417f6f295499d9
-  data.tar.gz: e3591cc5f70e6fe8a04af5070a7b5d6ee60e98718c4c6dc6db1fbef2b3be9f5239155da91bb51ba10611b5017925f1bf71aa1259fd5550b5af6d0ba458e2ab96
+  metadata.gz: acc15bb56862ea03c6b195253ba881786acf498719f930b8a8435a60f86b44d4383778cc215e7497971833c4be596a9c41a6c5134f77703a9f5cd0a6b5714ad2
+  data.tar.gz: d45b2ec3a22ce2e29beb6a5ec0f4d7b142cebca3b6ca76786fa19b841c257d3841d5a7a43d7d564459b8f9c5b05faa7229bd9b2e2178592ec3988b64f77b535c

data/.github/workflows/test.yaml

@@ -22,6 +22,29 @@ jobs:
           bundler-cache: true
       - run: bundle install
       - run: bundle exec rspec
+  test-windows:
+    runs-on: windows-2022
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ['head']
+    steps:
+      - uses: actions/checkout@v3
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - run: bundle install
+      - run: bundle exec rspec
+  check-misc:
+    runs-on: ubuntu-20.04
+    steps:
+      - uses: actions/checkout@v3
+      # Copy from https://github.com/ruby/ruby/blob/089227e94823542acfdafa68541d330eee42ffea/.github/workflows/check_misc.yml#L27
+      - name: Check for trailing spaces
+        run: |
+          git grep -I -n '[	 ]$' -- '*.rb' '*.[chy]' '*.rs' && exit 1 || :
+          git grep -n '^[	 ][	 ]*$' -- '*.md' && exit 1 || :
   steep-check:
     runs-on: ubuntu-20.04
     strategy:
@@ -58,7 +81,7 @@ jobs:
       - run: mkdir -p tool/lrama
         working-directory: ../ruby
       - name: Copy Lrama to ruby/tool
-        run: cp -r exe lib template ../ruby/tool/lrama
+        run: cp -r LEGAL.md MIT exe lib template ../ruby/tool/lrama
         working-directory:
       - run: tree tool/lrama
         working-directory: ../ruby

data/Gemfile

@@ -4,8 +4,9 @@ gemspec
 
 gem "rspec"
 gem "pry"
-gem "stackprof"
+# stackprof doesn't support Windows
+gem "stackprof", platforms: [:ruby]
 gem "rake"
 gem "rbs", require: false
 gem "steep", require: false
-gem "simplecov", require: false
+gem "simplecov", require: false

data/README.md

@@ -49,10 +49,20 @@ Enter the formula:
 
 ## Versions and Branches
 
+### v0_5 (`master` branch)
+
+This branch is for Ruby 3.3. `lrama_0_5` branch is created from this branch, once Ruby 3.3 is released.
+
 ### v0_4 (`lrama_0_4` branch)
 
 This branch generates "parse.c" compatible with Bison 3.8.2 for ruby 3.0, 3.1, 3.2. The first version migrated to ruby is ["0.4.0"](https://github.com/ruby/ruby/pull/7798) therefore keep this branch for Bison compatible branch.
 
+## Supported Ruby version
+
+Lrama is executed with BASERUBY when building ruby from source code. Therefore Lrama needs to support BASERUBY, currently 2.5, or later version.
+
+This also requires Lrama to be able to run with only default gems and bundled gems.
+
 ## Build Ruby
 
 1. Install Lrama
@@ -62,7 +72,7 @@ This branch generates "parse.c" compatible with Bison 3.8.2 for ruby 3.0, 3.1, 3
 
 1. Update `Lrama::VERSION`
 2. Release as a gem by `rake release`
-3. Update Lrama in ruby/ruby by `cp -r LEGAL.md MIT exe lib ruby/tool/lrama`
+3. Update Lrama in ruby/ruby by `cp -r LEGAL.md MIT exe lib template ruby/tool/lrama`
 4. Create new release on [GitHub](https://github.com/ruby/lrama/releases)
 
 ## License

data/doc/TODO.md

@@ -44,10 +44,14 @@
 * Reporting
   * [ ] Bison style
     * [ ] Wrap not selected reduce with "[]". See basic.output file generated by Bison.
+* Counterexamples
+  * [x] Nonunifying Counterexamples
+  * [ ] Unifying Counterexamples
+  * [ ] Performance improvement using reverse_transitions and reverse_productions
 * Error Tolerance
   * [x] Corchuelo et al. algorithm with N = 1 (this means the next token when error is raised)
   * [x] Add new decl for error token semantic value initialization (%error-token)
-  * [ ] Use YYMALLOC & YYFREE
+  * [x] Use YYMALLOC & YYFREE
 * Lex state
 * CI
   * [x] Setup CI

data/exe/lrama

@@ -1,6 +1,5 @@
 #!/usr/bin/env ruby
 
-
 $LOAD_PATH << File.join(__dir__, "../lib")
 require "lrama"
 

data/lib/lrama/command.rb

@@ -5,7 +5,6 @@ module Lrama
     def initialize(argv)
       @argv = argv
 
-      @version = nil
       @skeleton = "bison/yacc.c"
       @header = false
       @header_file = nil
@@ -23,15 +22,11 @@ module Lrama
     def run
       parse_option
 
-      if @version
-        puts Lrama::VERSION
-        exit 0
-      end
-
       Report::Duration.enable if @trace_opts[:time]
 
       warning = Lrama::Warning.new
       grammar = Lrama::Parser.new(@y.read).parse
+      @y.close if @y != STDIN
       states = Lrama::States.new(grammar, warning, trace_state: (@trace_opts[:automaton] || @trace_opts[:closure]))
       states.compute
       context = Lrama::Context.new(states)
@@ -67,7 +62,7 @@ module Lrama
       bison_list = %w[states itemsets lookaheads solved counterexamples cex all none]
       others = %w[verbose]
       list = bison_list + others
-      not_supported = %w[counterexamples cex none]
+      not_supported = %w[cex none]
       h = { grammar: true }
 
       report.each do |r|
@@ -112,7 +107,7 @@ module Lrama
       opt = OptionParser.new
 
       # opt.on('-h') {|v| p v }
-      opt.on('-V', '--version') {|v| @version = true }
+      opt.on('-V', '--version') {|v| puts "lrama #{Lrama::VERSION}"; exit 0 }
 
       # Tuning the Parser
       opt.on('-S', '--skeleton=FILE') {|v| @skeleton = v }
@@ -121,13 +116,13 @@ module Lrama
       # Output Files:
       opt.on('-h', '--header=[FILE]') {|v| @header = true; @header_file = v }
       opt.on('-d') { @header = true }
-      opt.on('-r', '--report=THINGS') {|v| @report = v.split(',') }
+      opt.on('-r', '--report=THINGS', Array) {|v| @report = v }
       opt.on('--report-file=FILE')    {|v| @report_file = v }
       opt.on('-v') {  } # Do nothing
       opt.on('-o', '--output=FILE')   {|v| @outfile = v }
 
       # Hidden
-      opt.on('--trace=THINGS') {|v| @trace = v.split(',') }
+      opt.on('--trace=THINGS', Array) {|v| @trace = v }
 
       # Error Recovery
       opt.on('-e') {|v| @error_recovery = true }

data/lib/lrama/context.rb

@@ -401,7 +401,6 @@ module Lrama
       end
       print sprintf("]\n\n")
 
-
       print sprintf("width [\n")
       vectors_count.times do |i|
         print sprintf("%d, ", ary[i] ? ary[i][3] : 0)
@@ -409,7 +408,6 @@ module Lrama
       end
       print sprintf("]\n\n")
 
-
       print sprintf("tally [\n")
       vectors_count.times do |i|
         print sprintf("%d, ", ary[i] ? ary[i][2] : 0)

data/lib/lrama/counterexamples/derivation.rb

@@ -0,0 +1,63 @@
+module Lrama
+  class Counterexamples
+    class Derivation
+      attr_reader :item, :left, :right
+      attr_writer :right
+
+      def initialize(item, left, right = nil)
+        @item = item
+        @left = left
+        @right = right
+      end
+
+      def to_s
+        "#<Derivation(#{item.display_name})>"
+      end
+      alias :inspect :to_s
+
+      def render_strings_for_report
+        result = []
+        _render_for_report(self, 0, result, 0)
+        result.map(&:rstrip)
+      end
+
+      def render_for_report
+        render_strings_for_report.join("\n")
+      end
+
+      private
+
+      def _render_for_report(derivation, offset, strings, index)
+        item = derivation.item
+        if strings[index]
+          strings[index] << " " * (offset - strings[index].length)
+        else
+          strings[index] = " " * offset
+        end
+        str = strings[index]
+        str << "#{item.rule_id}: #{item.symbols_before_dot.map(&:display_name).join(" ")} "
+
+        if derivation.left
+          len = str.length
+          str << "#{item.next_sym.display_name}"
+          length = _render_for_report(derivation.left, len, strings, index + 1)
+          # I want String#ljust!
+          str << " " * (length - str.length)
+        else
+          str << " • #{item.symbols_after_dot.map(&:display_name).join(" ")} "
+          return str.length
+        end
+
+        if derivation.right&.left
+          length = _render_for_report(derivation.right.left, str.length, strings, index + 1)
+          str << "#{item.symbols_after_dot[1..-1].map(&:display_name).join(" ")} "
+          str << " " * (length - str.length) if length > str.length
+        elsif item.next_next_sym
+          str << "#{item.symbols_after_dot[1..-1].map(&:display_name).join(" ")} "
+        end
+
+        return str.length
+      end
+    end
+  end
+end

data/lib/lrama/counterexamples/example.rb

@@ -0,0 +1,124 @@
+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
+        current = :production
+        lookahead_sym = paths.last.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
+            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
+              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 = []
+        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/lib/lrama/counterexamples/path.rb

@@ -0,0 +1,69 @@
+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
+    end
+
+    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
+
+    class TransitionPath < Path
+      def type
+        :transition
+      end
+
+      def transition?
+        true
+      end
+
+      def production?
+        false
+      end
+    end
+
+    class ProductionPath < Path
+      def type
+        :production
+      end
+
+      def transition?
+        false
+      end
+
+      def production?
+        true
+      end
+    end
+  end
+end

data/lib/lrama/counterexamples/state_item.rb

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

data/lib/lrama/counterexamples/triple.rb

@@ -0,0 +1,21 @@
+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