lrama 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b1a3e3181fc7060235e167ea97a92809b31aa5b74ef5978ab70415252bb87e3
-  data.tar.gz: 51a6ee0620321936fcd9d81c44ece3f9e444b977dc8fa940ddf920a5bb3b1dad
+  metadata.gz: 50dc10cc2d790e778dcb6a35b789f146e69157b3c99d5b66059d95c025546ea6
+  data.tar.gz: cbc16ede0db21b5d22f74c47dfd7a87af2ae20e15f72afc9ea8a79980531861d
 SHA512:
-  metadata.gz: f2b8805ad79cc0c3f125eba2715d274387191e6a355910d11c88f918eae4906b9398444162210c7ce955b1ba3f67cabf3b0679569a65d63bdc52328f2d7dc2f7
-  data.tar.gz: 93de8cc0c7f9154f37825d59010a4850cc81b8a66f460d70f95aed44c0eb1224e583d1afb95155be2d9ae063d286a4fa719c133c993c6ec9bfba1c490dfc997b
+  metadata.gz: 7567e78e28cb912eb6dae8182827b5c6555924757bffe4fd9db81f79dd117aaf00f0918c90ead79d3567eeee802b90556540141fd5d4083bf5d6013c075cb20c
+  data.tar.gz: e58f803bc04114bdeb69b74a5e34ab9649241dafb9fe69a62f7d17ea87026411e3f743c54537fa092a9d6cea547a046fc762a78d9daebf92c3184be5502a24c1

data/.github/workflows/test.yaml

@@ -8,12 +8,19 @@ permissions:
   contents: read
 
 jobs:
+  ruby-versions:
+    uses: ruby/actions/.github/workflows/ruby_versions.yml@master
+    with:
+      engine: cruby
+      min_version: 2.5
+
   test:
+    needs: ruby-versions
     runs-on: ubuntu-20.04
     strategy:
       fail-fast: false
       matrix:
-        ruby: ['head', '3.3', '3.2', '3.1', '3.0', '2.7', '2.6', '2.5']
+        ruby: ${{ fromJson(needs.ruby-versions.outputs.versions) }}
     steps:
       - uses: actions/checkout@v4
       - uses: ruby/setup-ruby@v1
@@ -29,14 +36,22 @@ jobs:
       fail-fast: false
       matrix:
         ruby: ['head']
+    defaults:
+      run:
+        shell: msys2 {0}
     steps:
       - uses: actions/checkout@v4
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler-cache: true
-      - run: choco install winflexbison || choco install winflexbison
-      - run: win_flex --help
+      - uses: msys2/setup-msys2@v2
+        id: setup-msys2
+        with:
+          update: true
+          install: >-
+            flex
+      - run: flex --help
       - run: bundle install
       - run: bundle exec rspec
   test-memory:
@@ -118,12 +133,12 @@ jobs:
           ruby-version: ${{ matrix.baseruby }}
           bundler-cache: true
       - run: git clone --depth=1 https://github.com/ruby/ruby.git -b ${{ matrix.ruby_branch }} ../ruby
-        working-directory:
+        working-directory: .
       - run: mkdir -p tool/lrama
         working-directory: ../ruby
       - name: Copy Lrama to ruby/tool
         run: cp -r LEGAL.md NEWS.md MIT exe lib template ../ruby/tool/lrama
-        working-directory:
+        working-directory: .
       - run: tree tool/lrama
         working-directory: ../ruby
       # See also https://github.com/ruby/ruby/blob/master/.github/workflows/ubuntu.yml

data/Gemfile

@@ -12,6 +12,6 @@ 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.4.0", require: false
+  gem "rbs", "3.4.1", require: false
   gem "steep", "1.6.0", require: false
 end

data/NEWS.md

@@ -1,5 +1,49 @@
 # NEWS for Lrama
 
+## Lrama 0.6.1 (2024-01-13)
+
+### Nested parameterizing rules
+
+Allow to pass an instantiated rule to other parameterizing rules.
+
+```
+%rule constant(X) : X
+              ;
+
+%rule option(Y) : /* empty */
+                | Y
+                ;
+
+%%
+
+program         : option(constant(number)) // Nested rule
+                ;
+%%
+```
+
+Allow to use nested parameterizing rules when define parameterizing rules.
+
+```
+%rule option(x) : /* empty */
+                | X
+                ;
+
+%rule double(Y) : Y Y
+                ;
+
+%rule double_opt(A) : option(double(A)) // Nested rule
+                    ;
+
+%%
+
+program         : double_opt(number)
+                ;
+
+%%
+```
+
+https://github.com/ruby/lrama/pull/337
+
 ## Lrama 0.6.0 (2023-12-25)
 
 ### User defined parameterizing rules
@@ -20,6 +64,8 @@ stmt: pair(ODD, EVEN) <num>
     ;
 ```
 
+https://github.com/ruby/lrama/pull/285
+
 ## Lrama 0.5.11 (2023-12-02)
 
 ### Type specification of parameterizing rules

data/Steepfile

@@ -4,13 +4,12 @@ target :lib do
   repo_path '.gem_rbs_collection/'
   signature "sig"
 
+  check "lib/lrama/grammar/binding.rb"
   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_rule_builder.rb"
-  check "lib/lrama/grammar/parameterizing_rule_resolver.rb"
-  check "lib/lrama/grammar/parameterizing_rule_rhs_builder.rb"
+  check "lib/lrama/grammar/parameterizing_rule"
   check "lib/lrama/grammar/parameterizing_rules"
   check "lib/lrama/grammar/percent_code.rb"
   check "lib/lrama/grammar/precedence.rb"

data/lib/lrama/command.rb

@@ -1,14 +1,28 @@
 module Lrama
   class Command
     def run(argv)
-      options = OptionParser.new.parse(argv)
+      begin
+        options = OptionParser.new.parse(argv)
+      rescue => e
+        message = e.message
+        message = message.gsub(/.+/, "\e[1m\\&\e[m") if Exception.to_tty?
+        abort message
+      end
 
       Report::Duration.enable if options.trace_opts[:time]
 
       warning = Lrama::Warning.new
       text = options.y.read
       options.y.close if options.y != STDIN
-      grammar = Lrama::Parser.new(text, options.grammar_file, options.debug).parse
+      parser = Lrama::Parser.new(text, options.grammar_file, options.debug)
+      begin
+        grammar = parser.parse
+      rescue => e
+        raise e if options.debug
+        message = e.message
+        message = message.gsub(/.+/, "\e[1m\\&\e[m") if Exception.to_tty?
+        abort message
+      end
       states = Lrama::States.new(grammar, warning, trace_state: (options.trace_opts[:automaton] || options.trace_opts[:closure]))
       states.compute
       context = Lrama::Context.new(states)
@@ -39,7 +53,7 @@ module Lrama
       end
 
       if warning.has_error?
-        exit 1
+        exit false
       end
     end
   end

data/lib/lrama/context.rb

@@ -9,7 +9,7 @@ module Lrama
     BaseMin = -Float::INFINITY
 
     # TODO: It might be better to pass `states` to Output directly?
-    attr_reader :states
+    attr_reader :states, :yylast, :yypact_ninf, :yytable_ninf, :yydefact, :yydefgoto
 
     def initialize(states)
       @states = states
@@ -41,15 +41,11 @@ module Lrama
     def yyfinal
       @states.states.find do |state|
         state.items.find do |item|
-          item.rule.lhs.id.s_value == "$accept" && item.end_of_rule?
+          item.rule.lhs.accept_symbol? && item.end_of_rule?
         end
       end.id
     end
 
-    def yylast
-      @yylast
-    end
-
     # Number of terms
     def yyntokens
       @states.terms.count
@@ -119,30 +115,14 @@ module Lrama
       end
     end
 
-    def yypact_ninf
-      @yypact_ninf
-    end
-
-    def yytable_ninf
-      @yytable_ninf
-    end
-
     def yypact
       @base[0...yynstates]
     end
 
-    def yydefact
-      @yydefact
-    end
-
     def yypgoto
       @base[yynstates..-1]
     end
 
-    def yydefgoto
-      @yydefgoto
-    end
-
     def yytable
       @table
     end

data/lib/lrama/grammar/binding.rb

@@ -0,0 +1,24 @@
+module Lrama
+  class Grammar
+    class Binding
+      attr_reader :actual_args, :count
+
+      def initialize(parameterizing_rule, actual_args)
+        @parameters = parameterizing_rule.parameters
+        @actual_args = actual_args
+        @parameter_to_arg = @parameters.zip(actual_args).map do |param, arg|
+          [param.s_value, arg]
+        end.to_h
+      end
+
+      def resolve_symbol(symbol)
+        if symbol.is_a?(Lexer::Token::InstantiateRule)
+          resolved_args = symbol.args.map { |arg| resolve_symbol(arg) }
+          Lrama::Lexer::Token::InstantiateRule.new(s_value: symbol.s_value, location: symbol.location, args: resolved_args, lhs_tag: symbol.lhs_tag)
+        else
+          @parameter_to_arg[symbol.s_value] || symbol
+        end
+      end
+    end
+  end
+end

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

@@ -22,7 +22,7 @@ module Lrama
         # For the semantic action of original rule:
         #
         # "Rule"                class: keyword_class { $1 } tSTRING { $2 + $3 } keyword_end { $class = $1 + $keyword_end }
-        # "Position in grammar"                   $1     $2      $3          $4          $5                             $6
+        # "Position in grammar"                   $1     $2      $3          $4          $5
         # "Index for yyvsp"                       -4     -3      -2          -1           0
         #
         #

data/lib/lrama/grammar/parameterizing_rule/resolver.rb

@@ -0,0 +1,39 @@
+module Lrama
+  class Grammar
+    class ParameterizingRule
+      class Resolver
+        attr_accessor :created_lhs_list
+
+        def initialize
+          @rules = []
+          @created_lhs_list = []
+        end
+
+        def add_parameterizing_rule(rule)
+          @rules << rule
+        end
+
+        def defined?(token)
+          !select_rules(token).empty?
+        end
+
+        def find(token)
+          select_rules(token).last
+        end
+
+        def created_lhs(lhs_s_value)
+          @created_lhs_list.select { |created_lhs| created_lhs.s_value == lhs_s_value }.last
+        end
+
+        private
+
+        def select_rules(token)
+          @rules.select do |rule|
+            rule.name == token.rule_name &&
+              rule.required_parameters_count == token.args_count
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lrama/grammar/parameterizing_rule/rhs.rb

@@ -0,0 +1,15 @@
+module Lrama
+  class Grammar
+    class ParameterizingRule
+      class Rhs
+        attr_accessor :symbols, :user_code, :precedence_sym
+
+        def initialize
+          @symbols = []
+          @user_code = nil
+          @precedence_sym = nil
+        end
+      end
+    end
+  end
+end

data/lib/lrama/grammar/parameterizing_rule/rule.rb

@@ -0,0 +1,16 @@
+module Lrama
+  class Grammar
+    class ParameterizingRule
+      class Rule
+        attr_reader :name, :parameters, :rhs_list, :required_parameters_count
+
+        def initialize(name, parameters, rhs_list)
+          @name = name
+          @parameters = parameters
+          @rhs_list = rhs_list
+          @required_parameters_count = parameters.count
+        end
+      end
+    end
+  end
+end

data/lib/lrama/grammar/parameterizing_rule.rb

@@ -1,6 +1,3 @@
-module Lrama
-  class Grammar
-    class ParameterizingRule < Struct.new(:rules, :token, keyword_init: true)
-    end
-  end
-end
+require_relative 'parameterizing_rule/resolver'
+require_relative 'parameterizing_rule/rhs'
+require_relative 'parameterizing_rule/rule'

data/lib/lrama/grammar/percent_code.rb

@@ -1,10 +1,10 @@
 module Lrama
   class Grammar
     class PercentCode
-      attr_reader :id, :code
+      attr_reader :name, :code
 
-      def initialize(id, code)
-        @id = id
+      def initialize(name, code)
+        @name = name
         @code = code
       end
     end

data/lib/lrama/grammar/rule_builder.rb

@@ -3,21 +3,22 @@ require 'lrama/grammar/parameterizing_rules/builder'
 module Lrama
   class Grammar
     class RuleBuilder
-      attr_accessor :lhs, :lhs_tag, :line
-      attr_reader :rhs, :user_code, :precedence_sym
+      attr_accessor :lhs, :line
+      attr_reader :lhs_tag, :rhs, :user_code, :precedence_sym
 
-      def initialize(rule_counter, midrule_action_counter, position_in_original_rule_rhs = nil, skip_preprocess_references: false)
+      def initialize(rule_counter, midrule_action_counter, position_in_original_rule_rhs = nil, lhs_tag: nil, skip_preprocess_references: false)
         @rule_counter = rule_counter
         @midrule_action_counter = midrule_action_counter
         @position_in_original_rule_rhs = position_in_original_rule_rhs
         @skip_preprocess_references = skip_preprocess_references
 
         @lhs = nil
+        @lhs_tag = lhs_tag
         @rhs = []
-        @lhs_tag = nil
         @user_code = nil
         @precedence_sym = nil
         @line = nil
+        @rule_builders_for_parameterizing_rules = []
         @rule_builders_for_derived_rules = []
       end
 
@@ -33,7 +34,7 @@ module Lrama
 
       def user_code=(user_code)
         if !@line
-          @line = user_code.line
+          @line = user_code&.line
         end
 
         flush_user_code
@@ -51,14 +52,14 @@ module Lrama
         freeze_rhs
       end
 
-      def setup_rules(parameterizing_resolver)
+      def setup_rules(parameterizing_rule_resolver)
         preprocess_references unless @skip_preprocess_references
-        process_rhs(parameterizing_resolver)
+        process_rhs(parameterizing_rule_resolver)
         build_rules
       end
 
       def rules
-        @parameterizing_rules + @midrule_action_rules + @rules
+        @parameterizing_rules + @old_parameterizing_rules + @midrule_action_rules + @rules
       end
 
       private
@@ -75,10 +76,13 @@ module Lrama
         tokens = @replaced_rhs
 
         rule = Rule.new(
-          id: @rule_counter.increment, _lhs: lhs, _rhs: tokens, token_code: user_code,
+          id: @rule_counter.increment, _lhs: lhs, _rhs: tokens, lhs_tag: lhs_tag, token_code: user_code,
           position_in_original_rule_rhs: @position_in_original_rule_rhs, precedence_sym: precedence_sym, lineno: line
         )
         @rules = [rule]
+        @parameterizing_rules = @rule_builders_for_parameterizing_rules.map do |rule_builder|
+          rule_builder.rules
+        end.flatten
         @midrule_action_rules = @rule_builders_for_derived_rules.map do |rule_builder|
           rule_builder.rules
         end.flatten
@@ -89,11 +93,11 @@ module Lrama
 
       # rhs is a mixture of variety type of tokens like `Ident`, `InstantiateRule`, `UserCode` and so on.
       # `#process_rhs` replaces some kind of tokens to `Ident` so that all `@replaced_rhs` are `Ident` or `Char`.
-      def process_rhs(parameterizing_resolver)
+      def process_rhs(parameterizing_rule_resolver)
         return if @replaced_rhs
 
         @replaced_rhs = []
-        @parameterizing_rules = []
+        @old_parameterizing_rules = []
 
         rhs.each_with_index do |token, i|
           case token
@@ -102,26 +106,46 @@ module Lrama
           when Lrama::Lexer::Token::Ident
             @replaced_rhs << token
           when Lrama::Lexer::Token::InstantiateRule
-            if parameterizing_resolver.defined?(token.rule_name)
-              parameterizing = parameterizing_resolver.build_rules(token, @rule_counter, @lhs_tag, line)
-              @parameterizing_rules = @parameterizing_rules + parameterizing.map(&:rules).flatten
-              @replaced_rhs = @replaced_rhs + parameterizing.map(&:token).flatten.uniq
+            if parameterizing_rule_resolver.defined?(token)
+              parameterizing_rule = parameterizing_rule_resolver.find(token)
+              raise "Unexpected token. #{token}" unless parameterizing_rule
+
+              bindings = Binding.new(parameterizing_rule, token.args)
+              lhs_s_value = lhs_s_value(token, bindings)
+              if (created_lhs = parameterizing_rule_resolver.created_lhs(lhs_s_value))
+                @replaced_rhs << created_lhs
+              else
+                lhs_token = Lrama::Lexer::Token::Ident.new(s_value: lhs_s_value, location: token.location)
+                @replaced_rhs << lhs_token
+                parameterizing_rule_resolver.created_lhs_list << lhs_token
+                parameterizing_rule.rhs_list.each do |r|
+                  rule_builder = RuleBuilder.new(@rule_counter, @midrule_action_counter, i, lhs_tag: token.lhs_tag, skip_preprocess_references: true)
+                  rule_builder.lhs = lhs_token
+                  r.symbols.each { |sym| rule_builder.add_rhs(bindings.resolve_symbol(sym)) }
+                  rule_builder.line = line
+                  rule_builder.user_code = r.user_code
+                  rule_builder.precedence_sym = r.precedence_sym
+                  rule_builder.complete_input
+                  rule_builder.setup_rules(parameterizing_rule_resolver)
+                  @rule_builders_for_parameterizing_rules << rule_builder
+                end
+              end
             else
               # TODO: Delete when the standard library will defined as a grammar file.
-              parameterizing = ParameterizingRules::Builder.new(token, @rule_counter, @lhs_tag, user_code, precedence_sym, line)
-              @parameterizing_rules = @parameterizing_rules + parameterizing.build
-              @replaced_rhs << parameterizing.build_token
+              parameterizing_rule = ParameterizingRules::Builder.new(token, @rule_counter, token.lhs_tag, user_code, precedence_sym, line)
+              @old_parameterizing_rules = @old_parameterizing_rules + parameterizing_rule.build
+              @replaced_rhs << parameterizing_rule.build_token
             end
           when Lrama::Lexer::Token::UserCode
             prefix = token.referred ? "@" : "$@"
             new_token = Lrama::Lexer::Token::Ident.new(s_value: prefix + @midrule_action_counter.increment.to_s)
             @replaced_rhs << new_token
 
-            rule_builder = RuleBuilder.new(@rule_counter, @midrule_action_counter, i, skip_preprocess_references: true)
+            rule_builder = RuleBuilder.new(@rule_counter, @midrule_action_counter, i, lhs_tag: lhs_tag, skip_preprocess_references: true)
             rule_builder.lhs = new_token
             rule_builder.user_code = token
             rule_builder.complete_input
-            rule_builder.setup_rules(parameterizing_resolver)
+            rule_builder.setup_rules(parameterizing_rule_resolver)
 
             @rule_builders_for_derived_rules << rule_builder
           else
@@ -130,6 +154,18 @@ module Lrama
         end
       end
 
+      def lhs_s_value(token, bindings)
+        s_values = token.args.map do |arg|
+          resolved = bindings.resolve_symbol(arg)
+          if resolved.is_a?(Lexer::Token::InstantiateRule)
+            [resolved.s_value, resolved.args.map(&:s_value)]
+          else
+            resolved.s_value
+          end
+        end
+        "#{token.rule_name}_#{s_values.join('_')}"
+      end
+
       def numberize_references
         # Bison n'th component is 1-origin
         (rhs + [user_code]).compact.each.with_index(1) do |token, i|
@@ -144,13 +180,11 @@ module Lrama
                 candidates = rhs.each_with_index.select {|token, i| token.referred_by?(ref_name) }
 
                 if candidates.size >= 2
-                  location = token.location.partial_location(ref.first_column, ref.last_column)
-                  raise location.generate_error_message("Referring symbol `#{ref_name}` is duplicated.")
+                  token.invalid_ref(ref, "Referring symbol `#{ref_name}` is duplicated.")
                 end
 
                 unless (referring_symbol = candidates.first)
-                  location = token.location.partial_location(ref.first_column, ref.last_column)
-                  raise location.generate_error_message("Referring symbol `#{ref_name}` is not found.")
+                  token.invalid_ref(ref, "Referring symbol `#{ref_name}` is not found.")
                 end
 
                 ref.index = referring_symbol[1] + 1
@@ -163,7 +197,7 @@ module Lrama
             if ref.index
               # TODO: Prohibit $0 even so Bison allows it?
               # See: https://www.gnu.org/software/bison/manual/html_node/Actions.html
-              raise "Can not refer following component. #{ref.index} >= #{i}. #{token}" if ref.index >= i
+              token.invalid_ref(ref, "Can not refer following component. #{ref.index} >= #{i}.") if ref.index >= i
               rhs[ref.index - 1].referred = true
             end
           end

data/lib/lrama/grammar/type.rb

@@ -1,6 +1,18 @@
 module Lrama
   class Grammar
-    class Type < Struct.new(:id, :tag, keyword_init: true)
+    class Type
+      attr_reader :id, :tag
+
+      def initialize(id:, tag:)
+        @id = id
+        @tag = tag
+      end
+
+      def ==(other)
+        self.class == other.class &&
+        self.id == other.id &&
+        self.tag == other.tag
+      end
     end
   end
 end

data/lib/lrama/grammar.rb

@@ -1,4 +1,5 @@
 require "lrama/grammar/auxiliary"
+require "lrama/grammar/binding"
 require "lrama/grammar/code"
 require "lrama/grammar/counter"
 require "lrama/grammar/error_token"
@@ -8,9 +9,6 @@ require "lrama/grammar/printer"
 require "lrama/grammar/reference"
 require "lrama/grammar/rule"
 require "lrama/grammar/rule_builder"
-require "lrama/grammar/parameterizing_rule_builder"
-require "lrama/grammar/parameterizing_rule_resolver"
-require "lrama/grammar/parameterizing_rule_rhs_builder"
 require "lrama/grammar/parameterizing_rule"
 require "lrama/grammar/symbol"
 require "lrama/grammar/type"
@@ -40,7 +38,7 @@ module Lrama
       @rule_builders = []
       @rules = []
       @sym_to_rules = {}
-      @parameterizing_resolver = ParameterizingRuleResolver.new
+      @parameterizing_rule_resolver = ParameterizingRule::Resolver.new
       @empty_symbol = nil
       @eof_symbol = nil
       @error_symbol = nil
@@ -52,7 +50,7 @@ module Lrama
     end
 
     def add_percent_code(id:, code:)
-      @percent_codes << PercentCode.new(id, code)
+      @percent_codes << PercentCode.new(id.s_value, code.s_value)
     end
 
     def add_printer(ident_or_tags:, token_code:, lineno:)
@@ -134,8 +132,8 @@ module Lrama
       @rule_builders << builder
     end
 
-    def add_parameterizing_rule_builder(builder)
-      @parameterizing_resolver.add_parameterizing_rule_builder(builder)
+    def add_parameterizing_rule(rule)
+      @parameterizing_rule_resolver.add_parameterizing_rule(rule)
     end
 
     def prologue_first_lineno=(prologue_first_lineno)
@@ -171,7 +169,7 @@ module Lrama
 
     # TODO: More validation methods
     #
-    # * Validaiton for no_declared_type_reference
+    # * Validation for no_declared_type_reference
     def validate!
       validate_symbol_number_uniqueness!
       validate_symbol_alias_name_uniqueness!
@@ -319,7 +317,7 @@ module Lrama
 
     def setup_rules
       @rule_builders.each do |builder|
-        builder.setup_rules(@parameterizing_resolver)
+        builder.setup_rules(@parameterizing_rule_resolver)
       end
     end
 

data/lib/lrama/lexer/grammar_file.rb

@@ -5,7 +5,7 @@ module Lrama
 
       def initialize(path, text)
         @path = path
-        @text = text
+        @text = text.freeze
       end
 
       def ==(other)