lrama 0.5.9 → 0.5.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5369d73367ea2fee299dbb73336a7801c98faa51bb3f68e66327c12f5a2d6716
-  data.tar.gz: b79943902e78f921d3361800cd1c371cebc594f527e940b83be3d26fcab190a9
+  metadata.gz: 634093bc73fd1504910364bffa6827a66fa7479f1f5b5238fdf577f0bb6d3d9d
+  data.tar.gz: 96db570d049f47f20bf619535ee91e7f0f846a492404a54f7fe41a6addcce484
 SHA512:
-  metadata.gz: 93fd0bb99180b74f7a98b1186273b9324ac8855f599add59a4eb86b7b38b7930975c32463568ae93ff5d829d7c605dbd8a264c8127e40d92f7f7b0bd46637b0a
-  data.tar.gz: 06a43beddb6b78b4a1866164c63ebff7309c134b74dc32b5272e181f88ba4b2ff2ea30d756a16016e194e6c0babf0e6ee1536984e90835798eaa57be8eb09c9f
+  metadata.gz: 6b09e84cd16cd162f263e68abf7ada808418212ca449fab0f4a380c42c0193f479cad3d0d1afcc1d5f17d81b890e3754642d1a9433f7be5f6fc71fdcb2df3f97
+  data.tar.gz: 1994a670f1033e737f2193e2e71ccaa0818e4144ac7f4424ebf24046ece23efc3f67eeb0927c5336663a244f270b321247b39dbbdbe76cfacc13b94da6289a8b

data/.github/workflows/test.yaml

@@ -20,6 +20,7 @@ jobs:
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler-cache: true
+      - run: flex --help
       - run: bundle install
       - run: bundle exec rspec
   test-windows:
@@ -34,8 +35,30 @@ jobs:
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler-cache: true
+      - run: choco install winflexbison || choco install winflexbison
+      - run: win_flex --help
       - run: bundle install
       - run: bundle exec rspec
+  test-memory:
+    runs-on: ubuntu-20.04
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ['head']
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - run: |
+          sudo apt-get update -q
+          sudo apt-get install --no-install-recommends -q -y valgrind
+      - run: valgrind --version
+      - run: bundle install
+      - run: bundle exec rspec spec/lrama/integration_spec.rb
+        env:
+          ENABEL_VALGRIND: 'true'
   check-misc:
     runs-on: ubuntu-20.04
     strategy:
@@ -65,6 +88,8 @@ jobs:
       fail-fast: false
       matrix:
         ruby: ['head']
+    env:
+      INSTALL_STEEP: 'true'
     steps:
       - uses: actions/checkout@v4
       - uses: ruby/setup-ruby@v1

data/.gitignore

@@ -1,7 +1,10 @@
+/.DS_Store
+/.bundle/
 /.gem_rbs_collection/
-/tmp
-.irbrc
+/.irbrc
 /Gemfile.lock
-/pkg/
-coverage/
+/coverage/
 /parser.output
+/pkg/
+/tmp/
+/vendor/bundle

data/Gemfile

@@ -2,12 +2,16 @@ source 'https://rubygems.org'
 
 gemspec
 
-gem "rspec"
 gem "pry"
-# stackprof doesn't support Windows
-gem "stackprof", platforms: [:ruby]
 gem "racc", "1.7.3"
 gem "rake"
-gem "rbs", require: false
-gem "steep", require: false
+gem "rspec"
 gem "simplecov", require: false
+gem "stackprof", platforms: [:ruby] # stackprof doesn't support Windows
+
+# Recent steep requires Ruby >= 3.0.0.
+# Then skip install on some CI jobs.
+if !ENV['GITHUB_ACTION'] || ENV['INSTALL_STEEP'] == 'true'
+  gem "rbs", "3.3.0", require: false
+  gem "steep", "1.6.0", require: false
+end

data/Rakefile

@@ -6,3 +6,16 @@ namespace "build" do
     sh "bundle exec racc parser.y --embedded -o lib/lrama/parser.rb -t --log-file=parser.output"
   end
 end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+task :spec => "build:parser"
+
+desc "steep check"
+task :steep do
+  sh "bundle exec steep check"
+end
+
+task default: %i[spec steep]

data/Steepfile

@@ -4,18 +4,20 @@ target :lib do
   repo_path '.gem_rbs_collection/'
   signature "sig"
 
+  check "lib/lrama/grammar/code/printer_code.rb"
+  check "lib/lrama/grammar/code.rb"
+  check "lib/lrama/grammar/counter.rb"
+  check "lib/lrama/grammar/error_token.rb"
+  check "lib/lrama/grammar/parameterizing_rules"
+  check "lib/lrama/grammar/percent_code.rb"
+  check "lib/lrama/grammar/precedence.rb"
+  check "lib/lrama/grammar/printer.rb"
+  check "lib/lrama/grammar/reference.rb"
+  check "lib/lrama/grammar/rule_builder.rb"
+  check "lib/lrama/grammar/symbol.rb"
+  check "lib/lrama/lexer"
+  check "lib/lrama/report"
   check "lib/lrama/bitmap.rb"
   check "lib/lrama/digraph.rb"
-  check "lib/lrama/grammar/percent_code.rb"
-  # TODO: Include this file once Lrama::Grammar::Symbol type is defined
-  # check "lib/lrama/grammar/reference.rb"
-  check "lib/lrama/lexer/token.rb"
-  check "lib/lrama/lexer/token/char.rb"
-  check "lib/lrama/lexer/token/ident.rb"
-  check "lib/lrama/lexer/token/parameterizing.rb"
-  check "lib/lrama/lexer/token/tag.rb"
-  check "lib/lrama/lexer/token/user_code.rb"
-  check "lib/lrama/report/duration.rb"
-  check "lib/lrama/report/profile.rb"
   check "lib/lrama/warning.rb"
 end

data/lib/lrama/context.rb

@@ -309,10 +309,8 @@ module Lrama
       # Index is sequence number of nterm, value is state id
       # of a default nterm transition destination.
       @yydefgoto = Array.new(@states.nterms.count, 0)
-      h = {}
       # Mapping from nterm to next_states
       nterm_to_next_states = {}
-      terms_count = @states.terms.count
 
       @states.states.each do |state|
         state.nterm_transitions.each do |shift, next_state|
@@ -369,7 +367,7 @@ module Lrama
         end
 
         j = @sorted_actions.count - 1
-        state_id, froms_and_tos, count, width = action
+        _state_id, _froms_and_tos, count, width = action
 
         while (j >= 0) do
           case

data/lib/lrama/counterexamples/path.rb

@@ -19,51 +19,5 @@ module Lrama
       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/production_path.rb

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

data/lib/lrama/counterexamples/start_path.rb

@@ -0,0 +1,21 @@
+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/lib/lrama/counterexamples/transition_path.rb

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

data/lib/lrama/counterexamples.rb

@@ -3,7 +3,10 @@ require "set"
 require "lrama/counterexamples/derivation"
 require "lrama/counterexamples/example"
 require "lrama/counterexamples/path"
+require "lrama/counterexamples/production_path"
+require "lrama/counterexamples/start_path"
 require "lrama/counterexamples/state_item"
+require "lrama/counterexamples/transition_path"
 require "lrama/counterexamples/triple"
 
 module Lrama

data/lib/lrama/grammar/code/initial_action_code.rb

@@ -0,0 +1,28 @@
+module Lrama
+  class Grammar
+    class Code
+      class InitialActionCode < Code
+        private
+
+        # * ($$) yylval
+        # * (@$) yylloc
+        # * ($1) error
+        # * (@1) error
+        def reference_to_c(ref)
+          case
+          when ref.type == :dollar && ref.name == "$" # $$
+            "yylval"
+          when ref.type == :at && ref.name == "$" # @$
+            "yylloc"
+          when ref.type == :dollar # $n
+            raise "$#{ref.value} can not be used in initial_action."
+          when ref.type == :at # @n
+            raise "@#{ref.value} can not be used in initial_action."
+          else
+            raise "Unexpected. #{self}, #{ref}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lrama/grammar/code/no_reference_code.rb

@@ -0,0 +1,24 @@
+module Lrama
+  class Grammar
+    class Code
+      class NoReferenceCode < Code
+        private
+
+        # * ($$) error
+        # * (@$) error
+        # * ($1) error
+        # * (@1) error
+        def reference_to_c(ref)
+          case
+          when ref.type == :dollar # $$, $n
+            raise "$#{ref.value} can not be used in #{type}."
+          when ref.type == :at # @$, @n
+            raise "@#{ref.value} can not be used in #{type}."
+          else
+            raise "Unexpected. #{self}, #{ref}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lrama/grammar/code/printer_code.rb

@@ -0,0 +1,34 @@
+module Lrama
+  class Grammar
+    class Code
+      class PrinterCode < Code
+        def initialize(type: nil, token_code: nil, tag: nil)
+          super(type: type, token_code: token_code)
+          @tag = tag
+        end
+
+        private
+
+        # * ($$) *yyvaluep
+        # * (@$) *yylocationp
+        # * ($1) error
+        # * (@1) error
+        def reference_to_c(ref)
+          case
+          when ref.type == :dollar && ref.name == "$" # $$
+            member = @tag.member
+            "((*yyvaluep).#{member})"
+          when ref.type == :at && ref.name == "$" # @$
+            "(*yylocationp)"
+          when ref.type == :dollar # $n
+            raise "$#{ref.value} can not be used in #{type}."
+          when ref.type == :at # @n
+            raise "@#{ref.value} can not be used in #{type}."
+          else
+            raise "Unexpected. #{self}, #{ref}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lrama/grammar/code/rule_action.rb

@@ -0,0 +1,62 @@
+module Lrama
+  class Grammar
+    class Code
+      class RuleAction < Code
+        def initialize(type: nil, token_code: nil, rule: nil)
+          super(type: type, token_code: token_code)
+          @rule = rule
+        end
+
+        private
+
+        # * ($$) yyval
+        # * (@$) yyloc
+        # * ($1) yyvsp[i]
+        # * (@1) yylsp[i]
+        #
+        # "Rule"                class: keyword_class { $1 } tSTRING { $2 + $3 } keyword_end { $class = $1 + $keyword_end }
+        # "Position in grammar"                   $1    $2      $3          $4          $5                             $6
+        # "Index for yyvsp"                       -4    -3      -2          -1           0
+        def reference_to_c(ref)
+          case
+          when ref.type == :dollar && ref.name == "$" # $$
+            tag = ref.ex_tag || lhs.tag
+            raise_tag_not_found_error(ref) unless tag
+            "(yyval.#{tag.member})"
+          when ref.type == :at && ref.name == "$" # @$
+            "(yyloc)"
+          when ref.type == :dollar # $n
+            i = -position_in_rhs + ref.index
+            tag = ref.ex_tag || rhs[ref.index - 1].tag
+            raise_tag_not_found_error(ref) unless tag
+            "(yyvsp[#{i}].#{tag.member})"
+          when ref.type == :at # @n
+            i = -position_in_rhs + ref.index
+            "(yylsp[#{i}])"
+          else
+            raise "Unexpected. #{self}, #{ref}"
+          end
+        end
+
+        def position_in_rhs
+          # If rule is not derived rule, User Code is only action at
+          # the end of rule RHS. In such case, the action is located on
+          # `@rule.rhs.count`.
+          @rule.position_in_original_rule_rhs || @rule.rhs.count
+        end
+
+        def rhs
+          (@rule.original_rule || @rule).rhs
+        end
+
+        def lhs
+          @rule.lhs
+        end
+
+        def raise_tag_not_found_error(ref)
+          raise "Tag is not specified for '$#{ref.value}' in '#{@rule.to_s}'"
+        end
+      end
+    end
+  end
+end

data/lib/lrama/grammar/code.rb

@@ -7,116 +7,32 @@ module Lrama
 
       def_delegators "token_code", :s_value, :line, :column, :references
 
-      # $$, $n, @$, @n is translated to C code
+      # $$, $n, @$, @n are translated to C code
       def translated_code
-        case type
-        when :user_code
-          translated_user_code
-        when :initial_action
-          translated_initial_action_code
-        end
-      end
-
-      # * ($1) error
-      # * ($$) *yyvaluep
-      # * (@1) error
-      # * (@$) *yylocationp
-      def translated_printer_code(tag)
         t_code = s_value.dup
 
         references.reverse.each do |ref|
           first_column = ref.first_column
           last_column = ref.last_column
 
-          case
-          when ref.value == "$" && ref.type == :dollar # $$
-            # Omit "<>"
-            member = tag.s_value[1..-2]
-            str = "((*yyvaluep).#{member})"
-          when ref.value == "$" && ref.type == :at # @$
-            str = "(*yylocationp)"
-          when ref.type == :dollar # $n
-            raise "$#{ref.value} can not be used in %printer."
-          when ref.type == :at # @n
-            raise "@#{ref.value} can not be used in %printer."
-          else
-            raise "Unexpected. #{self}, #{ref}"
-          end
+          str = reference_to_c(ref)
 
           t_code[first_column..last_column] = str
         end
 
         return t_code
       end
-      alias :translated_error_token_code :translated_printer_code
 
       private
 
-      # * ($1) yyvsp[i]
-      # * ($$) yyval
-      # * (@1) yylsp[i]
-      # * (@$) yyloc
-      def translated_user_code
-        t_code = s_value.dup
-
-        references.reverse.each do |ref|
-          first_column = ref.first_column
-          last_column = ref.last_column
-
-          case
-          when ref.value == "$" && ref.type == :dollar # $$
-            # Omit "<>"
-            member = ref.tag.s_value[1..-2]
-            str = "(yyval.#{member})"
-          when ref.value == "$" && ref.type == :at # @$
-            str = "(yyloc)"
-          when ref.type == :dollar # $n
-            i = -ref.position_in_rhs + ref.value
-            # Omit "<>"
-            member = ref.tag.s_value[1..-2]
-            str = "(yyvsp[#{i}].#{member})"
-          when ref.type == :at # @n
-            i = -ref.position_in_rhs + ref.value
-            str = "(yylsp[#{i}])"
-          else
-            raise "Unexpected. #{self}, #{ref}"
-          end
-
-          t_code[first_column..last_column] = str
-        end
-
-        return t_code
-      end
-
-      # * ($1) error
-      # * ($$) yylval
-      # * (@1) error
-      # * (@$) yylloc
-      def translated_initial_action_code
-        t_code = s_value.dup
-
-        references.reverse.each do |ref|
-          first_column = ref.first_column
-          last_column = ref.last_column
-
-          case
-          when ref.value == "$" && ref.type == :dollar # $$
-            str = "yylval"
-          when ref.value == "$" && ref.type == :at # @$
-            str = "yylloc"
-          when ref.type == :dollar # $n
-            raise "$#{ref.value} can not be used in initial_action."
-          when ref.type == :at # @n
-            raise "@#{ref.value} can not be used in initial_action."
-          else
-            raise "Unexpected. #{self}, #{ref}"
-          end
-
-          t_code[first_column..last_column] = str
-        end
-
-        return t_code
+      def reference_to_c(ref)
+        raise NotImplementedError.new("#reference_to_c is not implemented")
       end
     end
   end
 end
+
+require "lrama/grammar/code/initial_action_code"
+require "lrama/grammar/code/no_reference_code"
+require "lrama/grammar/code/printer_code"
+require "lrama/grammar/code/rule_action"

data/lib/lrama/grammar/counter.rb

@@ -0,0 +1,15 @@
+module Lrama
+  class Grammar
+    class Counter
+      def initialize(number)
+        @number = number
+      end
+
+      def increment
+        n = @number
+        @number += 1
+        n
+      end
+    end
+  end
+end

data/lib/lrama/grammar/error_token.rb

@@ -1,8 +1,8 @@
 module Lrama
   class Grammar
-    class ErrorToken < Struct.new(:ident_or_tags, :code, :lineno, keyword_init: true)
-      def translated_code(member)
-        code.translated_error_token_code(member)
+    class ErrorToken < Struct.new(:ident_or_tags, :token_code, :lineno, keyword_init: true)
+      def translated_code(tag)
+        Code::PrinterCode.new(type: :error_token, token_code: token_code, tag: tag).translated_code
       end
     end
   end

data/lib/lrama/grammar/parameterizing_rules/builder/base.rb

@@ -0,0 +1,36 @@
+module Lrama
+  class Grammar
+    class ParameterizingRules
+      class Builder
+        # Base class for parameterizing rules builder
+        class Base
+          attr_reader :build_token
+
+          def initialize(token, rule_counter, lhs_tag, user_code, precedence_sym, line)
+            @args = token.args
+            @token = @args.first
+            @rule_counter = rule_counter
+            @lhs_tag = lhs_tag
+            @user_code = user_code
+            @precedence_sym = precedence_sym
+            @line = line
+            @expected_argument_num = 1
+            @build_token = nil
+          end
+
+          def build
+            raise NotImplementedError
+          end
+
+          private
+
+          def validate_argument_number!
+            unless @args.count == @expected_argument_num
+              raise "Invalid number of arguments. expect: #{@expected_argument_num} actual: #{@args.count}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lrama/grammar/parameterizing_rules/builder/list.rb

@@ -0,0 +1,28 @@
+module Lrama
+  class Grammar
+    class ParameterizingRules
+      class Builder
+        # Builder for list of general parameterizing rules
+        class List < Base
+
+          # program: list(number)
+          #
+          # =>
+          #
+          # program: list_number
+          # list_number: ε
+          # list_number: list_number number
+          def build
+            validate_argument_number!
+
+            rules = []
+            @build_token = Lrama::Lexer::Token::Ident.new(s_value: "list_#{@token.s_value}")
+            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [], lhs_tag: @lhs_tag, token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [@build_token, @token], lhs_tag: @lhs_tag, token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules
+          end
+        end
+      end
+    end
+  end
+end