lrama 0.5.12 → 0.6.1

data/lib/lrama/states_reporter.rb

@@ -156,7 +156,7 @@ module Lrama
           nl = true
         end
 
-        if r = state.default_reduction_rule
+        if (r = state.default_reduction_rule)
           nl = true
           s = "$default".ljust(max_len)
 

data/lib/lrama/version.rb

@@ -1,3 +1,3 @@
 module Lrama
-  VERSION = "0.5.12".freeze
+  VERSION = "0.6.1".freeze
 end

data/parser.y

@@ -29,6 +29,7 @@ rule
                     | bison_declarations bison_declaration
 
   bison_declaration: grammar_declaration
+                   | rule_declaration
                    | "%expect" INTEGER { @grammar.expect = val[1] }
                    | "%define" variable value
                    | "%param" params
@@ -202,6 +203,85 @@ rule
 
   token_declaration: id int_opt alias { result = val }
 
+  rule_declaration: "%rule" IDENTIFIER "(" rule_args ")" ":" rule_rhs_list
+                      {
+                        rule = Grammar::ParameterizingRule::Rule.new(val[1].s_value, val[3], val[6])
+                        @grammar.add_parameterizing_rule(rule)
+                      }
+
+  rule_args: IDENTIFIER { result = [val[0]] }
+           | rule_args "," IDENTIFIER { result = val[0].append(val[2]) }
+
+  rule_rhs_list: rule_rhs
+                {
+                  builder = val[0]
+                  result = [builder]
+                }
+          | rule_rhs_list "|" rule_rhs
+                {
+                  builder = val[2]
+                  result = val[0].append(builder)
+                }
+
+  rule_rhs: /* empty */
+            {
+              reset_precs
+              result = Grammar::ParameterizingRule::Rhs.new
+            }
+          | "%empty"
+            {
+              reset_precs
+              result = Grammar::ParameterizingRule::Rhs.new
+            }
+          | rule_rhs symbol named_ref_opt
+            {
+              token = val[1]
+              token.alias_name = val[2]
+              builder = val[0]
+              builder.symbols << token
+              result = builder
+            }
+          | rule_rhs IDENTIFIER parameterizing_suffix
+              {
+                builder = val[0]
+                builder.symbols << Lrama::Lexer::Token::InstantiateRule.new(s_value: val[2], location: @lexer.location, args: [val[1]])
+                result = builder
+              }
+          | rule_rhs IDENTIFIER "(" parameterizing_args ")"
+              {
+                builder = val[0]
+                builder.symbols << Lrama::Lexer::Token::InstantiateRule.new(s_value: val[1].s_value, location: @lexer.location, args: val[3])
+                result = builder
+              }
+          | rule_rhs "{"
+            {
+              if @prec_seen
+                on_action_error("multiple User_code after %prec", val[0])  if @code_after_prec
+                @code_after_prec = true
+              end
+              begin_c_declaration("}")
+            }
+          C_DECLARATION
+            {
+              end_c_declaration
+            }
+          "}" named_ref_opt
+            {
+              user_code = val[3]
+              user_code.alias_name = val[6]
+              builder = val[0]
+              builder.user_code = user_code
+              result = builder
+            }
+          | rule_rhs "%prec" symbol
+            {
+              sym = @grammar.find_symbol_by_id!(val[2])
+              @prec_seen = true
+              builder = val[0]
+              builder.precedence_sym = sym
+              result = builder
+            }
+
   int_opt: # empty
          | INTEGER
 
@@ -326,21 +406,19 @@ rule
            builder.add_rhs(token)
            result = builder
          }
-     | rhs IDENTIFIER parameterizing_suffix tag_opt
+     | rhs symbol parameterizing_suffix tag_opt
          {
-           token = Lrama::Lexer::Token::Parameterizing.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::Parameterizing.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
          }
@@ -379,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 }
@@ -421,8 +501,7 @@ end
 include Lrama::Report::Duration
 
 def initialize(text, path, debug = false)
-  @text = text
-  @path = path
+  @grammar_file = Lrama::Lexer::GrammarFile.new(path, text)
   @yydebug = debug
   @rule_counter = Lrama::Grammar::Counter.new(0)
   @midrule_action_counter = Lrama::Grammar::Counter.new(1)
@@ -430,7 +509,7 @@ end
 
 def parse
   report_duration(:parse) do
-    @lexer = Lrama::Lexer.new(@text)
+    @lexer = Lrama::Lexer.new(@grammar_file)
     @grammar = Lrama::Grammar.new(@rule_counter)
     @precedence_number = 0
     reset_precs
@@ -447,40 +526,26 @@ end
 
 def on_error(error_token_id, error_value, value_stack)
   if error_value.is_a?(Lrama::Lexer::Token)
-    line = error_value.first_line
-    first_column = error_value.first_column
-    last_column = error_value.last_column
+    location = error_value.location
     value = "'#{error_value.s_value}'"
   else
-    line = @lexer.line
-    first_column = @lexer.head_column
-    last_column = @lexer.column
+    location = @lexer.location
     value = error_value.inspect
   end
 
-  raise ParseError, <<~ERROR
-    #{@path}:#{line}:#{first_column}: parse error on value #{value} (#{token_to_str(error_token_id) || '?'})
-    #{@text.split("\n")[line - 1]}
-    #{carrets(first_column, last_column)}
-  ERROR
+  error_message = "parse error on value #{value} (#{token_to_str(error_token_id) || '?'})"
+
+  raise_parse_error(error_message, location)
 end
 
 def on_action_error(error_message, error_value)
   if error_value.is_a?(Lrama::Lexer::Token)
-    line = error_value.first_line
-    first_column = error_value.first_column
-    last_column = error_value.last_column
+    location = error_value.location
   else
-    line = @lexer.line
-    first_column = @lexer.head_column
-    last_column = @lexer.column
+    location = @lexer.location
   end
 
-  raise ParseError, <<~ERROR
-    #{@path}:#{line}: #{error_message}
-    #{@text.split("\n")[line - 1]}
-    #{carrets(first_column, last_column)}
-  ERROR
+  raise_parse_error(error_message, location)
 end
 
 private
@@ -500,6 +565,6 @@ def end_c_declaration
   @lexer.end_symbol = nil
 end
 
-def carrets(first_column, last_column)
-  ' ' * (first_column + 1) + '^' * (last_column - first_column)
+def raise_parse_error(error_message, location)
+  raise ParseError, location.generate_error_message(error_message)
 end

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/code/printer_code.rbs

@@ -3,7 +3,7 @@ module Lrama
     class Code
       class PrinterCode < Code
         @tag: untyped
-        def initialize: (?type: untyped, ?token_code: untyped, ?tag: untyped) -> void
+        def initialize: (type: untyped, token_code: untyped, tag: untyped) -> void
 
         private
 

data/sig/lrama/grammar/code.rbs

@@ -3,16 +3,16 @@ module Lrama
     class Code
       extend Forwardable
 
-      attr_accessor type: untyped
-      attr_accessor token_code: untyped
+      attr_accessor type: Symbol
+      attr_accessor token_code: Lexer::Token::UserCode
 
       # delegated
       def s_value: -> String
       def line: -> Integer
-      def column: -> untyped
-      def references: -> untyped
+      def column: -> Integer
+      def references: -> Array[Lrama::Grammar::Reference]
 
-      def initialize: (?type: untyped, ?token_code: untyped) -> void
+      def initialize: (type: Symbol, token_code: Lexer::Token::UserCode) -> void
 
       def translated_code: () -> String
 

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

@@ -0,0 +1,6 @@
+module Lrama
+  class Grammar
+    class ParameterizingRule
+    end
+  end
+end

data/sig/lrama/grammar/parameterizing_rules/builder/base.rbs

@@ -5,11 +5,11 @@ module Lrama
         class Base
           attr_reader build_token: Lexer::Token::Ident
 
-          def initialize: (Lexer::Token::Parameterizing token, Counter rule_counter, untyped lhs_tag, Lexer::Token::UserCode? user_code, Lexer::Token? precedence_sym, Integer? line) -> void
+          def initialize: (Lexer::Token::InstantiateRule token, Counter rule_counter, untyped lhs_tag, Lexer::Token::UserCode? user_code, Lexer::Token? precedence_sym, Integer? line) -> void
           def build: () -> Array[Rule]
 
           @args: Array[Lexer::Token]
-          @token: Lexer::Token::Parameterizing
+          @token: Lexer::Token::InstantiateRule
           @key: Symbol
           @rule_counter: Counter
           @lhs_tag: untyped

data/sig/lrama/grammar/parameterizing_rules/builder.rbs

@@ -4,7 +4,7 @@ module Lrama
       class Builder
         RULES: Hash[Symbol, singleton(Base)]
 
-        @token: Lexer::Token::Parameterizing
+        @token: Lexer::Token::InstantiateRule
         @key: Symbol
         @rule_counter: Counter
         @lhs_tag: untyped

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,20 +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: () -> void
-      def parameterizing_rules: () -> Array[Rule]
-      def midrule_action_rules: () -> Array[Rule]
+      def setup_rules: (Grammar::ParameterizingRule::Resolver parameterizing_rule_resolver) -> void
       def rules: () -> Array[Rule]
 
       private
@@ -34,7 +34,8 @@ module Lrama
       def freeze_rhs: () -> void
       def preprocess_references: () -> void
       def build_rules: () -> void
-      def process_rhs: () -> 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/grammar_file.rbs

@@ -0,0 +1,15 @@
+module Lrama
+  class Lexer
+    class GrammarFile
+      attr_reader path: String
+      attr_reader text: String
+
+      @lines: Array[String]
+
+      def initialize: (String path, String text) -> void
+
+      def ==: (GrammarFile other) -> bool
+      def lines: () -> Array[String]
+    end
+  end
+end

data/sig/lrama/lexer/location.rbs

@@ -1,14 +1,26 @@
 module Lrama
   class Lexer
     class Location
+      attr_reader grammar_file: GrammarFile
       attr_reader first_line: Integer
       attr_reader first_column: Integer
       attr_reader last_line: Integer
       attr_reader last_column: Integer
 
-      def initialize: (first_line: Integer, first_column: Integer, last_line: Integer, last_column: Integer) -> void
+      def initialize: (grammar_file: GrammarFile, first_line: Integer, first_column: Integer, last_line: Integer, last_column: Integer) -> void
 
       def ==: (Location other) -> bool
+      def partial_location: (Integer, Integer) -> Location
+      def generate_error_message: (String) -> String
+      def line_with_carets: () -> String
+
+      private
+
+      def path: () -> String
+      def blanks: () -> String
+      def carets: () -> String
+      def text: () -> String
+      def _text: () -> Array[String]
     end
   end
 end

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

@@ -0,0 +1,14 @@
+module Lrama
+  class Lexer
+    class Token
+      class InstantiateRule < 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], ?lhs_tag: Lexer::Token::Tag?) -> void
+        def rule_name: () -> String
+        def args_count: () -> Integer
+      end
+    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.5.12
+  version: 0.6.1
 platform: ruby
 authors:
 - Yuichiro Kaneko
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-12-07 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
@@ -55,6 +56,10 @@ files:
 - lib/lrama/grammar/code/rule_action.rb
 - lib/lrama/grammar/counter.rb
 - lib/lrama/grammar/error_token.rb
+- lib/lrama/grammar/parameterizing_rule.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
@@ -72,11 +77,12 @@ files:
 - lib/lrama/grammar/type.rb
 - lib/lrama/grammar/union.rb
 - lib/lrama/lexer.rb
+- lib/lrama/lexer/grammar_file.rb
 - lib/lrama/lexer/location.rb
 - lib/lrama/lexer/token.rb
 - lib/lrama/lexer/token/char.rb
 - lib/lrama/lexer/token/ident.rb
-- lib/lrama/lexer/token/parameterizing.rb
+- lib/lrama/lexer/token/instantiate_rule.rb
 - lib/lrama/lexer/token/tag.rb
 - lib/lrama/lexer/token/user_code.rb
 - lib/lrama/option_parser.rb
@@ -107,10 +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/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
@@ -125,11 +136,12 @@ files:
 - sig/lrama/grammar/rule.rbs
 - sig/lrama/grammar/rule_builder.rbs
 - sig/lrama/grammar/symbol.rbs
+- sig/lrama/lexer/grammar_file.rbs
 - sig/lrama/lexer/location.rbs
 - sig/lrama/lexer/token.rbs
 - sig/lrama/lexer/token/char.rbs
 - sig/lrama/lexer/token/ident.rbs
-- sig/lrama/lexer/token/parameterizing.rbs
+- sig/lrama/lexer/token/instantiate_rule.rbs
 - sig/lrama/lexer/token/tag.rbs
 - sig/lrama/lexer/token/user_code.rbs
 - sig/lrama/report/duration.rbs
@@ -158,7 +170,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.0.dev
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: LALR (1) parser generator written by Ruby

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

@@ -1,34 +0,0 @@
-module Lrama
-  class Lexer
-    class Token
-      class Parameterizing < Token
-        attr_accessor :args
-
-        def initialize(s_value:, alias_name: nil, location: nil, args: [])
-          super s_value: s_value, alias_name: alias_name, location: location
-          @args = args
-        end
-
-        def option?
-          %w(option ?).include?(self.s_value)
-        end
-
-        def nonempty_list?
-          %w(nonempty_list +).include?(self.s_value)
-        end
-
-        def list?
-          %w(list *).include?(self.s_value)
-        end
-
-        def separated_nonempty_list?
-          %w(separated_nonempty_list).include?(self.s_value)
-        end
-
-        def separated_list?
-          %w(separated_list).include?(self.s_value)
-        end
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-module Lrama
-  class Lexer
-    class Token
-      class Parameterizing < Token
-        attr_accessor args: Array[Lexer::Token]
-
-        def initialize: (s_value: String, ?alias_name: String, ?location: Location, ?args: Array[Lexer::Token]) -> void
-
-        def option?: () -> bool
-        def nonempty_list?: () -> bool
-        def list?: () -> bool
-        def separated_nonempty_list?: () -> bool
-        def separated_list?: () -> bool
-      end
-    end
-  end
-end