lrama 0.6.1 → 0.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50dc10cc2d790e778dcb6a35b789f146e69157b3c99d5b66059d95c025546ea6
-  data.tar.gz: cbc16ede0db21b5d22f74c47dfd7a87af2ae20e15f72afc9ea8a79980531861d
+  metadata.gz: ecd30d3fab4dd73442ed6d3b2802db5b463159cb6ddf1f1835d9b8e860d4c9dd
+  data.tar.gz: 79b6087e68d3c2e95db81fa1d25f58280a5543e9c5fa91f5b6ecc7c40b5599d7
 SHA512:
-  metadata.gz: 7567e78e28cb912eb6dae8182827b5c6555924757bffe4fd9db81f79dd117aaf00f0918c90ead79d3567eeee802b90556540141fd5d4083bf5d6013c075cb20c
-  data.tar.gz: e58f803bc04114bdeb69b74a5e34ab9649241dafb9fe69a62f7d17ea87026411e3f743c54537fa092a9d6cea547a046fc762a78d9daebf92c3184be5502a24c1
+  metadata.gz: f3302156423399987015deb90afbaa0d6916e5e61b14c5297ff6a0e01ab9db3bbd164b334a11e26d38cf626425b7faee404e5d1cdec236a9b08b576ced4fe201
+  data.tar.gz: 380d8d31c93e5ae6c5a406c2b2eedad0d4b52dd311ecd742ca1412bd1acade7dae8fe12f7a6325ef8a0b4922ffd927b0dfa2caf3cd54c095669ab2b2cab85516

data/.github/workflows/test.yaml

@@ -87,6 +87,11 @@ jobs:
           bundler-cache: true
       - run: bundle install
 
+      # Copy from https://github.com/ruby/ruby/blob/cb9a47f2acd6e373ef868b890a9d07da6f565dd4/.github/workflows/check_misc.yml#L31
+      - name: Check if C-sources are US-ASCII
+        run: |
+          grep -r -n --include='*.[chyS]' --include='*.asm' $'[^\t-~]' -- . && exit 1 || :
+
       # Copy from https://github.com/ruby/ruby/blob/089227e94823542acfdafa68541d330eee42ffea/.github/workflows/check_misc.yml#L27
       - name: Check for trailing spaces
         run: |
@@ -120,8 +125,8 @@ jobs:
       fail-fast: false
       matrix:
         # '3.0' is the oldest living ruby version
-        # '2.5' is for BASERUBY
-        baseruby: ['head', '3.0', '2.5']
+        # '2.7' is for BASERUBY
+        baseruby: ['head', '3.0', '2.7']
         ruby_branch: ['master']
     defaults:
       run:

data/NEWS.md

@@ -1,5 +1,48 @@
 # NEWS for Lrama
 
+## Lrama 0.6.3 (2024-02-15)
+
+### Bring Your Own Stack
+
+Provide functionalities for Bring Your Own Stack.
+
+Ruby’s Ripper library requires their own semantic value stack to manage Ruby Objects returned by user defined callback method. Currently Ripper uses semantic value stack (`yyvsa`) which is used by parser to manage Node. This hack introduces some limitation on Ripper. For example, Ripper can not execute semantic analysis depending on Node structure.
+
+Lrama introduces two features to support another semantic value stack by parser generator users.
+
+1. Callback entry points
+
+User can emulate semantic value stack by these callbacks.
+Lrama provides these five callbacks. Registered functions are called when each event happen. For example %after-shift function is called when shift happens on original semantic value stack.
+
+* `%after-shift` function_name
+* `%before-reduce` function_name
+* `%after-reduce` function_name
+* `%after-shift-error-token` function_name
+* `%after-pop-stack` function_name
+
+2. `$:n` variable to access index of each grammar symbols
+
+User also needs to access semantic value of their stack in grammar action. `$:n` provides the way to access to it. `$:n` is translated to the minus index from the top of the stack.
+For example
+
+```
+primary: k_if expr_value then compstmt if_tail k_end
+          {
+          /*% ripper: if!($:2, $:4, $:5) %*/
+          /* $:2 = -5, $:4 = -3, $:5 = -2. */
+          }
+```
+
+## Lrama 0.6.2 (2024-01-27)
+
+### %no-stdlib directive
+
+If `%no-stdlib` directive is set, Lrama doesn't load Lrama standard library for
+parameterizing rules, stdlib.y.
+
+https://github.com/ruby/lrama/pull/344
+
 ## Lrama 0.6.1 (2024-01-13)
 
 ### Nested parameterizing rules

data/README.md

@@ -1,7 +1,23 @@
 # Lrama
 
+[![Gem Version](https://badge.fury.io/rb/lrama.svg)](https://badge.fury.io/rb/lrama)
+[![build](https://github.com/ruby/lrama/actions/workflows/test.yaml/badge.svg)](https://github.com/ruby/lrama/actions/workflows/test.yaml)
+
 Lrama is LALR (1) parser generator written by Ruby. The first goal of this project is providing error tolerant parser for CRuby with minimal changes on CRuby parse.y file.
 
+* [Features](#features)
+* [Installation](#installation)
+* [Usage](#usage)
+* [Versions and Branches](#versions-and-branches)
+* [Supported Ruby version](#supported-ruby-version)
+* [Development](#development)
+  * [How to generate parser.rb](#how-to-generate-parserrb)
+  * [Test](#test)
+  * [Profiling Lrama](#profiling-lrama)
+  * [Build Ruby](#build-ruby)
+* [Release flow](#release-flow)
+* [License](#license)
+
 ## Features
 
 * Bison style grammar file is supported with some assumptions
@@ -11,6 +27,9 @@ Lrama is LALR (1) parser generator written by Ruby. The first goal of this proje
   * b4_lac_if is always false
 * Error Tolerance parser
   * Subset of [Repairing Syntax Errors in LR Parsers (Corchuelo et al.)](https://idus.us.es/bitstream/handle/11441/65631/Repairing%20syntax%20errors.pdf) algorithm is supported
+* Parameterizing rules
+  * The definition of a non-terminal symbol can be parameterized with other (terminal or non-terminal) symbols.
+  * Providing a generic definition of parameterizing rules as a [standard library](lib/lrama/grammar/stdlib.y).
 
 ## Installation
 
@@ -85,6 +104,8 @@ Running tests:
 ```shell
 $ bundle install
 $ bundle exec rspec
+# or
+$ bundle exec rake spec
 ```
 
 Running type check:
@@ -93,6 +114,8 @@ Running type check:
 $ bundle install
 $ bundle exec rbs collection install
 $ bundle exec steep check
+# or
+$ bundle exec rake steep
 ```
 
 Running both of them:

data/Steepfile

@@ -11,12 +11,14 @@ target :lib do
   check "lib/lrama/grammar/error_token.rb"
   check "lib/lrama/grammar/parameterizing_rule"
   check "lib/lrama/grammar/parameterizing_rules"
+  check "lib/lrama/grammar/symbols"
   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/grammar/type.rb"
   check "lib/lrama/lexer"
   check "lib/lrama/report"
   check "lib/lrama/bitmap.rb"

data/lib/lrama/command.rb

@@ -1,5 +1,8 @@
 module Lrama
   class Command
+    LRAMA_LIB = File.realpath(File.join(File.dirname(__FILE__)))
+    STDLIB_FILE_PATH = File.join(LRAMA_LIB, 'grammar', 'stdlib.y')
+
     def run(argv)
       begin
         options = OptionParser.new.parse(argv)
@@ -14,9 +17,14 @@ module Lrama
       warning = Lrama::Warning.new
       text = options.y.read
       options.y.close if options.y != STDIN
-      parser = Lrama::Parser.new(text, options.grammar_file, options.debug)
       begin
-        grammar = parser.parse
+        grammar = Lrama::Parser.new(text, options.grammar_file, options.debug).parse
+        unless grammar.no_stdlib
+          stdlib_grammar = Lrama::Parser.new(File.read(STDLIB_FILE_PATH), STDLIB_FILE_PATH, options.debug).parse
+          grammar.insert_before_parameterizing_rules(stdlib_grammar.parameterizing_rules)
+        end
+        grammar.prepare
+        grammar.validate!
       rescue => e
         raise e if options.debug
         message = e.message

data/lib/lrama/context.rb

@@ -41,7 +41,7 @@ module Lrama
     def yyfinal
       @states.states.find do |state|
         state.items.find do |item|
-          item.rule.lhs.accept_symbol? && item.end_of_rule?
+          item.lhs.accept_symbol? && item.end_of_rule?
         end
       end.id
     end
@@ -221,7 +221,7 @@ module Lrama
 
         if state.reduces.map(&:selected_look_ahead).any? {|la| !la.empty? }
           # Iterate reduces with reverse order so that first rule is used.
-          state.reduces.reverse.each do |reduce|
+          state.reduces.reverse_each do |reduce|
             reduce.look_ahead.each do |term|
               actions[term.number] = rule_id_to_action_number(reduce.rule.id)
             end
@@ -265,9 +265,9 @@ module Lrama
 
         s = actions.each_with_index.map do |n, i|
           [i, n]
-        end.select do |i, n|
+        end.reject do |i, n|
           # Remove default_reduction_rule entries
-          n != 0
+          n == 0
         end
 
         if s.count != 0
@@ -462,7 +462,7 @@ module Lrama
       @yylast = high
 
       # replace_ninf
-      @yypact_ninf = (@base.select {|i| i != BaseMin } + [0]).min - 1
+      @yypact_ninf = (@base.reject {|i| i == BaseMin } + [0]).min - 1
       @base.map! do |i|
         case i
         when BaseMin
@@ -472,7 +472,7 @@ module Lrama
         end
       end
 
-      @yytable_ninf = (@table.compact.select {|i| i != ErrorActionNumber } + [0]).min - 1
+      @yytable_ninf = (@table.compact.reject {|i| i == ErrorActionNumber } + [0]).min - 1
       @table.map! do |i|
         case i
         when nil

data/lib/lrama/counterexamples/example.rb

@@ -40,7 +40,7 @@ module Lrama
         current = :production
         lookahead_sym = paths.last.to.item.end_of_rule? ? @conflict_symbol : nil
 
-        paths.reverse.each do |path|
+        paths.reverse_each do |path|
           item = path.to.item
 
           case current
@@ -97,7 +97,7 @@ module Lrama
           if next_sym == sym
             derivation = nil
 
-            sis.reverse.each do |si|
+            sis.reverse_each do |si|
               derivation = Derivation.new(si.item, derivation)
             end
 

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

@@ -6,18 +6,24 @@ module Lrama
 
         # * ($$) yylval
         # * (@$) yylloc
+        # * ($:$) error
         # * ($1) error
         # * (@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 == :index && ref.name == "$" # $:$
+            raise "$:#{ref.value} can not be used in initial_action."
           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."
+          when ref.type == :index # $:n
+            raise "$:#{ref.value} can not be used in initial_action."
           else
             raise "Unexpected. #{self}, #{ref}"
           end

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

@@ -6,14 +6,18 @@ module Lrama
 
         # * ($$) error
         # * (@$) error
+        # * ($:$) error
         # * ($1) 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}."
+          when ref.type == :index # $:$, $:n
+            raise "$:#{ref.value} can not be used in #{type}."
           else
             raise "Unexpected. #{self}, #{ref}"
           end

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

@@ -11,8 +11,10 @@ module Lrama
 
         # * ($$) *yyvaluep
         # * (@$) *yylocationp
+        # * ($:$) error
         # * ($1) error
         # * (@1) error
+        # * ($:1) error
         def reference_to_c(ref)
           case
           when ref.type == :dollar && ref.name == "$" # $$
@@ -20,10 +22,14 @@ module Lrama
             "((*yyvaluep).#{member})"
           when ref.type == :at && ref.name == "$" # @$
             "(*yylocationp)"
+          when ref.type == :index && ref.name == "$" # $:$
+            raise "$:#{ref.value} can not be used in #{type}."
           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}."
+          when ref.type == :index # $:n
+            raise "$:#{ref.value} can not be used in #{type}."
           else
             raise "Unexpected. #{self}, #{ref}"
           end

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

@@ -11,8 +11,10 @@ module Lrama
 
         # * ($$) yyval
         # * (@$) yyloc
+        # * ($:$) error
         # * ($1) yyvsp[i]
         # * (@1) yylsp[i]
+        # * ($:1) i - 1
         #
         #
         # Consider a rule like
@@ -24,6 +26,8 @@ module Lrama
         # "Rule"                class: keyword_class { $1 } tSTRING { $2 + $3 } keyword_end { $class = $1 + $keyword_end }
         # "Position in grammar"                   $1     $2      $3          $4          $5
         # "Index for yyvsp"                       -4     -3      -2          -1           0
+        # "$:n"                                  $:1    $:2     $:3         $:4         $:5
+        # "index of $:n"                          -5     -4      -3          -2          -1
         #
         #
         # For the first midrule action:
@@ -31,6 +35,7 @@ module Lrama
         # "Rule"                class: keyword_class { $1 } tSTRING { $2 + $3 } keyword_end { $class = $1 + $keyword_end }
         # "Position in grammar"                   $1
         # "Index for yyvsp"                        0
+        # "$:n"                                  $:1
         def reference_to_c(ref)
           case
           when ref.type == :dollar && ref.name == "$" # $$
@@ -39,6 +44,8 @@ module Lrama
             "(yyval.#{tag.member})"
           when ref.type == :at && ref.name == "$" # @$
             "(yyloc)"
+          when ref.type == :index && ref.name == "$" # $:$
+            raise "$:$ is not supported"
           when ref.type == :dollar # $n
             i = -position_in_rhs + ref.index
             tag = ref.ex_tag || rhs[ref.index - 1].tag
@@ -47,6 +54,9 @@ module Lrama
           when ref.type == :at # @n
             i = -position_in_rhs + ref.index
             "(yylsp[#{i}])"
+          when ref.type == :index # $:n
+            i = -position_in_rhs + ref.index
+            "(#{i} - 1)"
           else
             raise "Unexpected. #{self}, #{ref}"
           end
@@ -70,7 +80,7 @@ module Lrama
         end
 
         def raise_tag_not_found_error(ref)
-          raise "Tag is not specified for '$#{ref.value}' in '#{@rule.to_s}'"
+          raise "Tag is not specified for '$#{ref.value}' in '#{@rule}'"
         end
       end
     end

data/lib/lrama/grammar/code.rb

@@ -28,7 +28,7 @@ module Lrama
       def translated_code
         t_code = s_value.dup
 
-        references.reverse.each do |ref|
+        references.reverse_each do |ref|
           first_column = ref.first_column
           last_column = ref.last_column
 

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

@@ -2,7 +2,7 @@ module Lrama
   class Grammar
     class ParameterizingRule
       class Resolver
-        attr_accessor :created_lhs_list
+        attr_accessor :rules, :created_lhs_list
 
         def initialize
           @rules = []
@@ -13,24 +13,32 @@ module Lrama
           @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
+          @created_lhs_list.reverse.find { |created_lhs| created_lhs.s_value == lhs_s_value }
         end
 
         private
 
         def select_rules(token)
-          @rules.select do |rule|
-            rule.name == token.rule_name &&
-              rule.required_parameters_count == token.args_count
+          rules = select_rules_by_name(token.rule_name)
+          rules = rules.select { |rule| rule.required_parameters_count == token.args_count }
+          if rules.empty?
+            raise "Invalid number of arguments. `#{token.rule_name}`"
+          else
+            rules
+          end
+        end
+
+        def select_rules_by_name(rule_name)
+          rules = @rules.select { |rule| rule.name == rule_name }
+          if rules.empty?
+            raise "Parameterizing rule does not exist. `#{rule_name}`"
+          else
+            rules
           end
         end
       end

data/lib/lrama/grammar/reference.rb

@@ -2,11 +2,12 @@ module Lrama
   class Grammar
     # type: :dollar or :at
     # name: String (e.g. $$, $foo, $expr.right)
-    # index: Integer (e.g. $1)
+    # number: Integer (e.g. $1)
+    # index: Integer
     # ex_tag: "$<tag>1" (Optional)
-    class Reference < Struct.new(:type, :name, :index, :ex_tag, :first_column, :last_column, keyword_init: true)
+    class Reference < Struct.new(:type, :name, :number, :index, :ex_tag, :first_column, :last_column, keyword_init: true)
       def value
-        name || index
+        name || number
       end
     end
   end

data/lib/lrama/grammar/rule.rb

@@ -19,7 +19,7 @@ module Lrama
       # TODO: Change this to display_name
       def to_s
         l = lhs.id.s_value
-        r = rhs.empty? ? "ε" : rhs.map {|r| r.id.s_value }.join(", ")
+        r = empty_rule? ? "ε" : rhs.map {|r| r.id.s_value }.join(", ")
 
         "#{l} -> #{r}"
       end
@@ -27,7 +27,7 @@ module Lrama
       # Used by #user_actions
       def as_comment
         l = lhs.id.s_value
-        r = rhs.empty? ? "%empty" : rhs.map(&:display_name).join(" ")
+        r = empty_rule? ? "%empty" : rhs.map(&:display_name).join(" ")
 
         "#{l}: #{r}"
       end

data/lib/lrama/grammar/rule_builder.rb

@@ -1,5 +1,3 @@
-require 'lrama/grammar/parameterizing_rules/builder'
-
 module Lrama
   class Grammar
     class RuleBuilder
@@ -59,7 +57,7 @@ module Lrama
       end
 
       def rules
-        @parameterizing_rules + @old_parameterizing_rules + @midrule_action_rules + @rules
+        @parameterizing_rules + @midrule_action_rules + @rules
       end
 
       private
@@ -97,7 +95,6 @@ module Lrama
         return if @replaced_rhs
 
         @replaced_rhs = []
-        @old_parameterizing_rules = []
 
         rhs.each_with_index do |token, i|
           case token
@@ -106,35 +103,28 @@ module Lrama
           when Lrama::Lexer::Token::Ident
             @replaced_rhs << token
           when Lrama::Lexer::Token::InstantiateRule
-            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
+            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
-              # TODO: Delete when the standard library will defined as a grammar file.
-              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
+              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
           when Lrama::Lexer::Token::UserCode
             prefix = token.referred ? "@" : "$@"
@@ -173,11 +163,12 @@ module Lrama
 
           token.references.each do |ref|
             ref_name = ref.name
-            if ref_name && ref_name != '$'
-              if lhs.referred_by?(ref_name)
+
+            if ref_name
+              if ref_name == '$'
                 ref.name = '$'
               else
-                candidates = rhs.each_with_index.select {|token, i| token.referred_by?(ref_name) }
+                candidates = ([lhs] + rhs).each_with_index.select {|token, _i| token.referred_by?(ref_name) }
 
                 if candidates.size >= 2
                   token.invalid_ref(ref, "Referring symbol `#{ref_name}` is duplicated.")
@@ -187,10 +178,21 @@ module Lrama
                   token.invalid_ref(ref, "Referring symbol `#{ref_name}` is not found.")
                 end
 
-                ref.index = referring_symbol[1] + 1
+                if referring_symbol[1] == 0 # Refers to LHS
+                  ref.name = '$'
+                else
+                  ref.number = referring_symbol[1]
+                end
               end
             end
 
+            if ref.number
+              # TODO: When Inlining is implemented, for example, if `$1` is expanded to multiple RHS tokens,
+              #       `$2` needs to access `$2 + n` to actually access it. So, after the Inlining implementation,
+              #       it needs resolves from number to index.
+              ref.index = ref.number
+            end
+
             # TODO: Need to check index of @ too?
             next if ref.type == :at
 

data/lib/lrama/grammar/stdlib.y

@@ -0,0 +1,80 @@
+/**********************************************************************
+
+  stdlib.y
+
+  This is lrama's standard library. It provides a number of
+  parameterizing rule definitions, such as options and lists,
+  that should be useful in a number of situations.
+
+**********************************************************************/
+
+/*
+ * program: option(number)
+ *
+ * =>
+ *
+ * program: option_number
+ * option_number: %empty
+ * option_number: number
+ */
+%rule option(X): /* empty */
+               | X
+               ;
+
+/*
+ * program: list(number)
+ *
+ * =>
+ *
+ * program: list_number
+ * list_number: %empty
+ * list_number: list_number number
+ */
+%rule list(X): /* empty */
+             | list(X) X
+             ;
+
+/*
+ * program: nonempty_list(number)
+ *
+ * =>
+ *
+ * program: nonempty_list_number
+ * nonempty_list_number: number
+ * nonempty_list_number: nonempty_list_number number
+ */
+%rule nonempty_list(X): X
+                      | nonempty_list(X) X
+                      ;
+
+/*
+ * program: separated_nonempty_list(comma, number)
+ *
+ * =>
+ *
+ * program: separated_nonempty_list_comma_number
+ * separated_nonempty_list_comma_number: number
+ * separated_nonempty_list_comma_number: separated_nonempty_list_comma_number comma number
+ */
+%rule separated_nonempty_list(separator, X): X
+                                           | separated_nonempty_list(separator, X) separator X
+                                           ;
+
+/*
+ * program: separated_list(comma, number)
+ *
+ * =>
+ *
+ * program: separated_list_comma_number
+ * separated_list_comma_number: option_separated_nonempty_list_comma_number
+ * option_separated_nonempty_list_comma_number: %empty
+ * option_separated_nonempty_list_comma_number: separated_nonempty_list_comma_number
+ * separated_nonempty_list_comma_number: number
+ * separated_nonempty_list_comma_number: comma separated_nonempty_list_comma_number number
+ */
+%rule separated_list(separator, X): option(separated_nonempty_list(separator, X))
+                                  ;
+
+%%
+
+%union{};