lrama 0.5.12 → 0.6.1

data/lib/lrama/grammar/rule_builder.rb

@@ -3,21 +3,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 +34,7 @@ module Lrama
 
       def user_code=(user_code)
         if !@line
-          @line = user_code.line
+          @line = user_code&.line
         end
 
         flush_user_code
@@ -51,22 +52,14 @@ module Lrama
         freeze_rhs
       end
 
-      def setup_rules
+      def setup_rules(parameterizing_rule_resolver)
         preprocess_references unless @skip_preprocess_references
-        process_rhs
+        process_rhs(parameterizing_rule_resolver)
         build_rules
       end
 
-      def parameterizing_rules
-        @parameterizing_rules
-      end
-
-      def midrule_action_rules
-        @midrule_action_rules
-      end
-
       def rules
-        @rules
+        @parameterizing_rules + @old_parameterizing_rules + @midrule_action_rules + @rules
       end
 
       private
@@ -83,10 +76,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
@@ -95,13 +91,13 @@ module Lrama
         end
       end
 
-      # rhs is a mixture of variety type of tokens like `Ident`, `Parameterizing`, `UserCode` and so on.
+      # 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
+      def process_rhs(parameterizing_rule_resolver)
         return if @replaced_rhs
 
         @replaced_rhs = []
-        @parameterizing_rules = []
+        @old_parameterizing_rules = []
 
         rhs.each_with_index do |token, i|
           case token
@@ -109,22 +105,47 @@ module Lrama
             @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
+          when Lrama::Lexer::Token::InstantiateRule
+            if parameterizing_rule_resolver.defined?(token)
+              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
+                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
+            else
+              # TODO: Delete when the standard library will defined as a grammar file.
+              parameterizing_rule = ParameterizingRules::Builder.new(token, @rule_counter, token.lhs_tag, user_code, precedence_sym, line)
+              @old_parameterizing_rules = @old_parameterizing_rules + parameterizing_rule.build
+              @replaced_rhs << parameterizing_rule.build_token
             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 = 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
+            rule_builder.setup_rules(parameterizing_rule_resolver)
 
             @rule_builders_for_derived_rules << rule_builder
           else
@@ -133,6 +154,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|
@@ -146,8 +179,13 @@ module Lrama
               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
+                if candidates.size >= 2
+                  token.invalid_ref(ref, "Referring symbol `#{ref_name}` is duplicated.")
+                end
+
+                unless (referring_symbol = candidates.first)
+                  token.invalid_ref(ref, "Referring symbol `#{ref_name}` is not found.")
+                end
 
                 ref.index = referring_symbol[1] + 1
               end
@@ -159,7 +197,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
@@ -167,7 +205,7 @@ module Lrama
       end
 
       def flush_user_code
-        if c = @user_code
+        if (c = @user_code)
           @rhs << c
           @user_code = nil
         end

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,6 +9,7 @@ require "lrama/grammar/printer"
 require "lrama/grammar/reference"
 require "lrama/grammar/rule"
 require "lrama/grammar/rule_builder"
+require "lrama/grammar/parameterizing_rule"
 require "lrama/grammar/symbol"
 require "lrama/grammar/type"
 require "lrama/grammar/union"
@@ -36,6 +38,7 @@ module Lrama
       @rule_builders = []
       @rules = []
       @sym_to_rules = {}
+      @parameterizing_rule_resolver = ParameterizingRule::Resolver.new
       @empty_symbol = nil
       @eof_symbol = nil
       @error_symbol = nil
@@ -47,7 +50,7 @@ module Lrama
     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:)
@@ -69,7 +72,7 @@ module Lrama
         return sym
       end
 
-      if sym = @symbols.find {|s| s.id == id }
+      if (sym = @symbols.find {|s| s.id == id })
         return sym
       end
 
@@ -129,6 +132,10 @@ module Lrama
       @rule_builders << builder
     end
 
+    def add_parameterizing_rule(rule)
+      @parameterizing_rule_resolver.add_parameterizing_rule(rule)
+    end
+
     def prologue_first_lineno=(prologue_first_lineno)
       @aux.prologue_first_lineno = prologue_first_lineno
     end
@@ -162,7 +169,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!
@@ -310,7 +317,7 @@ module Lrama
 
     def setup_rules
       @rule_builders.each do |builder|
-        builder.setup_rules
+        builder.setup_rules(@parameterizing_rule_resolver)
       end
     end
 
@@ -350,56 +357,21 @@ module Lrama
       @accept_symbol = term
     end
 
-    # 1. Add $accept rule to the top of rules
-    # 2. Extract action in the middle of RHS into new Empty rule
-    # 3. Append id and extract action then create Rule
-    #
-    # Bison 3.8.2 uses different orders for symbol number and rule number
-    # when a rule has actions in the middle of a rule.
-    #
-    # For example,
-    #
-    # `program: $@1 top_compstmt`
-    #
-    # Rules are ordered like below,
-    #
-    # 1 $@1: ε
-    # 2 program: $@1 top_compstmt
-    #
-    # Symbols are ordered like below,
-    #
-    # 164 program
-    # 165 $@1
-    #
     def normalize_rules
-      # 1. Add $accept rule to the top of rules
-      accept = @accept_symbol
-      eof = @eof_symbol
+      # Add $accept rule to the top of rules
       lineno = @rule_builders.first ? @rule_builders.first.line : 0
-      @rules << Rule.new(id: @rule_counter.increment, _lhs: accept.id, _rhs: [@rule_builders.first.lhs, eof.id], token_code: nil, lineno: lineno)
+      @rules << Rule.new(id: @rule_counter.increment, _lhs: @accept_symbol.id, _rhs: [@rule_builders.first.lhs, @eof_symbol.id], token_code: nil, lineno: lineno)
 
       setup_rules
 
       @rule_builders.each do |builder|
-        # Extract actions in the middle of RHS into new rules.
-        builder.midrule_action_rules.each do |rule|
-          @rules << rule
-        end
-
         builder.rules.each do |rule|
-          add_nterm(id: rule._lhs)
-          @rules << rule
-        end
-
-        builder.parameterizing_rules.each do |rule|
           add_nterm(id: rule._lhs, tag: rule.lhs_tag)
           @rules << rule
         end
-
-        builder.midrule_action_rules.each do |rule|
-          add_nterm(id: rule._lhs)
-        end
       end
+
+      @rules.sort_by!(&:id)
     end
 
     # Collect symbols from rules

data/lib/lrama/lexer/grammar_file.rb

@@ -0,0 +1,21 @@
+module Lrama
+  class Lexer
+    class GrammarFile
+      attr_reader :path, :text
+
+      def initialize(path, text)
+        @path = path
+        @text = text.freeze
+      end
+
+      def ==(other)
+        self.class == other.class &&
+        self.path == other.path
+      end
+
+      def lines
+        @lines ||= text.split("\n")
+      end
+    end
+  end
+end

data/lib/lrama/lexer/location.rb

@@ -1,9 +1,10 @@
 module Lrama
   class Lexer
     class Location
-      attr_reader :first_line, :first_column, :last_line, :last_column
+      attr_reader :grammar_file, :first_line, :first_column, :last_line, :last_column
 
-      def initialize(first_line:, first_column:, last_line:, last_column:)
+      def initialize(grammar_file:, first_line:, first_column:, last_line:, last_column:)
+        @grammar_file = grammar_file
         @first_line = first_line
         @first_column = first_column
         @last_line = last_line
@@ -12,11 +13,85 @@ module Lrama
 
       def ==(other)
         self.class == other.class &&
+        self.grammar_file == other.grammar_file &&
         self.first_line == other.first_line &&
         self.first_column == other.first_column &&
         self.last_line == other.last_line &&
         self.last_column == other.last_column
       end
+
+      def partial_location(left, right)
+        offset = -first_column
+        new_first_line = -1
+        new_first_column = -1
+        new_last_line = -1
+        new_last_column = -1
+
+        _text.each.with_index do |line, index|
+          new_offset = offset + line.length + 1
+
+          if offset <= left && left <= new_offset
+            new_first_line = first_line + index
+            new_first_column = left - offset
+          end
+
+          if offset <= right && right <= new_offset
+            new_last_line = first_line + index
+            new_last_column = right - offset
+          end
+
+          offset = new_offset
+        end
+
+        Location.new(
+          grammar_file: grammar_file,
+          first_line: new_first_line, first_column: new_first_column,
+          last_line: new_last_line, last_column: new_last_column
+        )
+      end
+
+      def to_s
+        "#{path} (#{first_line},#{first_column})-(#{last_line},#{last_column})"
+      end
+
+      def generate_error_message(error_message)
+        <<~ERROR.chomp
+          #{path}:#{first_line}:#{first_column}: #{error_message}
+          #{line_with_carets}
+        ERROR
+      end
+
+      def line_with_carets
+        <<~TEXT
+          #{text}
+          #{carets}
+        TEXT
+      end
+
+      private
+
+      def path
+        grammar_file.path
+      end
+
+      def blanks
+        (text[0...first_column] or raise "#{first_column} is invalid").gsub(/[^\t]/, ' ')
+      end
+
+      def carets
+        blanks + '^' * (last_column - first_column)
+      end
+
+      def text
+        @text ||= _text.join("\n")
+      end
+
+      def _text
+        @_text ||=begin
+          range = (first_line - 1)...last_line
+          grammar_file.lines[range] or raise "#{range} is invalid"
+        end
+      end
     end
   end
 end

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

@@ -0,0 +1,23 @@
+module Lrama
+  class Lexer
+    class Token
+      class InstantiateRule < Token
+        attr_reader :args, :lhs_tag
+
+        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
+end

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

@@ -35,27 +35,27 @@ module Lrama
           # It need to wrap an identifier with brackets to use ".-" for identifiers
           when scanner.scan(/\$(<[a-zA-Z0-9_]+>)?\$/) # $$, $<long>$
             tag = scanner[1] ? Lrama::Lexer::Token::Tag.new(s_value: scanner[1]) : nil
-            return Lrama::Grammar::Reference.new(type: :dollar, name: "$", ex_tag: tag, first_column: start, last_column: scanner.pos - 1)
+            return Lrama::Grammar::Reference.new(type: :dollar, name: "$", ex_tag: tag, first_column: start, last_column: scanner.pos)
           when scanner.scan(/\$(<[a-zA-Z0-9_]+>)?(\d+)/) # $1, $2, $<long>1
             tag = scanner[1] ? Lrama::Lexer::Token::Tag.new(s_value: scanner[1]) : nil
-            return Lrama::Grammar::Reference.new(type: :dollar, index: Integer(scanner[2]), ex_tag: tag, first_column: start, last_column: scanner.pos - 1)
+            return Lrama::Grammar::Reference.new(type: :dollar, index: Integer(scanner[2]), ex_tag: tag, first_column: start, last_column: scanner.pos)
           when scanner.scan(/\$(<[a-zA-Z0-9_]+>)?([a-zA-Z_][a-zA-Z0-9_]*)/) # $foo, $expr, $<long>program (named reference without brackets)
             tag = scanner[1] ? Lrama::Lexer::Token::Tag.new(s_value: scanner[1]) : nil
-            return Lrama::Grammar::Reference.new(type: :dollar, name: scanner[2], ex_tag: tag, first_column: start, last_column: scanner.pos - 1)
-          when scanner.scan(/\$(<[a-zA-Z0-9_]+>)?\[([a-zA-Z_.][-a-zA-Z0-9_.]*)\]/) # $expr.right, $expr-right, $<long>program (named reference with brackets)
+            return Lrama::Grammar::Reference.new(type: :dollar, name: scanner[2], ex_tag: tag, first_column: start, last_column: scanner.pos)
+          when scanner.scan(/\$(<[a-zA-Z0-9_]+>)?\[([a-zA-Z_.][-a-zA-Z0-9_.]*)\]/) # $[expr.right], $[expr-right], $<long>[expr.right] (named reference with brackets)
             tag = scanner[1] ? Lrama::Lexer::Token::Tag.new(s_value: scanner[1]) : nil
-            return Lrama::Grammar::Reference.new(type: :dollar, name: scanner[2], ex_tag: tag, first_column: start, last_column: scanner.pos - 1)
+            return Lrama::Grammar::Reference.new(type: :dollar, name: scanner[2], ex_tag: tag, first_column: start, last_column: scanner.pos)
 
           # @ references
           # It need to wrap an identifier with brackets to use ".-" for identifiers
           when scanner.scan(/@\$/) # @$
-            return Lrama::Grammar::Reference.new(type: :at, name: "$", first_column: start, last_column: scanner.pos - 1)
+            return Lrama::Grammar::Reference.new(type: :at, name: "$", first_column: start, last_column: scanner.pos)
           when scanner.scan(/@(\d+)/) # @1
-            return Lrama::Grammar::Reference.new(type: :at, index: Integer(scanner[1]), first_column: start, last_column: scanner.pos - 1)
+            return Lrama::Grammar::Reference.new(type: :at, index: Integer(scanner[1]), first_column: start, last_column: scanner.pos)
           when scanner.scan(/@([a-zA-Z][a-zA-Z0-9_]*)/) # @foo, @expr (named reference without brackets)
-            return Lrama::Grammar::Reference.new(type: :at, name: scanner[1], first_column: start, last_column: scanner.pos - 1)
-          when scanner.scan(/@\[([a-zA-Z_.][-a-zA-Z0-9_.]*)\]/) # @expr.right, @expr-right  (named reference with brackets)
-            return Lrama::Grammar::Reference.new(type: :at, name: scanner[1], first_column: start, last_column: scanner.pos - 1)
+            return Lrama::Grammar::Reference.new(type: :at, name: scanner[1], first_column: start, last_column: scanner.pos)
+          when scanner.scan(/@\[([a-zA-Z_.][-a-zA-Z0-9_.]*)\]/) # @[expr.right], @[expr-right]  (named reference with brackets)
+            return Lrama::Grammar::Reference.new(type: :at, name: scanner[1], first_column: start, last_column: scanner.pos)
           end
         end
       end

data/lib/lrama/lexer/token.rb

@@ -1,6 +1,6 @@
 require 'lrama/lexer/token/char'
 require 'lrama/lexer/token/ident'
-require 'lrama/lexer/token/parameterizing'
+require 'lrama/lexer/token/instantiate_rule'
 require 'lrama/lexer/token/tag'
 require 'lrama/lexer/token/user_code'
 
@@ -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

@@ -1,12 +1,12 @@
 require "strscan"
+require "lrama/lexer/grammar_file"
 require "lrama/lexer/location"
 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(
@@ -28,10 +28,12 @@ module Lrama
       %error-token
       %empty
       %code
+      %rule
     )
 
-    def initialize(text)
-      @scanner = StringScanner.new(text)
+    def initialize(grammar_file)
+      @grammar_file = grammar_file
+      @scanner = StringScanner.new(grammar_file.text)
       @head_column = @head = @scanner.pos
       @head_line = @line = 1
       @status = :initial
@@ -47,18 +49,15 @@ module Lrama
       end
     end
 
-    def line
-      @line
-    end
-
     def column
       @scanner.pos - @head
     end
 
     def location
       Location.new(
+        grammar_file: @grammar_file,
         first_line: @head_line, first_column: @head_column,
-        last_line: @line, last_column: column
+        last_line: line, last_column: column
       )
     end
 
@@ -78,8 +77,7 @@ module Lrama
         end
       end
 
-      @head_line = line
-      @head_column = column
+      reset_first_position
 
       case
       when @scanner.eos?
@@ -117,6 +115,8 @@ module Lrama
     def lex_c_code
       nested = 0
       code = ''
+      reset_first_position
+
       while !@scanner.eos? do
         case
         when @scanner.scan(/{/)
@@ -140,12 +140,12 @@ module Lrama
           @line += @scanner.matched.count("\n")
         when @scanner.scan(/'.*?'/)
           code += %Q(#{@scanner.matched})
+        when @scanner.scan(/[^\"'\{\}\n]+/)
+          code += @scanner.matched
+        when @scanner.scan(/#{Regexp.escape(@end_symbol)}/)
+          code += @scanner.matched
         else
-          if @scanner.scan(/[^\"'\{\}\n#{@end_symbol}]+/)
-            code += @scanner.matched
-          else
-            code += @scanner.getch
-          end
+          code += @scanner.getch
         end
       end
       raise ParseError, "Unexpected code: #{code}."
@@ -166,9 +166,14 @@ module Lrama
       end
     end
 
+    def reset_first_position
+      @head_line = line
+      @head_column = column
+    end
+
     def newline
       @line += 1
-      @head = @scanner.pos + 1
+      @head = @scanner.pos
     end
   end
 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