lrama 0.5.12 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '008f1a5df39b115123be84cb5e1edd379d88458bc95256b0e4fe4659481ceb51'
-  data.tar.gz: 02af30da8cf4cb2cad841f43b603433edafab09b0cf0e8993201c2e9aea12029
+  metadata.gz: 50dc10cc2d790e778dcb6a35b789f146e69157b3c99d5b66059d95c025546ea6
+  data.tar.gz: cbc16ede0db21b5d22f74c47dfd7a87af2ae20e15f72afc9ea8a79980531861d
 SHA512:
-  metadata.gz: 12cf8b98035052e89f9060dd73ec2b32ad9c5bec2fe4076e6ee0416832039962cf973c7ca895b482f2f434500648638c01a717d67357aa055eccce851995adaf
-  data.tar.gz: a4cffc85bb5945a3d4d037c0eadee0df22e30236085e01f06bffe1646d0acafd09fdb606860752cdea9dbfdf45baa1fc8d244504b7a0ca29c37ab60f9a727367
+  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.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.3.0", require: false
+  gem "rbs", "3.4.1", require: false
   gem "steep", "1.6.0", require: false
 end

data/NEWS.md

@@ -1,5 +1,71 @@
 # 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
+
+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>
+    ;
+```
+
+https://github.com/ruby/lrama/pull/285
+
 ## Lrama 0.5.11 (2023-12-02)
 
 ### Type specification of parameterizing rules

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,7 +147,7 @@ $ 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 NEWS.md MIT exe lib template ruby/tool/lrama`
 4. Create new release on [GitHub](https://github.com/ruby/lrama/releases)

data/Steepfile

@@ -4,10 +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"
   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/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
@@ -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/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/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

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