lrama 0.5.9 → 0.5.11

data/lib/lrama/grammar/parameterizing_rules/builder/nonempty_list.rb

@@ -0,0 +1,28 @@
+module Lrama
+  class Grammar
+    class ParameterizingRules
+      class Builder
+        # Builder for nonempty list of general parameterizing rules
+        class NonemptyList < Base
+
+          # program: nonempty_list(number)
+          #
+          # =>
+          #
+          # program: nonempty_list_number
+          # nonempty_list_number: number
+          # nonempty_list_number: nonempty_list_number number
+          def build
+            validate_argument_number!
+
+            rules = []
+            @build_token = Lrama::Lexer::Token::Ident.new(s_value: "nonempty_list_#{@token.s_value}")
+            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [@token], lhs_tag: @lhs_tag, token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [@build_token, @token], lhs_tag: @lhs_tag, token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lrama/grammar/parameterizing_rules/builder/option.rb

@@ -0,0 +1,28 @@
+module Lrama
+  class Grammar
+    class ParameterizingRules
+      class Builder
+        # Builder for option of general parameterizing rules
+        class Option < Base
+
+          # program: option(number)
+          #
+          # =>
+          #
+          # program: option_number
+          # option_number: ε
+          # option_number: number
+          def build
+            validate_argument_number!
+
+            rules = []
+            @build_token = Lrama::Lexer::Token::Ident.new(s_value: "option_#{@token.s_value}")
+            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [], lhs_tag: @lhs_tag, token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [@token], lhs_tag: @lhs_tag, token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lrama/grammar/parameterizing_rules/builder/separated_list.rb

@@ -0,0 +1,39 @@
+module Lrama
+  class Grammar
+    class ParameterizingRules
+      class Builder
+        # Builder for separated list of general parameterizing rules
+        class SeparatedList < Base
+          def initialize(token, rule_counter, lhs_tag, user_code, precedence_sym, line)
+            super
+            @separator = @args[0]
+            @token = @args[1]
+            @expected_argument_num = 2
+          end
+
+          # program: separated_list(',', number)
+          #
+          # =>
+          #
+          # program: separated_list_number
+          # separated_list_number: ε
+          # separated_list_number: separated_nonempty_list_number
+          # separated_nonempty_list_number: number
+          # separated_nonempty_list_number: separated_nonempty_list_number ',' number
+          def build
+            validate_argument_number!
+
+            rules = []
+            @build_token = Lrama::Lexer::Token::Ident.new(s_value: "separated_list_#{@token.s_value}")
+            separated_nonempty_list_token = Lrama::Lexer::Token::Ident.new(s_value: "separated_nonempty_list_#{@token.s_value}")
+            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [], lhs_tag: @lhs_tag, token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [separated_nonempty_list_token], lhs_tag: @lhs_tag, token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules << Rule.new(id: @rule_counter.increment, _lhs: separated_nonempty_list_token, _rhs: [@token], lhs_tag: @lhs_tag, token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules << Rule.new(id: @rule_counter.increment, _lhs: separated_nonempty_list_token, _rhs: [separated_nonempty_list_token, @separator, @token], lhs_tag: @lhs_tag, token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lrama/grammar/parameterizing_rules/builder/separated_nonempty_list.rb

@@ -0,0 +1,34 @@
+module Lrama
+  class Grammar
+    class ParameterizingRules
+      class Builder
+        # Builder for separated nonempty list of general parameterizing rules
+        class SeparatedNonemptyList < Base
+          def initialize(token, rule_counter, lhs_tag, user_code, precedence_sym, line)
+            super
+            @separator = @args[0]
+            @token = @args[1]
+            @expected_argument_num = 2
+          end
+
+          # program: separated_nonempty_list(',', number)
+          #
+          # =>
+          #
+          # program: separated_nonempty_list_number
+          # separated_nonempty_list_number: number
+          # separated_nonempty_list_number: separated_nonempty_list_number ',' number
+          def build
+            validate_argument_number!
+
+            rules = []
+            @build_token = Lrama::Lexer::Token::Ident.new(s_value: "separated_nonempty_list_#{@token.s_value}")
+            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [@token], lhs_tag: @lhs_tag, token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules << Rule.new(id: @rule_counter.increment, _lhs: @build_token, _rhs: [@build_token, @separator, @token], lhs_tag: @lhs_tag, token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lrama/grammar/parameterizing_rules/builder.rb

@@ -0,0 +1,60 @@
+require 'lrama/grammar/parameterizing_rules/builder/base'
+require 'lrama/grammar/parameterizing_rules/builder/list'
+require 'lrama/grammar/parameterizing_rules/builder/nonempty_list'
+require 'lrama/grammar/parameterizing_rules/builder/option'
+require 'lrama/grammar/parameterizing_rules/builder/separated_nonempty_list'
+require 'lrama/grammar/parameterizing_rules/builder/separated_list'
+
+module Lrama
+  class Grammar
+    class ParameterizingRules
+      # Builder for parameterizing rules
+      class Builder
+        RULES = {
+          option: Lrama::Grammar::ParameterizingRules::Builder::Option,
+          "?": Lrama::Grammar::ParameterizingRules::Builder::Option,
+          nonempty_list: Lrama::Grammar::ParameterizingRules::Builder::NonemptyList,
+          "+": Lrama::Grammar::ParameterizingRules::Builder::NonemptyList,
+          list: Lrama::Grammar::ParameterizingRules::Builder::List,
+          "*": Lrama::Grammar::ParameterizingRules::Builder::List,
+          separated_nonempty_list: Lrama::Grammar::ParameterizingRules::Builder::SeparatedNonemptyList,
+          separated_list: Lrama::Grammar::ParameterizingRules::Builder::SeparatedList,
+        }
+
+        def initialize(token, rule_counter, lhs_tag, user_code, precedence_sym, line)
+          @token = token
+          @key = token.s_value.to_sym
+          @rule_counter = rule_counter
+          @lhs_tag = lhs_tag
+          @user_code = user_code
+          @precedence_sym = precedence_sym
+          @line = line
+          @builder = nil
+        end
+
+        def build
+          create_builder
+          @builder.build
+        end
+
+        def build_token
+          create_builder
+          @builder.build_token
+        end
+
+        private
+
+        def create_builder
+          unless @builder
+            validate_key!
+            @builder = RULES[@key].new(@token, @rule_counter, @lhs_tag, @user_code, @precedence_sym, @line)
+          end
+        end
+
+        def validate_key!
+          raise "Parameterizing rule does not exist. `#{@key}`" unless RULES.key?(@key)
+        end
+      end
+    end
+  end
+end

data/lib/lrama/grammar/printer.rb

@@ -1,8 +1,8 @@
 module Lrama
   class Grammar
-    class Printer < Struct.new(:ident_or_tags, :code, :lineno, keyword_init: true)
-      def translated_code(member)
-        code.translated_printer_code(member)
+    class Printer < Struct.new(:ident_or_tags, :token_code, :lineno, keyword_init: true)
+      def translated_code(tag)
+        Code::PrinterCode.new(type: :printer, token_code: token_code, tag: tag).translated_code
       end
     end
   end

data/lib/lrama/grammar/reference.rb

@@ -1,21 +1,12 @@
-# type: :dollar or :at
-# ex_tag: "$<tag>1" (Optional)
-
 module Lrama
   class Grammar
-    class Reference < Struct.new(:type, :value, :ex_tag, :first_column, :last_column, :referring_symbol, :position_in_rhs, keyword_init: true)
-      def tag
-        if ex_tag
-          ex_tag
-        else
-          # FIXME: Remove this class check
-          if referring_symbol.is_a?(Symbol)
-            referring_symbol.tag
-          else
-            # Lrama::Lexer::Token (User_code) case
-            nil
-          end
-        end
+    # type: :dollar or :at
+    # name: String (e.g. $$, $foo, $expr.right)
+    # index: Integer (e.g. $1)
+    # ex_tag: "$<tag>1" (Optional)
+    class Reference < Struct.new(:type, :name, :index, :ex_tag, :first_column, :last_column, keyword_init: true)
+      def value
+        name || index
       end
     end
   end

data/lib/lrama/grammar/rule.rb

@@ -1,6 +1,21 @@
 module Lrama
   class Grammar
-    class Rule < Struct.new(:id, :lhs, :rhs, :code, :nullable, :precedence_sym, :lineno, keyword_init: true)
+    # _rhs holds original RHS element. Use rhs to refer to Symbol.
+    class Rule < Struct.new(:id, :_lhs, :lhs, :lhs_tag, :_rhs, :rhs, :token_code, :position_in_original_rule_rhs, :nullable, :precedence_sym, :lineno, keyword_init: true)
+      attr_accessor :original_rule
+
+      def ==(other)
+        self.class == other.class &&
+        self.lhs == other.lhs &&
+        self.lhs_tag == other.lhs_tag &&
+        self.rhs == other.rhs &&
+        self.token_code == other.token_code &&
+        self.position_in_original_rule_rhs == other.position_in_original_rule_rhs &&
+        self.nullable == other.nullable &&
+        self.precedence_sym == other.precedence_sym &&
+        self.lineno == other.lineno
+      end
+
       # TODO: Change this to display_name
       def to_s
         l = lhs.id.s_value
@@ -32,7 +47,9 @@ module Lrama
       end
 
       def translated_code
-        code&.translated_code
+        return nil unless token_code
+
+        Code::RuleAction.new(type: :rule_action, token_code: token_code, rule: self).translated_code
       end
     end
   end

data/lib/lrama/grammar/rule_builder.rb

@@ -0,0 +1,177 @@
+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
+
+      def initialize(rule_counter, midrule_action_counter, position_in_original_rule_rhs = 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
+        @rhs = []
+        @lhs_tag = nil
+        @user_code = nil
+        @precedence_sym = nil
+        @line = nil
+        @rule_builders_for_derived_rules = []
+      end
+
+      def add_rhs(rhs)
+        if !@line
+          @line = rhs.line
+        end
+
+        flush_user_code
+
+        @rhs << rhs
+      end
+
+      def user_code=(user_code)
+        if !@line
+          @line = user_code.line
+        end
+
+        flush_user_code
+
+        @user_code = user_code
+      end
+
+      def precedence_sym=(precedence_sym)
+        flush_user_code
+
+        @precedence_sym = precedence_sym
+      end
+
+      def complete_input
+        freeze_rhs
+      end
+
+      def setup_rules
+        preprocess_references unless @skip_preprocess_references
+        process_rhs
+        build_rules
+      end
+
+      def parameterizing_rules
+        @parameterizing_rules
+      end
+
+      def midrule_action_rules
+        @midrule_action_rules
+      end
+
+      def rules
+        @rules
+      end
+
+      private
+
+      def freeze_rhs
+        @rhs.freeze
+      end
+
+      def preprocess_references
+        numberize_references
+      end
+
+      def build_rules
+        tokens = @replaced_rhs
+
+        rule = Rule.new(
+          id: @rule_counter.increment, _lhs: lhs, _rhs: tokens, token_code: user_code,
+          position_in_original_rule_rhs: @position_in_original_rule_rhs, precedence_sym: precedence_sym, lineno: line
+        )
+        @rules = [rule]
+        @midrule_action_rules = @rule_builders_for_derived_rules.map do |rule_builder|
+          rule_builder.rules
+        end.flatten
+        @midrule_action_rules.each do |r|
+          r.original_rule = rule
+        end
+      end
+
+      # rhs is a mixture of variety type of tokens like `Ident`, `Parameterizing`, `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
+        return if @replaced_rhs
+
+        @replaced_rhs = []
+        @parameterizing_rules = []
+
+        rhs.each_with_index do |token, i|
+          case token
+          when Lrama::Lexer::Token::Char
+            @replaced_rhs << token
+          when Lrama::Lexer::Token::Ident
+            @replaced_rhs << token
+          when Lrama::Lexer::Token::Parameterizing
+            parameterizing = ParameterizingRules::Builder.new(token, @rule_counter, @lhs_tag, user_code, precedence_sym, line)
+            parameterizing.build.each do |r|
+              @parameterizing_rules << r
+            end
+            @replaced_rhs << parameterizing.build_token
+          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.lhs = new_token
+            rule_builder.user_code = token
+            rule_builder.complete_input
+            rule_builder.setup_rules
+
+            @rule_builders_for_derived_rules << rule_builder
+          else
+            raise "Unexpected token. #{token}"
+          end
+        end
+      end
+
+      def numberize_references
+        # Bison n'th component is 1-origin
+        (rhs + [user_code]).compact.each.with_index(1) do |token, i|
+          next unless token.is_a?(Lrama::Lexer::Token::UserCode)
+
+          token.references.each do |ref|
+            ref_name = ref.name
+            if ref_name && ref_name != '$'
+              if lhs.referred_by?(ref_name)
+                ref.name = '$'
+              else
+                candidates = rhs.each_with_index.select {|token, i| token.referred_by?(ref_name) }
+
+                raise "Referring symbol `#{ref_name}` is duplicated. #{token}" if candidates.size >= 2
+                raise "Referring symbol `#{ref_name}` is not found. #{token}" unless referring_symbol = candidates.first
+
+                ref.index = referring_symbol[1] + 1
+              end
+            end
+
+            # TODO: Need to check index of @ too?
+            next if ref.type == :at
+
+            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
+              rhs[ref.index - 1].referred = true
+            end
+          end
+        end
+      end
+
+      def flush_user_code
+        if c = @user_code
+          @rhs << c
+          @user_code = nil
+        end
+      end
+    end
+  end
+end

data/lib/lrama/grammar/symbol.rb

@@ -6,10 +6,23 @@
 
 module Lrama
   class Grammar
-    class Symbol < Struct.new(:id, :alias_name, :number, :tag, :term, :token_id, :nullable, :precedence, :printer, :error_token, keyword_init: true)
-      attr_accessor :first_set, :first_set_bitmap
+    class Symbol
+      attr_accessor :id, :alias_name, :tag, :number, :token_id, :nullable, :precedence, :printer, :error_token, :first_set, :first_set_bitmap
+      attr_reader :term
       attr_writer :eof_symbol, :error_symbol, :undef_symbol, :accept_symbol
 
+      def initialize(id:, alias_name: nil, number: nil, tag: nil, term:, token_id: nil, nullable: nil, precedence: nil, printer: nil)
+        @id = id
+        @alias_name = alias_name
+        @number = number
+        @tag = tag
+        @term = term
+        @token_id = token_id
+        @nullable = nullable
+        @precedence = precedence
+        @printer = printer
+      end
+
       def term?
         term
       end
@@ -41,6 +54,7 @@ module Lrama
       # name for yysymbol_kind_t
       #
       # See: b4_symbol_kind_base
+      # @type var name: String
       def enum_name
         case
         when accept_symbol?

data/lib/lrama/grammar/type.rb

@@ -0,0 +1,6 @@
+module Lrama
+  class Grammar
+    class Type < Struct.new(:id, :tag, keyword_init: true)
+    end
+  end
+end