lrama 0.6.0 → 0.6.2

data/lib/lrama/grammar/rule_builder.rb

@@ -1,23 +1,22 @@
-require 'lrama/grammar/parameterizing_rules/builder'
-
 module Lrama
   class Grammar
     class RuleBuilder
-      attr_accessor :lhs, :lhs_tag, :line
-      attr_reader :rhs, :user_code, :precedence_sym
+      attr_accessor :lhs, :line
+      attr_reader :lhs_tag, :rhs, :user_code, :precedence_sym
 
-      def initialize(rule_counter, midrule_action_counter, position_in_original_rule_rhs = nil, skip_preprocess_references: false)
+      def initialize(rule_counter, midrule_action_counter, position_in_original_rule_rhs = nil, lhs_tag: nil, skip_preprocess_references: false)
         @rule_counter = rule_counter
         @midrule_action_counter = midrule_action_counter
         @position_in_original_rule_rhs = position_in_original_rule_rhs
         @skip_preprocess_references = skip_preprocess_references
 
         @lhs = nil
+        @lhs_tag = lhs_tag
         @rhs = []
-        @lhs_tag = nil
         @user_code = nil
         @precedence_sym = nil
         @line = nil
+        @rule_builders_for_parameterizing_rules = []
         @rule_builders_for_derived_rules = []
       end
 
@@ -33,7 +32,7 @@ module Lrama
 
       def user_code=(user_code)
         if !@line
-          @line = user_code.line
+          @line = user_code&.line
         end
 
         flush_user_code
@@ -51,9 +50,9 @@ module Lrama
         freeze_rhs
       end
 
-      def setup_rules(parameterizing_resolver)
+      def setup_rules(parameterizing_rule_resolver)
         preprocess_references unless @skip_preprocess_references
-        process_rhs(parameterizing_resolver)
+        process_rhs(parameterizing_rule_resolver)
         build_rules
       end
 
@@ -75,10 +74,13 @@ module Lrama
         tokens = @replaced_rhs
 
         rule = Rule.new(
-          id: @rule_counter.increment, _lhs: lhs, _rhs: tokens, token_code: user_code,
+          id: @rule_counter.increment, _lhs: lhs, _rhs: tokens, lhs_tag: lhs_tag, token_code: user_code,
           position_in_original_rule_rhs: @position_in_original_rule_rhs, precedence_sym: precedence_sym, lineno: line
         )
         @rules = [rule]
+        @parameterizing_rules = @rule_builders_for_parameterizing_rules.map do |rule_builder|
+          rule_builder.rules
+        end.flatten
         @midrule_action_rules = @rule_builders_for_derived_rules.map do |rule_builder|
           rule_builder.rules
         end.flatten
@@ -89,11 +91,10 @@ module Lrama
 
       # 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(parameterizing_resolver)
+      def process_rhs(parameterizing_rule_resolver)
         return if @replaced_rhs
 
         @replaced_rhs = []
-        @parameterizing_rules = []
 
         rhs.each_with_index do |token, i|
           case token
@@ -102,26 +103,39 @@ module Lrama
           when Lrama::Lexer::Token::Ident
             @replaced_rhs << token
           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
+            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 = ParameterizingRules::Builder.new(token, @rule_counter, @lhs_tag, user_code, precedence_sym, line)
-              @parameterizing_rules = @parameterizing_rules + parameterizing.build
-              @replaced_rhs << parameterizing.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 ? "@" : "$@"
             new_token = Lrama::Lexer::Token::Ident.new(s_value: prefix + @midrule_action_counter.increment.to_s)
             @replaced_rhs << new_token
 
-            rule_builder = RuleBuilder.new(@rule_counter, @midrule_action_counter, i, skip_preprocess_references: true)
+            rule_builder = RuleBuilder.new(@rule_counter, @midrule_action_counter, i, lhs_tag: lhs_tag, skip_preprocess_references: true)
             rule_builder.lhs = new_token
             rule_builder.user_code = token
             rule_builder.complete_input
-            rule_builder.setup_rules(parameterizing_resolver)
+            rule_builder.setup_rules(parameterizing_rule_resolver)
 
             @rule_builders_for_derived_rules << rule_builder
           else
@@ -130,6 +144,18 @@ module Lrama
         end
       end
 
+      def lhs_s_value(token, bindings)
+        s_values = token.args.map do |arg|
+          resolved = bindings.resolve_symbol(arg)
+          if resolved.is_a?(Lexer::Token::InstantiateRule)
+            [resolved.s_value, resolved.args.map(&:s_value)]
+          else
+            resolved.s_value
+          end
+        end
+        "#{token.rule_name}_#{s_values.join('_')}"
+      end
+
       def numberize_references
         # Bison n'th component is 1-origin
         (rhs + [user_code]).compact.each.with_index(1) do |token, i|
@@ -137,23 +163,26 @@ 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
-                  location = token.location.partial_location(ref.first_column, ref.last_column)
-                  raise location.generate_error_message("Referring symbol `#{ref_name}` is duplicated.")
+                  token.invalid_ref(ref, "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.")
+                  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
 
@@ -163,7 +192,7 @@ module Lrama
             if ref.index
               # TODO: Prohibit $0 even so Bison allows it?
               # See: https://www.gnu.org/software/bison/manual/html_node/Actions.html
-              raise "Can not refer following component. #{ref.index} >= #{i}. #{token}" if ref.index >= i
+              token.invalid_ref(ref, "Can not refer following component. #{ref.index} >= #{i}.") if ref.index >= i
               rhs[ref.index - 1].referred = true
             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/type.rb

@@ -1,6 +1,18 @@
 module Lrama
   class Grammar
-    class Type < Struct.new(:id, :tag, keyword_init: true)
+    class Type
+      attr_reader :id, :tag
+
+      def initialize(id:, tag:)
+        @id = id
+        @tag = tag
+      end
+
+      def ==(other)
+        self.class == other.class &&
+        self.id == other.id &&
+        self.tag == other.tag
+      end
     end
   end
 end

data/lib/lrama/grammar.rb

@@ -1,4 +1,5 @@
 require "lrama/grammar/auxiliary"
+require "lrama/grammar/binding"
 require "lrama/grammar/code"
 require "lrama/grammar/counter"
 require "lrama/grammar/error_token"
@@ -8,9 +9,6 @@ require "lrama/grammar/printer"
 require "lrama/grammar/reference"
 require "lrama/grammar/rule"
 require "lrama/grammar/rule_builder"
-require "lrama/grammar/parameterizing_rule_builder"
-require "lrama/grammar/parameterizing_rule_resolver"
-require "lrama/grammar/parameterizing_rule_rhs_builder"
 require "lrama/grammar/parameterizing_rule"
 require "lrama/grammar/symbol"
 require "lrama/grammar/type"
@@ -26,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
@@ -40,19 +38,20 @@ module Lrama
       @rule_builders = []
       @rules = []
       @sym_to_rules = {}
-      @parameterizing_resolver = ParameterizingRuleResolver.new
+      @parameterizing_rule_resolver = ParameterizingRule::Resolver.new
       @empty_symbol = nil
       @eof_symbol = nil
       @error_symbol = nil
       @undef_symbol = nil
       @accept_symbol = nil
       @aux = Auxiliary.new
+      @no_stdlib = false
 
       append_special_symbols
     end
 
     def add_percent_code(id:, code:)
-      @percent_codes << PercentCode.new(id, code)
+      @percent_codes << PercentCode.new(id.s_value, code.s_value)
     end
 
     def add_printer(ident_or_tags:, token_code:, lineno:)
@@ -134,8 +133,16 @@ module Lrama
       @rule_builders << builder
     end
 
-    def add_parameterizing_rule_builder(builder)
-      @parameterizing_resolver.add_parameterizing_rule_builder(builder)
+    def add_parameterizing_rule(rule)
+      @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)
@@ -171,7 +178,7 @@ module Lrama
 
     # TODO: More validation methods
     #
-    # * Validaiton for no_declared_type_reference
+    # * Validation for no_declared_type_reference
     def validate!
       validate_symbol_number_uniqueness!
       validate_symbol_alias_name_uniqueness!
@@ -236,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
@@ -319,7 +326,7 @@ module Lrama
 
     def setup_rules
       @rule_builders.each do |builder|
-        builder.setup_rules(@parameterizing_resolver)
+        builder.setup_rules(@parameterizing_rule_resolver)
       end
     end
 

data/lib/lrama/lexer/grammar_file.rb

@@ -5,7 +5,7 @@ module Lrama
 
       def initialize(path, text)
         @path = path
-        @text = text
+        @text = text.freeze
       end
 
       def ==(other)

data/lib/lrama/lexer/token/instantiate_rule.rb

@@ -2,16 +2,21 @@ module Lrama
   class Lexer
     class Token
       class InstantiateRule < Token
-        attr_accessor :args
+        attr_reader :args, :lhs_tag
 
-        def initialize(s_value:, alias_name: nil, location: nil, args: [])
+        def initialize(s_value:, alias_name: nil, location: nil, args: [], lhs_tag: nil)
           super s_value: s_value, alias_name: alias_name, location: location
           @args = args
+          @lhs_tag = lhs_tag
         end
 
         def rule_name
           s_value
         end
+
+        def args_count
+          args.count
+        end
       end
     end
   end

data/lib/lrama/lexer/token.rb

@@ -46,6 +46,11 @@ module Lrama
       def last_column
         location.last_column
       end
+
+      def invalid_ref(ref, message)
+        location = self.location.partial_location(ref.first_column, ref.last_column)
+        raise location.generate_error_message(message)
+      end
     end
   end
 end

data/lib/lrama/lexer.rb

@@ -5,9 +5,8 @@ require "lrama/lexer/token"
 
 module Lrama
   class Lexer
-    attr_reader :head_line, :head_column
-    attr_accessor :status
-    attr_accessor :end_symbol
+    attr_reader :head_line, :head_column, :line
+    attr_accessor :status, :end_symbol
 
     SYMBOLS = ['%{', '%}', '%%', '{', '}', '\[', '\]', '\(', '\)', '\,', ':', '\|', ';']
     PERCENT_TOKENS = %w(
@@ -30,6 +29,7 @@ module Lrama
       %empty
       %code
       %rule
+      %no-stdlib
     )
 
     def initialize(grammar_file)
@@ -50,10 +50,6 @@ module Lrama
       end
     end
 
-    def line
-      @line
-    end
-
     def column
       @scanner.pos - @head
     end

data/lib/lrama/output.rb

@@ -352,9 +352,9 @@ module Lrama
     # b4_percent_code_get
     def percent_code(name)
       @grammar.percent_codes.select do |percent_code|
-        percent_code.id.s_value == name
+        percent_code.name == name
       end.map do |percent_code|
-        percent_code.code.s_value
+        percent_code.code
       end.join
     end