lrama 0.6.0 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b1a3e3181fc7060235e167ea97a92809b31aa5b74ef5978ab70415252bb87e3
-  data.tar.gz: 51a6ee0620321936fcd9d81c44ece3f9e444b977dc8fa940ddf920a5bb3b1dad
+  metadata.gz: e4158de45c42ff62eacfb00737261feaa49d8f0cc646004e30da74ba4e2e69c6
+  data.tar.gz: 734830227f701e18df2e9e8bc3da55d15f49c890e08530e6ac55ef87ae5f952d
 SHA512:
-  metadata.gz: f2b8805ad79cc0c3f125eba2715d274387191e6a355910d11c88f918eae4906b9398444162210c7ce955b1ba3f67cabf3b0679569a65d63bdc52328f2d7dc2f7
-  data.tar.gz: 93de8cc0c7f9154f37825d59010a4850cc81b8a66f460d70f95aed44c0eb1224e583d1afb95155be2d9ae063d286a4fa719c133c993c6ec9bfba1c490dfc997b
+  metadata.gz: 52ebbe4d099ae63d73aa995bddc8e966f989a4d00ad3b39634d2abe2448da404dd9bff8f15e0dedd0577716089329c804ef2c4edcadd39ca6ba47f8d293d101d
+  data.tar.gz: 72e91c79618071b5850c85335cfe3f1b63ff89f11cd332b0141623a4e2a7e2c2c389dd0db9afe38a5a84b7aa891ac1834fc7a2d6c6eed8f62d87734f6b99cbbf

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:
@@ -72,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: |
@@ -105,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:
@@ -118,12 +138,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,58 @@
 # NEWS for Lrama
 
+## 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
+
+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 +73,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,36 @@
 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)
-      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
+      begin
+        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
+        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 +61,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.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
@@ -241,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

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/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/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

@@ -0,0 +1,47 @@
+module Lrama
+  class Grammar
+    class ParameterizingRule
+      class Resolver
+        attr_accessor :rules, :created_lhs_list
+
+        def initialize
+          @rules = []
+          @created_lhs_list = []
+        end
+
+        def add_parameterizing_rule(rule)
+          @rules << rule
+        end
+
+        def find(token)
+          select_rules(token).last
+        end
+
+        def created_lhs(lhs_s_value)
+          @created_lhs_list.reverse.find { |created_lhs| created_lhs.s_value == lhs_s_value }
+        end
+
+        private
+
+        def select_rules(token)
+          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
+    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.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