lrama 0.5.9 → 0.5.10

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

@@ -0,0 +1,28 @@
+module Lrama
+  class Grammar
+    class ParameterizingRules
+      class Builder
+        class SeparatedList < Base
+          def initialize(token, rule_counter, lhs, user_code, precedence_sym, line)
+            super
+            @separator = @args[0]
+            @token = @args[1]
+            @expected_argument_num = 2
+          end
+
+          def build
+            validate_argument_number!
+
+            rules = []
+            separated_list_token = Lrama::Lexer::Token::Ident.new(s_value: "separated_list_#{@token.s_value}")
+            rules << Rule.new(id: @rule_counter.increment, _lhs: @lhs, _rhs: [separated_list_token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules << Rule.new(id: @rule_counter.increment, _lhs: separated_list_token, _rhs: [], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules << Rule.new(id: @rule_counter.increment, _lhs: separated_list_token, _rhs: [@token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules << Rule.new(id: @rule_counter.increment, _lhs: separated_list_token, _rhs: [separated_list_token, @separator, @token], 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,27 @@
+module Lrama
+  class Grammar
+    class ParameterizingRules
+      class Builder
+        class SeparatedNonemptyList < Base
+          def initialize(token, rule_counter, lhs, user_code, precedence_sym, line)
+            super
+            @separator = @args[0]
+            @token = @args[1]
+            @expected_argument_num = 2
+          end
+
+          def build
+            validate_argument_number!
+
+            rules = []
+            separated_list_token = Lrama::Lexer::Token::Ident.new(s_value: "separated_nonempty_list_#{@token.s_value}")
+            rules << Rule.new(id: @rule_counter.increment, _lhs: @lhs, _rhs: [separated_list_token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules << Rule.new(id: @rule_counter.increment, _lhs: separated_list_token, _rhs: [@token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules << Rule.new(id: @rule_counter.increment, _lhs: separated_list_token, _rhs: [separated_list_token, @separator, @token], 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,43 @@
+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
+      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, user_code, precedence_sym, line)
+          @token = token
+          @key = token.s_value.to_sym
+          @rule_counter = rule_counter
+          @lhs = lhs
+          @user_code = user_code
+          @precedence_sym = precedence_sym
+          @line = line
+        end
+
+        def build
+          if RULES.key?(@key)
+            RULES[@key].new(@token, @rule_counter, @lhs, @user_code, @precedence_sym, @line).build
+          else
+            raise "Parameterizing rule does not exist. `#{@key}`"
+          end
+        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,20 @@
 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, :_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.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 +46,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,179 @@
+require 'lrama/grammar/parameterizing_rules/builder'
+
+module Lrama
+  class Grammar
+    class RuleBuilder
+      attr_accessor :lhs, :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 = []
+        @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
+
+        # Expand Parameterizing rules
+        if tokens.any? {|r| r.is_a?(Lrama::Lexer::Token::Parameterizing) }
+          @rules = @parameterizing_rules
+          @midrule_action_rules = []
+        else
+          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
+      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_rules = ParameterizingRules::Builder.new(token, @rule_counter, lhs, user_code, precedence_sym, line).build
+            @replaced_rhs << 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