lrama 0.6.1 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50dc10cc2d790e778dcb6a35b789f146e69157b3c99d5b66059d95c025546ea6
-  data.tar.gz: cbc16ede0db21b5d22f74c47dfd7a87af2ae20e15f72afc9ea8a79980531861d
+  metadata.gz: e4158de45c42ff62eacfb00737261feaa49d8f0cc646004e30da74ba4e2e69c6
+  data.tar.gz: 734830227f701e18df2e9e8bc3da55d15f49c890e08530e6ac55ef87ae5f952d
 SHA512:
-  metadata.gz: 7567e78e28cb912eb6dae8182827b5c6555924757bffe4fd9db81f79dd117aaf00f0918c90ead79d3567eeee802b90556540141fd5d4083bf5d6013c075cb20c
-  data.tar.gz: e58f803bc04114bdeb69b74a5e34ab9649241dafb9fe69a62f7d17ea87026411e3f743c54537fa092a9d6cea547a046fc762a78d9daebf92c3184be5502a24c1
+  metadata.gz: 52ebbe4d099ae63d73aa995bddc8e966f989a4d00ad3b39634d2abe2448da404dd9bff8f15e0dedd0577716089329c804ef2c4edcadd39ca6ba47f8d293d101d
+  data.tar.gz: 72e91c79618071b5850c85335cfe3f1b63ff89f11cd332b0141623a4e2a7e2c2c389dd0db9afe38a5a84b7aa891ac1834fc7a2d6c6eed8f62d87734f6b99cbbf

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,14 @@
 # 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

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

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.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/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,7 +178,11 @@ 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.index = referring_symbol[1]
+                end
               end
             end
 

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{};

data/lib/lrama/grammar.rb

@@ -24,7 +24,7 @@ module Lrama
                   :lex_param, :parse_param, :initial_action,
                   :symbols, :types,
                   :rules, :rule_builders,
-                  :sym_to_rules
+                  :sym_to_rules, :no_stdlib
 
     def initialize(rule_counter)
       @rule_counter = rule_counter
@@ -45,6 +45,7 @@ module Lrama
       @undef_symbol = nil
       @accept_symbol = nil
       @aux = Auxiliary.new
+      @no_stdlib = false
 
       append_special_symbols
     end
@@ -136,6 +137,14 @@ module Lrama
       @parameterizing_rule_resolver.add_parameterizing_rule(rule)
     end
 
+    def parameterizing_rules
+      @parameterizing_rule_resolver.rules
+    end
+
+    def insert_before_parameterizing_rules(rules)
+      @parameterizing_rule_resolver.rules = rules + @parameterizing_rule_resolver.rules
+    end
+
     def prologue_first_lineno=(prologue_first_lineno)
       @aux.prologue_first_lineno = prologue_first_lineno
     end
@@ -234,7 +243,7 @@ module Lrama
     def compute_nullable
       @rules.each do |rule|
         case
-        when rule.rhs.empty?
+        when rule.empty_rule?
           rule.nullable = true
         when rule.rhs.any?(&:term)
           rule.nullable = false

data/lib/lrama/lexer.rb

@@ -29,6 +29,7 @@ module Lrama
       %empty
       %code
       %rule
+      %no-stdlib
     )
 
     def initialize(grammar_file)