ebnf 1.1.2 → 2.1.1

data/lib/ebnf.rb

@@ -1,9 +1,14 @@
 module EBNF
+  autoload :ABNF,     "ebnf/abnf"
   autoload :Base,     "ebnf/base"
   autoload :BNF,      "ebnf/bnf"
+  autoload :ISOEBNF,  "ebnf/isoebnf"
   autoload :LL1,      "ebnf/ll1"
+  autoload :Native,   "ebnf/native"
   autoload :Parser,   "ebnf/parser"
+  autoload :PEG,      "ebnf/peg"
   autoload :Rule,     "ebnf/rule"
+  autoload :Terminals,"ebnf/terminals"
   autoload :Writer,   "ebnf/writer"
   autoload :VERSION,  "ebnf/version"
 
@@ -17,7 +22,7 @@ module EBNF
   # @param  [Hash{Symbol => Object}] options
   # @return [EBNF::Base]
   # @raise  [Exception] on invalid input
-  def self.parse(input, options = {})
-    query = ::EBNF::Base.new(input, options)
+  def self.parse(input, **options)
+    ::EBNF::Base.new(input, **options)
   end
 end

data/lib/ebnf/abnf.rb

@@ -0,0 +1,301 @@
+require_relative 'abnf/core'
+require_relative 'abnf/meta'
+require 'logger'
+
+# ABNF parser
+# Parses ABNF into an array of {EBNF::Rule}.
+module EBNF
+  class ABNF
+    include EBNF::PEG::Parser
+
+    # Regular expressions for both "Core" and ABNF-specific terminals.
+    ALPHA = %r{[\x41-\x5A\x61-\x7A]}
+    VCHAR = %r{[\x20-\x7E]}
+    WSP = %r{[\x20\x09]}
+    CRLF = %r{\x0D?\x0A}
+    COMMENT = %r{;(?:#{WSP}|#{VCHAR})*#{CRLF}}
+    C_NL = %r{#{COMMENT}|#{CRLF}}
+    C_WSP = %r{#{WSP}|(?:#{C_NL}#{WSP})}
+
+    ##
+    # Hash of generated {EBNF::Rule} objects by symbol
+    #
+    # @return [Hash{Symbol => EBNF::Rule}]
+    attr_reader :parsed_rules
+
+    ##
+    # The following ABNF grammar rules are treated as terminals.
+
+    # `rulename     ::=  ALPHA (ALPHA | DIGIT | "-")*`
+    terminal(:rulename, /#{ALPHA}(?:#{ALPHA}|[0-9-])*/) do |value|
+      value.to_sym
+    end
+
+    # `defined_as   ::=  c_wsp* ("=" | "=/") c_wsp*`
+    terminal(:defined_as, /#{C_WSP}*=\/?#{C_WSP}*/) {|value| value.strip}
+
+    # `quoted_string::=  DQUOTE [#x20-#x21#x23-#x7E]* DQUOTE`
+    terminal(:quoted_string, /"[\x20-\x21\x23-\x7E]*"/) do |value|
+      value[1..-2]
+    end
+
+    # `bin_val      ::=  "b" BIT+ (("." BIT+)+ | ("-" BIT+))?`
+    terminal(:bin_val, /b[01]+(?:(?:(?:\.[01]+)+)|(?:-[01]+))?/) do |value|
+      if value.include?('.')
+        # Interpret segments in binary creating a sequence of hex characters or a string
+        hex_or_string(value[1..-1].split('.').map {|b| b.to_i(base=2).chr(Encoding::UTF_8)})
+      elsif value.include?('-')
+        # Interpret as a range
+        [:range, value[1..-1].split('-').map {|b| "#x%x" % b.to_i(base=2)}.join("-")]
+      else
+        # Interpret as a single HEX character
+        [:hex, "#x%x" % value[1..-1].to_i(base=2)]
+      end
+    end
+
+    # `dec_val      ::=  "d" DIGIT+ (("." DIGIT+)+ | ("-" DIGIT+))?`
+    terminal(:dec_val, /d[0-9]+(?:(?:(?:\.[0-9]+)+)|(?:-[0-9]+))?/) do |value|
+      if value.include?('.')
+        # Interpret segments in decimal creating a sequence of hex characters or a string
+        hex_or_string(value[1..-1].split('.').map {|b| b.to_i.chr(Encoding::UTF_8)})
+      elsif value.include?('-')
+        # Interpret as a range
+        [:range, value[1..-1].split('-').map {|d| "#x%x" % d.to_i}.join("-")]
+      else
+        # Interpret as a single HEX character
+        [:hex, "#x%x" % value[1..-1].to_i]
+      end
+    end
+
+    # `hex_val      ::=  "x" HEXDIG+  (("." HEXDIG+)+ | ("-" HEXDIG+))?`
+    terminal(:hex_val, /x[0-9A-F]+(?:(?:(?:\.[0-9A-F]+)+)|(?:-[0-9A-F]+))?/i) do |value|
+      if value.include?('.')
+        # Interpret segments in hexadecimal creating a sequence of hex characters or a string
+        hex_or_string(value[1..-1].split('.').map {|b| b.to_i(base=16).chr(Encoding::UTF_8)})
+      elsif value.include?('-')
+        # Interpret as a range
+        [:range, value[1..-1].split('-').map {|h| "#x%x" % h.to_i(base=16)}.join("-")]
+      else
+        # Interpret as a single HEX character
+        [:hex, "#x#{value[1..-1]}"]
+      end
+    end
+
+    # `c_wsp        ::=  WSP | (c_nl WSP)`
+    terminal(:c_wsp, C_WSP)
+
+    # `c_nl         ::=  comment | CRLF`
+    terminal(:c_nl, C_NL)
+
+    # `DIGIT        ::=  [#x30-#x39]`
+    terminal(:DIGIT, /\d/)
+
+    # ## Non-terminal productions
+
+    # The `start_production` on `:rule` allows the parser to present the value as a single Hash, rather than an array of individual hashes.
+    start_production(:rule, as_hash: true)
+
+    # `rule         ::=  rulename defined_as elements c_nl`
+    production(:rule) do |value|
+      # value contains an expression.
+      # Invoke callback
+      sym = value[:rulename]
+      elements = value[:elements]
+
+      if value[:defined_as] == "=/"
+        # append to rule alternate
+        rule = parsed_rules.fetch(sym) {raise "No existing rule found for #{sym}"}
+        rule.expr = [:alt, rule.expr] unless rule.alt?
+        if elements.is_a?(Array) && elements.first == :alt
+          # append alternatives to rule
+          rule.expr.concat(elements[1..-1])
+        else
+          # add elements as last alternative
+          rule.expr.push(elements)
+        end
+      else
+        # There shouldn't be an existing rule
+        raise "Redefining rule #{sym}" if parsed_rules.has_key?(sym)
+        parsed_rules[sym] = EBNF::Rule.new(sym.to_sym, nil, elements)
+      end
+      progress(:rule, level: 2) {parsed_rules[sym].to_sxp}
+      sym
+    end
+
+    # `elements     ::=  alternation c_wsp*`
+    production(:elements) do |value|
+      value.first[:alternation]
+    end
+
+    # `alternation  ::=  concatenation (c_wsp* "/" c_wsp* concatenation)*`
+    production(:alternation) do |value|
+      unless value.last[:_alternation_1].empty?
+        [:alt, value.first[:concatenation]] + value.last[:_alternation_1]
+      else
+        value.first[:concatenation]
+      end
+    end
+
+    # The `_aleteration_2` rule comes from the expanded PEG grammar and serves as an opportunity to custommize the values presented to the `aleteration` rule.
+    production(:_alternation_2) do |value|
+      if Array(value.last[:concatenation]).first == :alt
+        value.last[:concatenation][1..-1]
+      else
+        [value.last[:concatenation]]
+      end
+      value.last[:concatenation]
+    end
+
+    # `concatenation::=  repetition (c_wsp+ repetition)*`
+    production(:concatenation) do |value|
+      unless value.last[:_concatenation_1].empty?
+        [:seq, value.first[:repetition]] + value.last[:_concatenation_1]
+      else
+        value.first[:repetition]
+      end
+    end
+    start_production(:_concatenation_2, as_hash: true)
+    production(:_concatenation_2) do |value|
+      value[:repetition]
+    end
+
+    # `repetition   ::=  repeat? element`
+    production(:repetition) do |value|
+      rept = value.first[:_repetition_1]
+      elt = value.last[:element]
+      case rept
+      when [0, '*'] then [:star, elt]
+      when [1, '*'] then [:plus, elt]
+      when nil      then elt
+      else
+        [:rept, rept.first, rept.last, elt]
+      end
+    end
+
+    # `repeat       ::=  DIGIT+ | (DIGIT* "*" DIGIT*)`
+    production(:repeat) do |value|
+      if value.is_a?(Integer)
+        [value, value]
+      else
+        [value.first, value.last]
+      end
+    end
+    start_production(:_repeat_1, as_hash: true)
+    production(:_repeat_1) {|value| value.values}
+    production(:_repeat_2) {|value| value.join("").to_i}
+    production(:_repeat_3) {|value| value.join("").to_i}
+    production(:_repeat_4) {|value| value.length > 0 ? value.join("").to_i : '*'}
+
+    # `element      ::=  rulename | group | option | char_val | num_val | prose_val`
+    production(:element) do |value|
+      value
+    end
+
+    # `group        ::=  "(" c_wsp* alternation c_wsp* ")"`
+    start_production(:group, as_hash: true)
+    production(:group) do |value|
+      value[:alternation]
+    end
+
+    # `option       ::=  "[" c_wsp* alternation c_wsp* "]"`
+    start_production(:option, as_hash: true)
+    production(:option) do |value|
+      [:opt, value[:alternation]]
+    end
+
+    # `case_insensitive_string ::= "%i"? quoted_string`
+    production(:case_insensitive_string) do |value|
+      str = value.last[:quoted_string]
+      if str.match?(/[[:alpha:]]/)
+        # Only need to use case-insensitive if there are alphabetic characters in the string.
+        [:istr, value.last[:quoted_string]]
+      else
+        value.last[:quoted_string]
+      end
+    end
+
+    # `case_sensitive_string ::= "%s" quoted_string`
+    production(:case_sensitive_string) do |value|
+      value.last[:quoted_string]
+    end
+
+    # `num_val      ::=  "%" (bin_val | dec_val | hex_val)`
+    production(:num_val) do |value|
+      value.last[:_num_val_1]
+    end
+
+    # ## Parser invocation.
+    # On start, yield ourselves if a block is given, otherwise, return this parser instance
+    #
+    # @param  [#read, #to_s]          input
+    # @param  [Hash{Symbol => Object}] options
+    # @option options [Boolean] :level
+    #   Trace level. 0(debug), 1(info), 2(warn), 3(error).
+    # @return [EBNFParser]
+    def initialize(input, **options)
+      # If the `level` option is set, instantiate a logger for collecting trace information.
+      if options.has_key?(:level)
+        options[:logger] = Logger.new(STDERR)
+        options[:logger].level = options[:level]
+        options[:logger].formatter = lambda {|severity, datetime, progname, msg| "#{severity} #{msg}\n"}
+      end
+
+      # Read input, if necessary, which will be used in a Scanner.
+      @input = input.respond_to?(:read) ? input.read : input.to_s
+
+      @parsed_rules = {}
+
+      # Parses into `@parsed_rules`
+      parse(@input,
+            :rulelist,        # Starting rule
+            ABNFMeta::RULES,  # PEG rules
+            whitespace: '',   # No implicit whitespace
+            **options)
+    rescue EBNF::PEG::Parser::Error => e
+      raise SyntaxError, e.message
+    end
+
+    ##
+    # The AST includes the parsed rules along with built-in rules for ABNF used within the parsed grammar.
+    #
+    # @return [Array<EBNF::Rule>]
+    def ast
+      # Add built-in rules for standard ABNF rules not 
+      parsed_rules.values.map(&:symbols).flatten.uniq.each do |sym|
+        rule = ABNFCore::RULES.detect {|r| r.sym == sym}
+        parsed_rules[sym] ||= rule if rule
+      end
+
+      parsed_rules.values
+    end
+
+  private
+    # Generate a combination of seq and string to represent a sequence of characters
+    #
+    # @param [Array<String>] characters
+    # @return [String,Array]
+    def hex_or_string(characters)
+      seq = [:seq]
+      str_result = ""
+      characters.each do |c|
+        if VCHAR.match?(c)
+          str_result << c
+        else
+          if str_result.length > 0
+            seq << str_result
+            str_result = ""
+          end
+          seq << [:hex, "#x%x" % c.codepoints.first]
+        end
+      end
+      seq << str_result if str_result.length > 0
+
+      # Either return the sequence, or a string
+      if seq.length == 2 && seq.last.is_a?(String)
+        seq.last
+      else
+        seq
+      end
+    end
+  end
+end

data/lib/ebnf/abnf/core.rb

@@ -0,0 +1,23 @@
+# This file is automatically generated by ebnf version 2.0.0
+# Derived from etc/abnf-core.ebnf
+module ABNFCore
+  RULES = [
+    EBNF::Rule.new(:ALPHA, nil, [:range, "#x41-#x5A#x61-#x7A"], kind: :terminal),
+    EBNF::Rule.new(:BIT, nil, [:alt, "0", "1"], kind: :terminal),
+    EBNF::Rule.new(:CHAR, nil, [:range, "#x01-#x7F"], kind: :terminal),
+    EBNF::Rule.new(:CR, nil, [:hex, "#x0D"], kind: :terminal),
+    EBNF::Rule.new(:CRLF, nil, [:seq, [:opt, :CR], :LF], kind: :terminal),
+    EBNF::Rule.new(:CTL, nil, [:alt, [:range, "#x00-#x1F"], [:hex, "#x7F"]], kind: :terminal),
+    EBNF::Rule.new(:DIGIT, nil, [:range, "#x30-#x39"], kind: :terminal),
+    EBNF::Rule.new(:DQUOTE, nil, [:hex, "#x22"], kind: :terminal),
+    EBNF::Rule.new(:HEXDIG, nil, [:alt, :DIGIT, [:range, "A-F"]], kind: :terminal),
+    EBNF::Rule.new(:HTAB, nil, [:hex, "#x09"], kind: :terminal),
+    EBNF::Rule.new(:LF, nil, [:hex, "#x0A"], kind: :terminal),
+    EBNF::Rule.new(:LWSP, nil, [:star, [:alt, :WSP, [:seq, :CRLF, :WSP]]], kind: :terminal),
+    EBNF::Rule.new(:OCTET, nil, [:range, "#x00-#xFF"], kind: :terminal),
+    EBNF::Rule.new(:SP, nil, [:hex, "#x20"], kind: :terminal),
+    EBNF::Rule.new(:VCHAR, nil, [:range, "#x21-#x7E"], kind: :terminal),
+    EBNF::Rule.new(:WSP, nil, [:alt, :SP, :HTAB], kind: :terminal),
+  ]
+end
+

data/lib/ebnf/abnf/meta.rb

@@ -0,0 +1,111 @@
+# This file is automatically generated by ebnf version 2.0.0
+# Derived from abnf.ebnf
+module ABNFMeta
+  RULES = [
+    EBNF::Rule.new(:rulelist, nil, [:plus, :_rulelist_1]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_rulelist_1, nil, [:alt, :rule, :_rulelist_2]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_rulelist_2, nil, [:seq, :_rulelist_3, :c_nl]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_rulelist_3, nil, [:star, :c_wsp]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:rule, nil, [:seq, :rulename, :defined_as, :elements, :c_nl]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:elements, nil, [:seq, :alternation, :_elements_1]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_elements_1, nil, [:star, :c_wsp]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:alternation, nil, [:seq, :concatenation, :_alternation_1]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_alternation_1, nil, [:star, :_alternation_2]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_alternation_2, nil, [:seq, :_alternation_3, "/", :_alternation_4, :concatenation]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_alternation_3, nil, [:star, :c_wsp]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_alternation_4, nil, [:star, :c_wsp]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:concatenation, nil, [:seq, :repetition, :_concatenation_1]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_concatenation_1, nil, [:star, :_concatenation_2]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_concatenation_2, nil, [:seq, :_concatenation_3, :repetition]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_concatenation_3, nil, [:plus, :c_wsp]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:repetition, nil, [:seq, :_repetition_1, :element]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_repetition_1, nil, [:opt, :repeat]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:repeat, nil, [:alt, :_repeat_1, :_repeat_2]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_repeat_1, nil, [:seq, :_repeat_3, "*", :_repeat_4]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_repeat_3, nil, [:star, :DIGIT]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_repeat_4, nil, [:star, :DIGIT]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_repeat_2, nil, [:plus, :DIGIT]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:element, nil, [:alt, :rulename, :group, :option, :char_val, :num_val, :prose_val]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:group, nil, [:seq, "(", :_group_1, :alternation, :_group_2, ")"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_group_1, nil, [:star, :c_wsp]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_group_2, nil, [:star, :c_wsp]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:option, nil, [:seq, "[", :_option_1, :alternation, :_option_2, "]"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_option_1, nil, [:star, :c_wsp]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_option_2, nil, [:star, :c_wsp]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:char_val, nil, [:alt, :case_insensitive_string, :case_sensitive_string]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:case_insensitive_string, nil, [:seq, :_case_insensitive_string_1, :quoted_string]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_case_insensitive_string_1, nil, [:opt, "%i"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:case_sensitive_string, nil, [:seq, "%s", :quoted_string]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:num_val, nil, [:seq, "%", :_num_val_1]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_num_val_1, nil, [:alt, :bin_val, :dec_val, :hex_val]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:rulename, nil, [:seq, :ALPHA, :_rulename_1], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_rulename_1, nil, [:star, :_rulename_2]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_rulename_2, nil, [:alt, :ALPHA, :DIGIT, "-"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:defined_as, nil, [:seq, :_defined_as_1, :_defined_as_2, :_defined_as_3], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_defined_as_1, nil, [:star, :c_wsp]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_defined_as_2, nil, [:alt, "=", "=/"]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_defined_as_3, nil, [:star, :c_wsp]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:c_wsp, nil, [:alt, :WSP, :_c_wsp_1], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_c_wsp_1, nil, [:seq, :c_nl, :WSP]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:c_nl, nil, [:alt, :COMMENT, :CRLF], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:comment, nil, [:seq, ";", :_comment_1, :CRLF], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_comment_1, nil, [:star, :_comment_2]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_comment_2, nil, [:alt, :WSP, :VCHAR]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:quoted_string, nil, [:seq, :DQUOTE, :_quoted_string_1, :DQUOTE], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_quoted_string_1, nil, [:star, :_quoted_string_2]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_quoted_string_2, nil, [:range, "#x20-#x21#x23-#x7E"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:bin_val, nil, [:seq, "b", :_bin_val_1, :_bin_val_2], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_bin_val_1, nil, [:plus, :BIT]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_bin_val_2, nil, [:opt, :_bin_val_3]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_bin_val_3, nil, [:alt, :_bin_val_4, :_bin_val_5]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_bin_val_4, nil, [:plus, :_bin_val_6]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_bin_val_6, nil, [:seq, ".", :_bin_val_7]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_bin_val_7, nil, [:plus, :BIT]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_bin_val_5, nil, [:seq, "-", :_bin_val_8]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_bin_val_8, nil, [:plus, :BIT]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:dec_val, nil, [:seq, "d", :_dec_val_1, :_dec_val_2], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_dec_val_1, nil, [:plus, :DIGIT]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_dec_val_2, nil, [:opt, :_dec_val_3]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_dec_val_3, nil, [:alt, :_dec_val_4, :_dec_val_5]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_dec_val_4, nil, [:plus, :_dec_val_6]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_dec_val_6, nil, [:seq, ".", :_dec_val_7]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_dec_val_7, nil, [:plus, :DIGIT]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_dec_val_5, nil, [:seq, "-", :_dec_val_8]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_dec_val_8, nil, [:plus, :DIGIT]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:hex_val, nil, [:seq, "x", :_hex_val_1, :_hex_val_2], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_hex_val_1, nil, [:plus, :HEXDIG]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_hex_val_2, nil, [:opt, :_hex_val_3]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_hex_val_3, nil, [:alt, :_hex_val_4, :_hex_val_5]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_hex_val_4, nil, [:plus, :_hex_val_6]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_hex_val_6, nil, [:seq, ".", :_hex_val_7]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_hex_val_7, nil, [:plus, :HEXDIG]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_hex_val_5, nil, [:seq, "-", :_hex_val_8]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_hex_val_8, nil, [:plus, :HEXDIG]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:prose_val, nil, [:seq, "<", :_prose_val_1, ">"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_prose_val_1, nil, [:star, :_prose_val_2]).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_prose_val_2, nil, [:range, "#x20-#x3D#x3F-#x7E"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:ALPHA, nil, [:range, "#x41-#x5A#x61-#x7A"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:BIT, nil, [:alt, "0", "1"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:CHAR, nil, [:range, "#x01-#x7F"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:CR, nil, [:hex, "#x0D"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:CRLF, nil, [:seq, :_CRLF_1, :LF], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_CRLF_1, nil, [:opt, :CR], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:CTL, nil, [:alt, :_CTL_1, :_CTL_2], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_CTL_1, nil, [:range, "#x00-#x1F"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_CTL_2, nil, [:hex, "#x7F"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:DIGIT, nil, [:range, "#x30-#x39"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:DQUOTE, nil, [:hex, "#x22"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:HEXDIG, nil, [:alt, :DIGIT, :_HEXDIG_1], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_HEXDIG_1, nil, [:range, "A-F"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:HTAB, nil, [:hex, "#x09"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:LF, nil, [:hex, "#x0A"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:LWSP, nil, [:star, :_LWSP_1], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_LWSP_1, nil, [:alt, :WSP, :_LWSP_2], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:_LWSP_2, nil, [:seq, :CRLF, :WSP], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:OCTET, nil, [:range, "#x00-#xFF"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:SP, nil, [:hex, "#x20"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:VCHAR, nil, [:range, "#x21-#x7E"], kind: :terminal).extend(EBNF::PEG::Rule),
+    EBNF::Rule.new(:WSP, nil, [:alt, :SP, :HTAB], kind: :terminal).extend(EBNF::PEG::Rule),
+  ]
+end
+