lrama 0.5.11 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 634093bc73fd1504910364bffa6827a66fa7479f1f5b5238fdf577f0bb6d3d9d
-  data.tar.gz: 96db570d049f47f20bf619535ee91e7f0f846a492404a54f7fe41a6addcce484
+  metadata.gz: 7b1a3e3181fc7060235e167ea97a92809b31aa5b74ef5978ab70415252bb87e3
+  data.tar.gz: 51a6ee0620321936fcd9d81c44ece3f9e444b977dc8fa940ddf920a5bb3b1dad
 SHA512:
-  metadata.gz: 6b09e84cd16cd162f263e68abf7ada808418212ca449fab0f4a380c42c0193f479cad3d0d1afcc1d5f17d81b890e3754642d1a9433f7be5f6fc71fdcb2df3f97
-  data.tar.gz: 1994a670f1033e737f2193e2e71ccaa0818e4144ac7f4424ebf24046ece23efc3f67eeb0927c5336663a244f270b321247b39dbbdbe76cfacc13b94da6289a8b
+  metadata.gz: f2b8805ad79cc0c3f125eba2715d274387191e6a355910d11c88f918eae4906b9398444162210c7ce955b1ba3f67cabf3b0679569a65d63bdc52328f2d7dc2f7
+  data.tar.gz: 93de8cc0c7f9154f37825d59010a4850cc81b8a66f460d70f95aed44c0eb1224e583d1afb95155be2d9ae063d286a4fa719c133c993c6ec9bfba1c490dfc997b

data/.github/workflows/test.yaml

@@ -13,7 +13,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: ['head', '3.2', '3.1', '3.0', '2.7', '2.6', '2.5']
+        ruby: ['head', '3.3', '3.2', '3.1', '3.0', '2.7', '2.6', '2.5']
     steps:
       - uses: actions/checkout@v4
       - uses: ruby/setup-ruby@v1
@@ -122,7 +122,7 @@ jobs:
       - run: mkdir -p tool/lrama
         working-directory: ../ruby
       - name: Copy Lrama to ruby/tool
-        run: cp -r LEGAL.md MIT exe lib template ../ruby/tool/lrama
+        run: cp -r LEGAL.md NEWS.md MIT exe lib template ../ruby/tool/lrama
         working-directory:
       - run: tree tool/lrama
         working-directory: ../ruby

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.3.0", require: false
+  gem "rbs", "3.4.0", require: false
   gem "steep", "1.6.0", require: false
 end

data/LEGAL.md

@@ -7,5 +7,6 @@ mentioned below.
 
 These files are licensed under the GNU General Public License version 3 or later. See these files for more information.
 
+* template/bison/_yacc.h
 * template/bison/yacc.c
 * template/bison/yacc.h

data/NEWS.md

@@ -0,0 +1,187 @@
+# NEWS for Lrama
+
+## Lrama 0.6.0 (2023-12-25)
+
+### User defined parameterizing rules
+
+Allow to define parameterizing rule by `%rule` directive.
+
+```
+%rule pair(X, Y): X Y { $$ = $1 + $2; }
+                ;
+
+%%
+
+program: stmt
+       ;
+
+stmt: pair(ODD, EVEN) <num>
+    | pair(EVEN, ODD) <num>
+    ;
+```
+
+## Lrama 0.5.11 (2023-12-02)
+
+### Type specification of parameterizing rules
+
+Allow to specify type of rules by specifying tag, `<i>` in below example.
+Tag is post-modification style.
+
+```
+%union {
+    int i;
+}
+
+%%
+
+program         : option(number) <i>
+                | number_alias? <i>
+                ;
+```
+
+https://github.com/ruby/lrama/pull/272
+
+
+## Lrama 0.5.10 (2023-11-18)
+
+### Parameterizing rules (option, nonempty_list, list)
+
+Support function call style parameterizing rules for `option`, `nonempty_list` and `list`.
+
+https://github.com/ruby/lrama/pull/197
+
+### Parameterizing rules (separated_list)
+
+Support `separated_list` and `separated_nonempty_list` parameterizing rules.
+
+```
+program: separated_list(',', number)
+
+// Expanded to
+
+program: separated_list_number
+separated_list_number: ε
+separated_list_number: separated_nonempty_list_number
+separated_nonempty_list_number: number
+separated_nonempty_list_number: separated_nonempty_list_number ',' number
+```
+
+```
+program: separated_nonempty_list(',', number)
+
+// Expanded to
+
+program: separated_nonempty_list_number
+separated_nonempty_list_number: number
+separated_nonempty_list_number: separated_nonempty_list_number ',' number
+```
+
+https://github.com/ruby/lrama/pull/204
+
+## Lrama 0.5.9 (2023-11-05)
+
+### Parameterizing rules (suffix)
+
+Parameterizing rules are template of rules.
+It's very common pattern to write "list" grammar rule like:
+
+```
+opt_args: /* none */
+        | args
+        ;
+
+args: arg
+    | args arg
+```
+
+Lrama supports these suffixes:
+
+* `?`: option
+* `+`: nonempty list
+* `*`: list
+
+Idea of Parameterizing rules comes from Menhir LR(1) parser generator (https://gallium.inria.fr/~fpottier/menhir/manual.html#sec32).
+
+https://github.com/ruby/lrama/pull/181
+
+## Lrama 0.5.7 (2023-10-23)
+
+### Racc parser
+
+Replace Lrama's parser from hand written parser to LR parser generated by Racc.
+Lrama uses `--embedded` option to generate LR parser because Racc is changed from default gem to bundled gem by Ruby 3.3 (https://github.com/ruby/lrama/pull/132).
+
+https://github.com/ruby/lrama/pull/62
+
+## Lrama 0.5.4 (2023-08-17)
+
+### Runtime configuration for error recovery
+
+Meke error recovery function configurable on runtime by two new macros.
+
+* `YYMAXREPAIR`: Expected to return max length of repair operations. `%parse-param` is passed to this function.
+* `YYERROR_RECOVERY_ENABLED`: Expected to return bool value to determine error recovery is enabled or not. `%parse-param` is passed to this function.
+
+https://github.com/ruby/lrama/pull/74
+
+## Lrama 0.5.3 (2023-08-05)
+
+### Error Recovery
+
+Support token insert base Error Recovery.
+`-e` option is needed to generate parser with error recovery functions.
+
+https://github.com/ruby/lrama/pull/44
+
+## Lrama 0.5.2 (2023-06-14)
+
+### Named References
+
+Instead of positional references like `$1` or `$$`,
+named references allow to access to symbol by name.
+
+```
+primary: k_class cpath superclass bodystmt k_end
+           {
+             $primary = new_class($cpath, $bodystmt, $superclass);
+           }
+```
+
+Alias name can be declared.
+
+```
+expr[result]: expr[ex-left] '+' expr[ex.right]
+                {
+                  $result = $[ex-left] + $[ex.right];
+                }
+```
+
+Bison supports this feature from 2.5.
+
+### Add parse params to some macros and functions
+
+`%parse-param` are added to these macros and functions to remove ytab.sed hack from Ruby.
+
+* `YY_LOCATION_PRINT`
+* `YY_SYMBOL_PRINT`
+* `yy_stack_print`
+* `YY_STACK_PRINT`
+* `YY_REDUCE_PRINT`
+* `yysyntax_error`
+
+https://github.com/ruby/lrama/pull/40
+
+See also: https://github.com/ruby/ruby/pull/7807
+
+## Lrama 0.5.0 (2023-05-17)
+
+### stdin mode
+
+When `-` is given as grammar file name, reads the grammar source from STDIN, and takes the next argument as the input file name. This mode helps pre-process a grammar source.
+
+https://github.com/ruby/lrama/pull/8
+
+## Lrama 0.4.0 (2023-05-13)
+
+This is the first version migrated to Ruby.
+This version generates "parse.c" compatible with Bison 3.8.2.

data/README.md

@@ -49,9 +49,13 @@ Enter the formula:
 
 ## Versions and Branches
 
-### v0_5 (`master` branch)
+### v0_6 (`master` branch)
 
-This branch is for Ruby 3.3. `lrama_0_5` branch is created from this branch, once Ruby 3.3 is released.
+This branch is for Ruby 3.4. `lrama_0_6` branch is created from this branch, once Ruby 3.4 is released.
+
+### v0_5 (`lrama_0_5` branch)
+
+This branch is for Ruby 3.3.
 
 ### v0_4 (`lrama_0_4` branch)
 
@@ -91,6 +95,13 @@ $ bundle exec rbs collection install
 $ bundle exec steep check
 ```
 
+Running both of them:
+
+```shell
+$ bundle install
+$ bundle exec rake
+```
+
 ### Profiling Lrama
 
 #### 1. Create parse.tmp.y in ruby/ruby
@@ -136,9 +147,9 @@ $ stackprof --d3-flamegraph tmp/stackprof-cpu-myapp.dump > tmp/flamegraph.html
 
 ## Release flow
 
-1. Update `Lrama::VERSION`
+1. Update `Lrama::VERSION` and NEWS.md
 2. Release as a gem by `rake release`
-3. Update Lrama in ruby/ruby by `cp -r LEGAL.md MIT exe lib template ruby/tool/lrama`
+3. Update Lrama in ruby/ruby by `cp -r LEGAL.md NEWS.md MIT exe lib template ruby/tool/lrama`
 4. Create new release on [GitHub](https://github.com/ruby/lrama/releases)
 
 ## License

data/Steepfile

@@ -8,6 +8,9 @@ target :lib do
   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_rules"
   check "lib/lrama/grammar/percent_code.rb"
   check "lib/lrama/grammar/precedence.rb"

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

@@ -2,7 +2,7 @@ module Lrama
   class Grammar
     class Code
       class PrinterCode < Code
-        def initialize(type: nil, token_code: nil, tag: nil)
+        def initialize(type:, token_code:, tag:)
           super(type: type, token_code: token_code)
           @tag = tag
         end

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

@@ -2,7 +2,7 @@ module Lrama
   class Grammar
     class Code
       class RuleAction < Code
-        def initialize(type: nil, token_code: nil, rule: nil)
+        def initialize(type:, token_code:, rule:)
           super(type: type, token_code: token_code)
           @rule = rule
         end
@@ -14,9 +14,23 @@ module Lrama
         # * ($1) yyvsp[i]
         # * (@1) yylsp[i]
         #
+        #
+        # Consider a rule like
+        #
+        #   class: keyword_class { $1 } tSTRING { $2 + $3 } keyword_end { $class = $1 + $keyword_end }
+        #
+        # 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
+        # "Index for yyvsp"                       -4     -3      -2          -1           0
+        #
+        #
+        # For the first midrule action:
+        #
         # "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
+        # "Position in grammar"                   $1
+        # "Index for yyvsp"                        0
         def reference_to_c(ref)
           case
           when ref.type == :dollar && ref.name == "$" # $$
@@ -45,10 +59,12 @@ module Lrama
           @rule.position_in_original_rule_rhs || @rule.rhs.count
         end
 
+        # If this is midrule action, RHS is a RHS of the original rule.
         def rhs
           (@rule.original_rule || @rule).rhs
         end
 
+        # Unlike `rhs`, LHS is always a LHS of the rule.
         def lhs
           @rule.lhs
         end

data/lib/lrama/grammar/code.rb

@@ -1,12 +1,29 @@
 require "forwardable"
+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"
 
 module Lrama
   class Grammar
-    class Code < Struct.new(:type, :token_code, keyword_init: true)
+    class Code
       extend Forwardable
 
       def_delegators "token_code", :s_value, :line, :column, :references
 
+      attr_reader :type, :token_code
+
+      def initialize(type:, token_code:)
+        @type = type
+        @token_code = token_code
+      end
+
+      def ==(other)
+        self.class == other.class &&
+        self.type == other.type &&
+        self.token_code == other.token_code
+      end
+
       # $$, $n, @$, @n are translated to C code
       def translated_code
         t_code = s_value.dup
@@ -17,7 +34,7 @@ module Lrama
 
           str = reference_to_c(ref)
 
-          t_code[first_column..last_column] = str
+          t_code[first_column...last_column] = str
         end
 
         return t_code
@@ -31,8 +48,3 @@ module Lrama
     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/parameterizing_rule.rb

@@ -0,0 +1,6 @@
+module Lrama
+  class Grammar
+    class ParameterizingRule < Struct.new(:rules, :token, keyword_init: true)
+    end
+  end
+end

data/lib/lrama/grammar/parameterizing_rule_builder.rb

@@ -0,0 +1,34 @@
+module Lrama
+  class Grammar
+    class ParameterizingRuleBuilder
+      attr_reader :name, :parameters, :rhs
+
+      def initialize(name, parameters, rhs)
+        @name = name
+        @parameters = parameters
+        @rhs = rhs
+        @required_parameters_count = parameters.count
+      end
+
+      def build_rules(token, actual_args, rule_counter, lhs_tag, line, rule_builders)
+        validate_argument_number!(token)
+        lhs = lhs(actual_args)
+        @rhs.map do |rhs|
+          rhs.build_rules(token, actual_args, parameters, rule_counter, lhs, lhs_tag, line, rule_builders)
+        end.flatten
+      end
+
+      private
+
+      def validate_argument_number!(token)
+        unless @required_parameters_count == token.args.count
+          raise "Invalid number of arguments. expect: #{@required_parameters_count} actual: #{token.args.count}"
+        end
+      end
+
+      def lhs(actual_args)
+        Lrama::Lexer::Token::Ident.new(s_value: "#{name}_#{actual_args.map(&:s_value).join('_')}")
+      end
+    end
+  end
+end

data/lib/lrama/grammar/parameterizing_rule_resolver.rb

@@ -0,0 +1,30 @@
+module Lrama
+  class Grammar
+    class ParameterizingRuleResolver
+      def initialize
+        @parameterizing_rule_builders = []
+      end
+
+      def add_parameterizing_rule_builder(builder)
+        @parameterizing_rule_builders << builder
+      end
+
+      def defined?(name)
+        !rule_builders(name).empty?
+      end
+
+      def build_rules(token, rule_counter, lhs_tag, line)
+        builder = rule_builders(token.s_value).last
+        raise "Unknown parameterizing rule #{token.s_value} at line #{token.line}" unless builder
+
+        builder.build_rules(token, token.args, rule_counter, lhs_tag, line, @parameterizing_rule_builders)
+      end
+
+      private
+
+      def rule_builders(name)
+        @parameterizing_rule_builders.select { |builder| builder.name == name }
+      end
+    end
+  end
+end

data/lib/lrama/grammar/parameterizing_rule_rhs_builder.rb

@@ -0,0 +1,53 @@
+module Lrama
+  class Grammar
+    class ParameterizingRuleRhsBuilder
+      attr_accessor :symbols, :user_code, :precedence_sym
+
+      def initialize
+        @symbols = []
+        @user_code = nil
+        @precedence_sym = nil
+      end
+
+      def build_rules(token, actual_args, parameters, rule_counter, lhs, lhs_tag, line, rule_builders)
+        nested_rules = build_nested_rules(token, actual_args, parameters, rule_counter, lhs_tag, line, rule_builders)
+        rule = Rule.new(id: rule_counter.increment, _lhs: lhs, _rhs: rhs(token, actual_args, parameters, nested_rules.last), lhs_tag: lhs_tag, token_code: user_code, precedence_sym: precedence_sym, lineno: line)
+        ParameterizingRule.new(rules: nested_rules.map(&:rules) + [rule], token: lhs)
+      end
+
+      private
+
+      def build_nested_rules(token, actual_args, parameters, rule_counter, lhs_tag, line, rule_builders)
+        symbols.each_with_index.map do |sym, i|
+          next unless sym.is_a?(Lexer::Token::InstantiateRule)
+
+          builder = rule_builders.select { |builder| builder.name == sym.s_value }.last
+          raise "Unknown parameterizing rule #{token.s_value} at line #{token.line}" unless builder
+
+          builder.build_rules(sym, nested_actual_args(actual_args, parameters, i), rule_counter, lhs_tag, line, rule_builders)
+        end.flatten.compact
+      end
+
+      def nested_actual_args(actual_args, parameters, idx)
+        symbols[idx].args.map do |arg|
+          i = parameters.index { |parameter| parameter.s_value == arg.s_value }
+          i.nil? ? arg : actual_args[i]
+        end
+      end
+
+      def rhs(token, actual_args, parameters, nested_rule)
+        symbols.map do |sym|
+          if sym.is_a?(Lexer::Token::InstantiateRule)
+            sym.args.map do |arg|
+              idx = parameters.index { |parameter| parameter.s_value == arg.s_value }
+              idx.nil? ? sym : nested_rule&.token
+            end
+          else
+            idx = parameters.index { |parameter| parameter.s_value == sym.s_value }
+            idx.nil? ? sym : actual_args[idx]
+          end
+        end.flatten
+      end
+    end
+  end
+end

data/lib/lrama/grammar/rule_builder.rb

@@ -51,22 +51,14 @@ module Lrama
         freeze_rhs
       end
 
-      def setup_rules
+      def setup_rules(parameterizing_resolver)
         preprocess_references unless @skip_preprocess_references
-        process_rhs
+        process_rhs(parameterizing_resolver)
         build_rules
       end
 
-      def parameterizing_rules
-        @parameterizing_rules
-      end
-
-      def midrule_action_rules
-        @midrule_action_rules
-      end
-
       def rules
-        @rules
+        @parameterizing_rules + @midrule_action_rules + @rules
       end
 
       private
@@ -95,9 +87,9 @@ module Lrama
         end
       end
 
-      # rhs is a mixture of variety type of tokens like `Ident`, `Parameterizing`, `UserCode` and so on.
+      # 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
+      def process_rhs(parameterizing_resolver)
         return if @replaced_rhs
 
         @replaced_rhs = []
@@ -109,12 +101,17 @@ module Lrama
             @replaced_rhs << token
           when Lrama::Lexer::Token::Ident
             @replaced_rhs << token
-          when Lrama::Lexer::Token::Parameterizing
-            parameterizing = ParameterizingRules::Builder.new(token, @rule_counter, @lhs_tag, user_code, precedence_sym, line)
-            parameterizing.build.each do |r|
-              @parameterizing_rules << r
+          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
+            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
             end
-            @replaced_rhs << parameterizing.build_token
           when Lrama::Lexer::Token::UserCode
             prefix = token.referred ? "@" : "$@"
             new_token = Lrama::Lexer::Token::Ident.new(s_value: prefix + @midrule_action_counter.increment.to_s)
@@ -124,7 +121,7 @@ module Lrama
             rule_builder.lhs = new_token
             rule_builder.user_code = token
             rule_builder.complete_input
-            rule_builder.setup_rules
+            rule_builder.setup_rules(parameterizing_resolver)
 
             @rule_builders_for_derived_rules << rule_builder
           else
@@ -146,8 +143,15 @@ module Lrama
               else
                 candidates = rhs.each_with_index.select {|token, i| token.referred_by?(ref_name) }
 
-                raise "Referring symbol `#{ref_name}` is duplicated. #{token}" if candidates.size >= 2
-                raise "Referring symbol `#{ref_name}` is not found. #{token}" unless referring_symbol = candidates.first
+                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.")
+                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.")
+                end
 
                 ref.index = referring_symbol[1] + 1
               end
@@ -167,7 +171,7 @@ module Lrama
       end
 
       def flush_user_code
-        if c = @user_code
+        if (c = @user_code)
           @rhs << c
           @user_code = nil
         end