lrama 0.6.0 → 0.6.1

data/parser.y

@@ -205,8 +205,8 @@ rule
 
   rule_declaration: "%rule" IDENTIFIER "(" rule_args ")" ":" rule_rhs_list
                       {
-                        builder = Grammar::ParameterizingRuleBuilder.new(val[1].s_value, val[3], val[6])
-                        @grammar.add_parameterizing_rule_builder(builder)
+                        rule = Grammar::ParameterizingRule::Rule.new(val[1].s_value, val[3], val[6])
+                        @grammar.add_parameterizing_rule(rule)
                       }
 
   rule_args: IDENTIFIER { result = [val[0]] }
@@ -226,12 +226,12 @@ rule
   rule_rhs: /* empty */
             {
               reset_precs
-              result = Grammar::ParameterizingRuleRhsBuilder.new
+              result = Grammar::ParameterizingRule::Rhs.new
             }
           | "%empty"
             {
               reset_precs
-              result = Grammar::ParameterizingRuleRhsBuilder.new
+              result = Grammar::ParameterizingRule::Rhs.new
             }
           | rule_rhs symbol named_ref_opt
             {
@@ -408,19 +408,17 @@ rule
          }
      | rhs symbol parameterizing_suffix tag_opt
          {
-           token = Lrama::Lexer::Token::InstantiateRule.new(s_value: val[2], location: @lexer.location, args: [val[1]])
+           token = Lrama::Lexer::Token::InstantiateRule.new(s_value: val[2], location: @lexer.location, args: [val[1]], lhs_tag: val[3])
            builder = val[0]
            builder.add_rhs(token)
-           builder.lhs_tag = val[3]
            builder.line = val[1].first_line
            result = builder
          }
      | rhs IDENTIFIER "(" parameterizing_args ")" tag_opt
          {
-           token = Lrama::Lexer::Token::InstantiateRule.new(s_value: val[1].s_value, location: @lexer.location, args: val[3])
+           token = Lrama::Lexer::Token::InstantiateRule.new(s_value: val[1].s_value, location: @lexer.location, args: val[3], lhs_tag: val[5])
            builder = val[0]
            builder.add_rhs(token)
-           builder.lhs_tag = val[5]
            builder.line = val[1].first_line
            result = builder
          }
@@ -459,6 +457,8 @@ rule
 
   parameterizing_args: symbol { result = [val[0]] }
                      | parameterizing_args ',' symbol { result = val[0].append(val[2]) }
+                     | symbol parameterizing_suffix { result = [Lrama::Lexer::Token::InstantiateRule.new(s_value: val[1].s_value, location: @lexer.location, args: val[0])] }
+                     | IDENTIFIER "(" parameterizing_args ")" { result = [Lrama::Lexer::Token::InstantiateRule.new(s_value: val[0].s_value, location: @lexer.location, args: val[2])] }
 
   named_ref_opt: # empty
                | '[' IDENTIFIER ']' { result = val[1].s_value }

data/sig/lrama/grammar/binding.rbs

@@ -0,0 +1,16 @@
+module Lrama
+  class Grammar
+    class Binding
+      attr_reader actual_args: Array[Lexer::Token]
+      attr_reader count: Integer
+
+      @rule_name: String
+      @required_parameters_count: Integer
+      @parameters: Array[Lexer::Token]
+      @parameter_to_arg: untyped
+
+      def initialize: (Grammar::ParameterizingRule::Rule parameterizing_rule, Array[Lexer::Token] actual_args) -> void
+      def resolve_symbol: (Lexer::Token symbol) -> Lexer::Token
+    end
+  end
+end

data/sig/lrama/grammar/parameterizing_rule/resolver.rbs

@@ -0,0 +1,21 @@
+module Lrama
+  class Grammar
+    class ParameterizingRule
+      class Resolver
+        attr_accessor created_lhs_list: Array[Lexer::Token]
+
+        @rules: Array[Grammar::ParameterizingRule::Rule]
+
+        def initialize: () -> void
+        def add_parameterizing_rule: (Grammar::ParameterizingRule::Rule rule) -> void
+        def defined?: (Lexer::Token::InstantiateRule token) -> bool
+        def find: (Lexer::Token::InstantiateRule token) -> Grammar::ParameterizingRule::Rule?
+        def created_lhs: (String lhs_s_value) -> Lexer::Token?
+
+        private
+
+        def select_rules: (Lexer::Token::InstantiateRule token) -> Array[Grammar::ParameterizingRule::Rule]
+      end
+    end
+  end
+end

data/sig/lrama/grammar/parameterizing_rule/rhs.rbs

@@ -0,0 +1,13 @@
+module Lrama
+  class Grammar
+    class ParameterizingRule
+      class Rhs
+        attr_reader symbols: Array[untyped]
+        attr_reader user_code: Lexer::Token::UserCode?
+        attr_reader precedence_sym: Lexer::Token?
+
+        def initialize: () -> void
+      end
+    end
+  end
+end

data/sig/lrama/grammar/parameterizing_rule/rule.rbs

@@ -0,0 +1,14 @@
+module Lrama
+  class Grammar
+    class ParameterizingRule
+      class Rule
+        attr_reader name: String
+        attr_reader parameters: Array[Lexer::Token]
+        attr_reader rhs_list: Array[Grammar::ParameterizingRule::Rhs]
+        attr_reader required_parameters_count: Integer
+
+        def initialize: (String name, Array[Lexer::Token] parameters, Array[Grammar::ParameterizingRule::Rhs] rhs_list) -> void
+      end
+    end
+  end
+end

data/sig/lrama/grammar/parameterizing_rule.rbs

@@ -1,10 +1,6 @@
 module Lrama
   class Grammar
     class ParameterizingRule
-      attr_accessor rules: Array[Rule]
-      attr_accessor token: Lexer::Token
-
-      def initialize: (?untyped rules, Lexer::Token token) -> void
     end
   end
 end

data/sig/lrama/grammar/percent_code.rbs

@@ -1,10 +1,10 @@
 module Lrama
   class Grammar
     class PercentCode
-      attr_reader id: Lexer::Token::Ident
-      attr_reader code: Lexer::Token::UserCode
+      attr_reader name: String
+      attr_reader code: String
 
-      def initialize: (Lexer::Token::Ident id, Lexer::Token::UserCode code) -> void
+      def initialize: (String name, String code) -> void
     end
   end
 end

data/sig/lrama/grammar/rule_builder.rbs

@@ -2,8 +2,8 @@ module Lrama
   class Grammar
     class RuleBuilder
       attr_accessor lhs: Lexer::Token
-      attr_accessor lhs_tag: untyped
       attr_accessor line: Integer?
+      attr_reader lhs_tag: Lexer::Token::Tag?
       attr_reader rhs: Array[Lexer::Token]
       attr_reader user_code: Lexer::Token::UserCode?
       attr_reader precedence_sym: Lexer::Token?
@@ -13,18 +13,20 @@ module Lrama
       @position_in_original_rule_rhs: Integer?
       @skip_preprocess_references: bool
       @user_code: Lexer::Token::UserCode?
+      @rule_builders_for_parameterizing_rules: Array[RuleBuilder]
       @rule_builders_for_derived_rules: Array[RuleBuilder]
       @rules: Array[Rule]
       @replaced_rhs: Array[Lexer::Token]
       @parameterizing_rules: Array[Rule]
+      @old_parameterizing_rules: Array[Rule]
       @midrule_action_rules: Array[Rule]
 
-      def initialize: (Counter rule_counter, Counter midrule_action_counter, ?Integer position_in_original_rule_rhs, ?skip_preprocess_references: bool) -> void
+      def initialize: (Counter rule_counter, Counter midrule_action_counter, ?Integer position_in_original_rule_rhs, ?lhs_tag: Lexer::Token::Tag?, ?skip_preprocess_references: bool) -> void
       def add_rhs: (Lexer::Token rhs) -> void
-      def user_code=: (Lexer::Token::UserCode user_code) -> void
-      def precedence_sym=: (Lexer::Token user_code) -> void
+      def user_code=: (Lexer::Token::UserCode? user_code) -> void
+      def precedence_sym=: (Lexer::Token? precedence_sym) -> void
       def complete_input: () -> void
-      def setup_rules: (Grammar::ParameterizingRuleResolver parameterizing_resolver) -> void
+      def setup_rules: (Grammar::ParameterizingRule::Resolver parameterizing_rule_resolver) -> void
       def rules: () -> Array[Rule]
 
       private
@@ -32,7 +34,8 @@ module Lrama
       def freeze_rhs: () -> void
       def preprocess_references: () -> void
       def build_rules: () -> void
-      def process_rhs: (Grammar::ParameterizingRuleResolver parameterizing_resolver) -> void
+      def process_rhs: (Grammar::ParameterizingRule::Resolver parameterizing_rule_resolver) -> void
+      def lhs_s_value: (Lexer::Token::InstantiateRule token, Grammar::Binding bindings) -> String
       def numberize_references: () -> void
       def flush_user_code: () -> void
     end

data/sig/lrama/lexer/token/instantiate_rule.rbs

@@ -2,10 +2,12 @@ module Lrama
   class Lexer
     class Token
       class InstantiateRule < Token
-        attr_accessor args: Array[Lexer::Token]
+        attr_reader args: Array[Lexer::Token]
+        attr_reader lhs_tag: Lexer::Token::Tag?
 
-        def initialize: (s_value: String, ?alias_name: String, ?location: Location, ?args: Array[Lexer::Token]) -> void
+        def initialize: (s_value: String, ?alias_name: String, ?location: Location, ?args: Array[Lexer::Token], ?lhs_tag: Lexer::Token::Tag?) -> void
         def rule_name: () -> String
+        def args_count: () -> Integer
       end
     end
   end

data/sig/lrama/lexer/token.rbs

@@ -17,6 +17,7 @@ module Lrama
       def last_column: () -> Integer
       alias line first_line
       alias column first_column
+      def invalid_ref: (Lrama::Grammar::Reference ref, String message) -> bot
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lrama
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Yuichiro Kaneko
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-12-25 00:00:00.000000000 Z
+date: 2024-01-13 00:00:00.000000000 Z
 dependencies: []
 description: LALR (1) parser generator written by Ruby
 email:
@@ -48,6 +48,7 @@ files:
 - lib/lrama/digraph.rb
 - lib/lrama/grammar.rb
 - lib/lrama/grammar/auxiliary.rb
+- lib/lrama/grammar/binding.rb
 - lib/lrama/grammar/code.rb
 - lib/lrama/grammar/code/initial_action_code.rb
 - lib/lrama/grammar/code/no_reference_code.rb
@@ -56,9 +57,9 @@ files:
 - lib/lrama/grammar/counter.rb
 - lib/lrama/grammar/error_token.rb
 - lib/lrama/grammar/parameterizing_rule.rb
-- lib/lrama/grammar/parameterizing_rule_builder.rb
-- lib/lrama/grammar/parameterizing_rule_resolver.rb
-- lib/lrama/grammar/parameterizing_rule_rhs_builder.rb
+- lib/lrama/grammar/parameterizing_rule/resolver.rb
+- lib/lrama/grammar/parameterizing_rule/rhs.rb
+- lib/lrama/grammar/parameterizing_rule/rule.rb
 - lib/lrama/grammar/parameterizing_rules/builder.rb
 - lib/lrama/grammar/parameterizing_rules/builder/base.rb
 - lib/lrama/grammar/parameterizing_rules/builder/list.rb
@@ -112,14 +113,15 @@ files:
 - sig/lrama/bitmap.rbs
 - sig/lrama/digraph.rbs
 - sig/lrama/grammar.rbs
+- sig/lrama/grammar/binding.rbs
 - sig/lrama/grammar/code.rbs
 - sig/lrama/grammar/code/printer_code.rbs
 - sig/lrama/grammar/counter.rbs
 - sig/lrama/grammar/error_token.rbs
 - sig/lrama/grammar/parameterizing_rule.rbs
-- sig/lrama/grammar/parameterizing_rule_builder.rbs
-- sig/lrama/grammar/parameterizing_rule_resolver.rbs
-- sig/lrama/grammar/parameterizing_rule_rhs_builder.rbs
+- sig/lrama/grammar/parameterizing_rule/resolver.rbs
+- sig/lrama/grammar/parameterizing_rule/rhs.rbs
+- sig/lrama/grammar/parameterizing_rule/rule.rbs
 - sig/lrama/grammar/parameterizing_rules/builder.rbs
 - sig/lrama/grammar/parameterizing_rules/builder/base.rbs
 - sig/lrama/grammar/parameterizing_rules/builder/list.rbs
@@ -168,7 +170,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.1
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: LALR (1) parser generator written by Ruby

data/lib/lrama/grammar/parameterizing_rule_builder.rb

@@ -1,34 +0,0 @@
-module Lrama
-  class Grammar
-    class ParameterizingRuleBuilder
-      attr_reader :name, :parameters, :rhs
-
-      def initialize(name, parameters, rhs)
-        @name = name
-        @parameters = parameters
-        @rhs = rhs
-        @required_parameters_count = parameters.count
-      end
-
-      def build_rules(token, actual_args, rule_counter, lhs_tag, line, rule_builders)
-        validate_argument_number!(token)
-        lhs = lhs(actual_args)
-        @rhs.map do |rhs|
-          rhs.build_rules(token, actual_args, parameters, rule_counter, lhs, lhs_tag, line, rule_builders)
-        end.flatten
-      end
-
-      private
-
-      def validate_argument_number!(token)
-        unless @required_parameters_count == token.args.count
-          raise "Invalid number of arguments. expect: #{@required_parameters_count} actual: #{token.args.count}"
-        end
-      end
-
-      def lhs(actual_args)
-        Lrama::Lexer::Token::Ident.new(s_value: "#{name}_#{actual_args.map(&:s_value).join('_')}")
-      end
-    end
-  end
-end

data/lib/lrama/grammar/parameterizing_rule_resolver.rb

@@ -1,30 +0,0 @@
-module Lrama
-  class Grammar
-    class ParameterizingRuleResolver
-      def initialize
-        @parameterizing_rule_builders = []
-      end
-
-      def add_parameterizing_rule_builder(builder)
-        @parameterizing_rule_builders << builder
-      end
-
-      def defined?(name)
-        !rule_builders(name).empty?
-      end
-
-      def build_rules(token, rule_counter, lhs_tag, line)
-        builder = rule_builders(token.s_value).last
-        raise "Unknown parameterizing rule #{token.s_value} at line #{token.line}" unless builder
-
-        builder.build_rules(token, token.args, rule_counter, lhs_tag, line, @parameterizing_rule_builders)
-      end
-
-      private
-
-      def rule_builders(name)
-        @parameterizing_rule_builders.select { |builder| builder.name == name }
-      end
-    end
-  end
-end

data/lib/lrama/grammar/parameterizing_rule_rhs_builder.rb

@@ -1,53 +0,0 @@
-module Lrama
-  class Grammar
-    class ParameterizingRuleRhsBuilder
-      attr_accessor :symbols, :user_code, :precedence_sym
-
-      def initialize
-        @symbols = []
-        @user_code = nil
-        @precedence_sym = nil
-      end
-
-      def build_rules(token, actual_args, parameters, rule_counter, lhs, lhs_tag, line, rule_builders)
-        nested_rules = build_nested_rules(token, actual_args, parameters, rule_counter, lhs_tag, line, rule_builders)
-        rule = Rule.new(id: rule_counter.increment, _lhs: lhs, _rhs: rhs(token, actual_args, parameters, nested_rules.last), lhs_tag: lhs_tag, token_code: user_code, precedence_sym: precedence_sym, lineno: line)
-        ParameterizingRule.new(rules: nested_rules.map(&:rules) + [rule], token: lhs)
-      end
-
-      private
-
-      def build_nested_rules(token, actual_args, parameters, rule_counter, lhs_tag, line, rule_builders)
-        symbols.each_with_index.map do |sym, i|
-          next unless sym.is_a?(Lexer::Token::InstantiateRule)
-
-          builder = rule_builders.select { |builder| builder.name == sym.s_value }.last
-          raise "Unknown parameterizing rule #{token.s_value} at line #{token.line}" unless builder
-
-          builder.build_rules(sym, nested_actual_args(actual_args, parameters, i), rule_counter, lhs_tag, line, rule_builders)
-        end.flatten.compact
-      end
-
-      def nested_actual_args(actual_args, parameters, idx)
-        symbols[idx].args.map do |arg|
-          i = parameters.index { |parameter| parameter.s_value == arg.s_value }
-          i.nil? ? arg : actual_args[i]
-        end
-      end
-
-      def rhs(token, actual_args, parameters, nested_rule)
-        symbols.map do |sym|
-          if sym.is_a?(Lexer::Token::InstantiateRule)
-            sym.args.map do |arg|
-              idx = parameters.index { |parameter| parameter.s_value == arg.s_value }
-              idx.nil? ? sym : nested_rule&.token
-            end
-          else
-            idx = parameters.index { |parameter| parameter.s_value == sym.s_value }
-            idx.nil? ? sym : actual_args[idx]
-          end
-        end.flatten
-      end
-    end
-  end
-end

data/sig/lrama/grammar/parameterizing_rule_builder.rbs

@@ -1,19 +0,0 @@
-module Lrama
-  class Grammar
-    class ParameterizingRuleBuilder
-      attr_reader name: String
-      attr_reader parameters: Array[Lexer::Token]
-      attr_reader rhs: Array[Grammar::ParameterizingRuleRhsBuilder]
-
-      @required_parameters_count: Integer
-
-      def initialize: (String name, Array[Lexer::Token] parameters, Array[Grammar::ParameterizingRuleRhsBuilder] rhs) -> void
-      def build_rules: (Lexer::Token::InstantiateRule token, Array[Lexer::Token] actual_args, Counter rule_counter, untyped lhs_tag, Integer? line, Array[ParameterizingRuleBuilder] rule_builders) -> Array[Grammar::ParameterizingRule]
-
-      private
-
-      def validate_argument_number!: (Lexer::Token::InstantiateRule token) -> void
-      def lhs: (Array[Lexer::Token] actual_args) -> Lexer::Token
-    end
-  end
-end

data/sig/lrama/grammar/parameterizing_rule_resolver.rbs

@@ -1,16 +0,0 @@
-module Lrama
-  class Grammar
-    class ParameterizingRuleResolver
-      @parameterizing_rule_builders: Array[Grammar::ParameterizingRuleBuilder]
-
-      def initialize: () -> void
-      def add_parameterizing_rule_builder: (Grammar::ParameterizingRuleBuilder builder) -> void
-      def defined?: (String) -> bool
-      def build_rules: (Lexer::Token::InstantiateRule token, Counter rule_counter, untyped lhs_tag, Integer? line) -> Array[Grammar::ParameterizingRule]
-
-      private
-
-      def rule_builders: (String) -> Array[Grammar::ParameterizingRuleBuilder]
-    end
-  end
-end

data/sig/lrama/grammar/parameterizing_rule_rhs_builder.rbs

@@ -1,18 +0,0 @@
-module Lrama
-  class Grammar
-    class ParameterizingRuleRhsBuilder
-      attr_reader symbols: Array[untyped]
-      attr_reader user_code: Lexer::Token::UserCode?
-      attr_reader precedence_sym: Lexer::Token?
-
-      def initialize: () -> void
-      def build_rules: (Lexer::Token::InstantiateRule token, Array[Lexer::Token] actual_args, Array[Lexer::Token] parameters, Counter rule_counter, Lexer::Token lhs, untyped lhs_tag, Integer? line, Array[ParameterizingRuleBuilder] rule_builders) -> Grammar::ParameterizingRule
-
-      private
-
-      def build_nested_rules: (Lexer::Token::InstantiateRule token, Array[Lexer::Token] actual_args, Array[Lexer::Token] parameters, Counter rule_counter, untyped lhs_tag, Integer? line, Array[ParameterizingRuleBuilder] rule_builders) -> Array[Grammar::ParameterizingRule]
-      def nested_actual_args: (Array[Lexer::Token] actual_args, Array[Lexer::Token] parameters, Integer idx) -> Array[Lexer::Token]
-      def rhs: (Lexer::Token token, Array[Lexer::Token] actual_args, Array[Lexer::Token] parameters, ParameterizingRule? nested_rule) -> Array[Lexer::Token]
-    end
-  end
-end