abnftt 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3bc3e072613b51decf47f31c6ccbff2af79e403131d889ce6bbc075d097d5af2
+  data.tar.gz: 0d17df7192ac612129632e001e348f531f2c483041b961d447837a4dd3755b6f
+SHA512:
+  metadata.gz: 729b268fe2df5265d44560cd6dd07dc3a01de87a9d3fca4570953bf920566f35aadd64ba752f83560bf4b47d1404a6146500a0621d95e35416627ef8df5b115a
+  data.tar.gz: e319d947ef1f7ce20ece128b8b993d3b7931c4a3985b54ef8d7849ee79420a4d23b071cf6baa784062b92fec0ca74f4aea42d8e81829ba83f3911b71ede587fa

data/abnftt.gemspec

@@ -0,0 +1,14 @@
+Gem::Specification.new do |s|
+  s.name = "abnftt"
+  s.version = "0.1.1"
+  s.summary = "RFC 5234+7405 ABNF to Treetop"
+  s.description = %q{Less shifty support for tools based on IETF's ABNF}
+  s.author = "Carsten Bormann"
+  s.email = "cabo@tzi.org"
+  s.license = "MIT"
+  s.homepage = "http://github.com/cabo/abnftt"
+  s.files = Dir['lib/**/*.rb'] + %w(abnftt.gemspec) + Dir['bin/*']
+  s.executables = Dir['bin/*'].map {|x| File.basename(x)}
+  s.required_ruby_version = '>= 2.3'
+  s.require_paths = ["lib"]
+end

data/bin/abnftt

@@ -0,0 +1,136 @@
+#!/usr/bin/env ruby -Ku
+
+require 'pp'
+require 'yaml'
+require 'treetop'
+
+Encoding.default_external = Encoding::UTF_8
+
+require 'abnf'
+
+class Treetop::Runtime::SyntaxNode
+  def clean_abnf
+    if elements
+      elements.map {|el| el.clean_abnf}.join
+    else
+      text_value
+    end
+  end
+  def ast
+    fail "undefined_ast #{inspect}"
+  end
+  def ast_from_percent(base, first, second)
+    c1 = first.to_i(base).chr(Encoding::UTF_8)
+    case second[0]
+    when nil
+      ["cs", c1]
+    when "-"
+      c2 = second[1..-1].to_i(base).chr(Encoding::UTF_8)
+      ["char-range", c1, c2]
+    when "."
+      el = second.split(".")
+      el[0] = first
+      ["cs", el.map {|c| c.to_i(base).chr(Encoding::UTF_8)}.join]
+    else
+      fail "ast_from_percent"
+    end
+  end
+end
+
+def to_treetop(ast, ofn)
+  modname = File.basename(ofn).sub("-", "_").sub(/[^_a-zA-Z]/, "").upcase
+  <<~EOS
+    # Encoding: UTF-8
+    grammar #{modname}
+    #{ast.map {|x| to_treetop0(x)}.join}
+    end
+  EOS
+end
+def to_treetop0(ast)
+  fail ast.inspect unless ast[0] == "="
+  <<~EOS
+    rule #{to_treetop1(ast[1])}
+    #{to_treetop1(ast[2])}
+    end
+  EOS
+end
+FIXUP_NAMES = Hash.new {|h, k| k}
+FIXUP_NAMES.merge!({
+                     "rule" => "r__rule",
+                   })
+def to_treetop1(ast)
+  case ast
+  when String
+    FIXUP_NAMES[ast].gsub("-", "_")
+  when Array
+    case ast[0]
+    when "alt" # ["alt", *a]
+      "(#{ast[1..-1].map {|x| to_treetop1(x)}.join(" / ")})"
+    when "seq" # ["seq", *a]
+      "(#{ast[1..-1].map {|x| to_treetop1(x)}.join(" ")})"
+    when "rep" # ["rep", s, e, a]
+      t = to_treetop1(ast[3]) || "@@@"
+      case [ast[1], ast[2]]
+      when [0, 1]
+        t + "?"
+      when [0, true]
+        t + "*"
+      when [1, true]
+        t + "+"
+      else
+        t + " #{ast[1]}..#{ast[2] == true ? '' : ast[2]}"
+      end
+    when "prose" # ["prose", text]
+      fail "prose not implemented #{ast.inspect}"
+    when "ci" # ["ci", text]
+      s = ast[1]
+      if s =~ /\A[^A-Za-z]*\z/
+        s.inspect
+      else
+        s.inspect << "i"        # could do this always, but reduce noise
+      end
+    when "cs" # ["cs", text]
+      ast[1].inspect
+    when "char-range" # ["char-range", c1, c2]
+      c1 = Regexp.quote(ast[1])
+      c2 = Regexp.quote(ast[2])
+      "[#{c1}-#{c2}]"           # XXX does that always work
+    when "im" # ["im", a, text]
+      to_treetop1(ast[1]) + " " + ast[2]
+    else
+      fail "to_treetop(#{ast.inspect})"
+    end
+  else
+    fail "to_treetop(#{ast.inspect})"
+  end
+end
+
+unless fn = ARGV[0]
+  warn "Usage: abnftt grammar.abnftt"
+  exit 1
+end
+outfn = fn.sub(/\.abnftt\z/, "")
+
+parser = ABNFParser.new
+abnf_file = File.read(fn)
+ast = parser.parse abnf_file
+if ast
+#  p ast
+  File.open("#{outfn}.yaml", "w") do |f|
+    f.puts ast.ast.to_yaml
+  end
+  # pp ast.ast
+  File.open("#{outfn}.treetop", "w") do |f|
+    f.puts to_treetop(ast.ast, outfn)
+  end
+  File.open("#{outfn}.abnf", "w") do |f|
+    f.puts ast.clean_abnf.lines.map(&:rstrip).join("\n")
+  end
+else
+
+  puts parser.failure_reason
+  parser.failure_reason =~ /^(Expected .+) after/m
+  puts "#{$1.gsub("\n", '<<<NEWLINE>>>')}:"
+  puts abnf_file.lines.to_a[parser.failure_line - 1]
+  puts "#{'~' * (parser.failure_column - 1)}^"
+end

data/bin/abnftt~

@@ -0,0 +1,135 @@
+#!/usr/bin/env ruby -Ku
+
+require 'pp'
+require 'yaml'
+require 'treetop'
+
+Encoding.default_external = Encoding::UTF_8
+
+require 'abnf'
+
+class Treetop::Runtime::SyntaxNode
+  def clean_abnf
+    if elements
+      elements.map {|el| el.clean_abnf}.join
+    else
+      text_value
+    end
+  end
+  def ast
+    fail "undefined_ast #{inspect}"
+  end
+  def ast_from_percent(base, first, second)
+    c1 = first.to_i(base).chr(Encoding::UTF_8)
+    case second[0]
+    when nil
+      ["cs", c1]
+    when "-"
+      c2 = second[1..-1].to_i(base).chr(Encoding::UTF_8)
+      ["char-range", c1, c2]
+    when "."
+      el = second.split(".")
+      el[0] = first
+      ["cs", el.map {|c| c.to_i(base).chr(Encoding::UTF_8)}.join]
+    else
+      fail "ast_from_percent"
+    end
+  end
+end
+
+def to_treetop(ast)
+  <<~EOS
+    # Encoding: UTF-8
+    grammar TESTME
+    #{ast.map {|x| to_treetop0(x)}.join}
+    end
+  EOS
+end
+def to_treetop0(ast)
+  fail ast.inspect unless ast[0] == "="
+  <<~EOS
+    rule #{to_treetop1(ast[1])}
+    #{to_treetop1(ast[2])}
+    end
+  EOS
+end
+FIXUP_NAMES = Hash.new {|h, k| k}
+FIXUP_NAMES.merge!({
+                     "rule" => "r__rule",
+                   })
+def to_treetop1(ast)
+  case ast
+  when String
+    FIXUP_NAMES[ast].gsub("-", "_")
+  when Array
+    case ast[0]
+    when "alt" # ["alt", *a]
+      "(#{ast[1..-1].map {|x| to_treetop1(x)}.join(" / ")})"
+    when "seq" # ["seq", *a]
+      "(#{ast[1..-1].map {|x| to_treetop1(x)}.join(" ")})"
+    when "rep" # ["rep", s, e, a]
+      t = to_treetop1(ast[3]) || "@@@"
+      case [ast[1], ast[2]]
+      when [0, 1]
+        t + "?"
+      when [0, true]
+        t + "*"
+      when [1, true]
+        t + "+"
+      else
+        t + " #{ast[1]}..#{ast[2] == true ? '' : ast[2]}"
+      end
+    when "prose" # ["prose", text]
+      fail "prose not implemented #{ast.inspect}"
+    when "ci" # ["ci", text]
+      s = ast[1]
+      if s =~ /\A[^A-Za-z]*\z/
+        s.inspect
+      else
+        s.inspect << "i"        # could do this always, but reduce noise
+      end
+    when "cs" # ["cs", text]
+      ast[1].inspect
+    when "char-range" # ["char-range", c1, c2]
+      c1 = Regexp.quote(ast[1])
+      c2 = Regexp.quote(ast[2])
+      "[#{c1}-#{c2}]"           # XXX does that always work
+    when "im" # ["im", a, text]
+      to_treetop1(ast[1]) + " " + ast[2]
+    else
+      fail "to_treetop(#{ast.inspect})"
+    end
+  else
+    fail "to_treetop(#{ast.inspect})"
+  end
+end
+
+unless fn = ARGV[0]
+  warn "Usage: abnftt grammar.abnftt"
+  exit 1
+end
+outfn = fn.sub(/\.abnftt\z/, "")
+
+parser = ABNFParser.new
+abnf_file = File.read(fn)
+ast = parser.parse abnf_file
+if ast
+#  p ast
+  File.open("#{outfn}.yaml", "w") do |f|
+    f.puts ast.ast.to_yaml
+  end
+  # pp ast.ast
+  File.open("#{outfn}.treetop", "w") do |f|
+    f.puts to_treetop(ast.ast)
+  end
+  File.open("#{outfn}.abnf", "w") do |f|
+    f.puts ast.clean_abnf
+  end
+else
+  
+  puts parser.failure_reason
+  parser.failure_reason =~ /^(Expected .+) after/m
+  puts "#{$1.gsub("\n", '<<<NEWLINE>>>')}:"
+  puts abnf_file.lines.to_a[parser.failure_line - 1]
+  puts "#{'~' * (parser.failure_column - 1)}^"
+end

data/lib/abnf.rb

@@ -0,0 +1,2586 @@
+# Autogenerated from a Treetop grammar. Edits may be lost.
+
+
+module ABNF
+  include Treetop::Runtime
+
+  def root
+    @root ||= :rulelist
+  end
+
+  module Rulelist0
+    def ast() elements.map {|e| e.ast }.compact end
+  end
+
+  def _nt_rulelist
+    start_index = index
+    if node_cache[:rulelist].has_key?(index)
+      cached = node_cache[:rulelist][index]
+      if cached
+        node_cache[:rulelist][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      i1 = index
+      r2 = _nt_abnf_rule
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r1 = r2
+      else
+        r3 = _nt_empty_line
+        if r3
+          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+          r1 = r3
+        else
+          @index = i1
+          r1 = nil
+        end
+      end
+      if r1
+        s0 << r1
+      else
+        break
+      end
+    end
+    if s0.empty?
+      @index = i0
+      r0 = nil
+    else
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Rulelist0)
+      r0.extend(Rulelist0)
+    end
+
+    node_cache[:rulelist][start_index] = r0
+
+    r0
+  end
+
+  module EmptyLine0
+    def c_nl
+      elements[1]
+    end
+  end
+
+  module EmptyLine1
+    def ast() nil end
+  end
+
+  def _nt_empty_line
+    start_index = index
+    if node_cache[:empty_line].has_key?(index)
+      cached = node_cache[:empty_line][index]
+      if cached
+        node_cache[:empty_line][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    s1, i1 = [], index
+    loop do
+      r2 = _nt_c_wsp
+      if r2
+        s1 << r2
+      else
+        break
+      end
+    end
+    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+    s0 << r1
+    if r1
+      r3 = _nt_c_nl
+      s0 << r3
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(EmptyLine0)
+      r0.extend(EmptyLine1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:empty_line][start_index] = r0
+
+    r0
+  end
+
+  module AbnfRule0
+    def rulename
+      elements[0]
+    end
+
+    def defined_as
+      elements[1]
+    end
+
+    def alternation
+      elements[2]
+    end
+
+    def c_nl
+      elements[3]
+    end
+  end
+
+  module AbnfRule1
+    def ast() [defined_as.ast, rulename.ast, alternation.ast] end
+  end
+
+  def _nt_abnf_rule
+    start_index = index
+    if node_cache[:abnf_rule].has_key?(index)
+      cached = node_cache[:abnf_rule][index]
+      if cached
+        node_cache[:abnf_rule][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_rulename
+    s0 << r1
+    if r1
+      r2 = _nt_defined_as
+      s0 << r2
+      if r2
+        r3 = _nt_alternation
+        s0 << r3
+        if r3
+          r4 = _nt_c_nl
+          s0 << r4
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(AbnfRule0)
+      r0.extend(AbnfRule1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:abnf_rule][start_index] = r0
+
+    r0
+  end
+
+  module Rulename0
+    def ALPHA
+      elements[0]
+    end
+
+  end
+
+  module Rulename1
+    def ast() text_value end
+  end
+
+  def _nt_rulename
+    start_index = index
+    if node_cache[:rulename].has_key?(index)
+      cached = node_cache[:rulename][index]
+      if cached
+        node_cache[:rulename][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_ALPHA
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        i3 = index
+        r4 = _nt_ALPHA
+        if r4
+          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+          r3 = r4
+        else
+          r5 = _nt_DIGIT
+          if r5
+            r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+            r3 = r5
+          else
+            if (match_len = has_terminal?("-", false, index))
+              r6 = true
+              @index += match_len
+            else
+              terminal_parse_failure('"-"')
+              r6 = nil
+            end
+            if r6
+              r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+              r3 = r6
+            else
+              @index = i3
+              r3 = nil
+            end
+          end
+        end
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Rulename0)
+      r0.extend(Rulename1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:rulename][start_index] = r0
+
+    r0
+  end
+
+  module DefinedAs0
+  end
+
+  module DefinedAs1
+    def ast() elements[1].text_value end
+  end
+
+  def _nt_defined_as
+    start_index = index
+    if node_cache[:defined_as].has_key?(index)
+      cached = node_cache[:defined_as][index]
+      if cached
+        node_cache[:defined_as][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    s1, i1 = [], index
+    loop do
+      r2 = _nt_c_wsp
+      if r2
+        s1 << r2
+      else
+        break
+      end
+    end
+    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+    s0 << r1
+    if r1
+      i3 = index
+      if (match_len = has_terminal?("=", false, index))
+        r4 = true
+        @index += match_len
+      else
+        terminal_parse_failure('"="')
+        r4 = nil
+      end
+      if r4
+        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+        r3 = r4
+      else
+        if (match_len = has_terminal?("=/", false, index))
+          r5 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+          @index += match_len
+        else
+          terminal_parse_failure('"=/"')
+          r5 = nil
+        end
+        if r5
+          r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+          r3 = r5
+        else
+          @index = i3
+          r3 = nil
+        end
+      end
+      s0 << r3
+      if r3
+        s6, i6 = [], index
+        loop do
+          r7 = _nt_c_wsp
+          if r7
+            s6 << r7
+          else
+            break
+          end
+        end
+        r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
+        s0 << r6
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(DefinedAs0)
+      r0.extend(DefinedAs1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:defined_as][start_index] = r0
+
+    r0
+  end
+
+  module CWsp0
+    def c_nl
+      elements[0]
+    end
+
+    def WSP
+      elements[1]
+    end
+  end
+
+  module CWsp1
+    def ast() nil end
+  end
+
+  def _nt_c_wsp
+    start_index = index
+    if node_cache[:c_wsp].has_key?(index)
+      cached = node_cache[:c_wsp][index]
+      if cached
+        node_cache[:c_wsp][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_WSP
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+      r0.extend(CWsp1)
+      r0.extend(CWsp1)
+    else
+      i2, s2 = index, []
+      r3 = _nt_c_nl
+      s2 << r3
+      if r3
+        r4 = _nt_WSP
+        s2 << r4
+      end
+      if s2.last
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+        r2.extend(CWsp0)
+      else
+        @index = i2
+        r2 = nil
+      end
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+        r0.extend(CWsp1)
+        r0.extend(CWsp1)
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:c_wsp][start_index] = r0
+
+    r0
+  end
+
+  module CNl0
+    def ast() nil end
+  end
+
+  def _nt_c_nl
+    start_index = index
+    if node_cache[:c_nl].has_key?(index)
+      cached = node_cache[:c_nl][index]
+      if cached
+        node_cache[:c_nl][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_comment
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+      r0.extend(CNl0)
+      r0.extend(CNl0)
+    else
+      r2 = _nt_CRLF
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+        r0.extend(CNl0)
+        r0.extend(CNl0)
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:c_nl][start_index] = r0
+
+    r0
+  end
+
+  module Comment0
+    def CRLF
+      elements[2]
+    end
+  end
+
+  module Comment1
+    def ast() nil end
+  end
+
+  def _nt_comment
+    start_index = index
+    if node_cache[:comment].has_key?(index)
+      cached = node_cache[:comment][index]
+      if cached
+        node_cache[:comment][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    if (match_len = has_terminal?(";", false, index))
+      r1 = true
+      @index += match_len
+    else
+      terminal_parse_failure('";"')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        i3 = index
+        r4 = _nt_WSP
+        if r4
+          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+          r3 = r4
+        else
+          r5 = _nt_VCHAR
+          if r5
+            r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+            r3 = r5
+          else
+            @index = i3
+            r3 = nil
+          end
+        end
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+      if r2
+        r6 = _nt_CRLF
+        s0 << r6
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Comment0)
+      r0.extend(Comment1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:comment][start_index] = r0
+
+    r0
+  end
+
+  module Alternation0
+    def concatenation
+      elements[2]
+    end
+  end
+
+  module Alternation1
+    def concatenation
+      elements[0]
+    end
+
+  end
+
+  module Alternation2
+    def ast
+                                                         conc2 = elements[1].elements.map {|x| x.concatenation}
+                                                         # warn ["alt!!!", concatenation, conc2].inspect
+                                                         e = [elements[0], *conc2].map {|e| e.ast}.compact
+                                                         e.size == 1 ? e[0] : ["alt", *e]
+                                                       end
+  end
+
+  def _nt_alternation
+    start_index = index
+    if node_cache[:alternation].has_key?(index)
+      cached = node_cache[:alternation][index]
+      if cached
+        node_cache[:alternation][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_concatenation
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        i3, s3 = index, []
+        if (match_len = has_terminal?("/", false, index))
+          r4 = true
+          @index += match_len
+        else
+          terminal_parse_failure('"/"')
+          r4 = nil
+        end
+        s3 << r4
+        if r4
+          s5, i5 = [], index
+          loop do
+            r6 = _nt_c_wsp
+            if r6
+              s5 << r6
+            else
+              break
+            end
+          end
+          r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+          s3 << r5
+          if r5
+            r7 = _nt_concatenation
+            s3 << r7
+          end
+        end
+        if s3.last
+          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+          r3.extend(Alternation0)
+        else
+          @index = i3
+          r3 = nil
+        end
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Alternation1)
+      r0.extend(Alternation2)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:alternation][start_index] = r0
+
+    r0
+  end
+
+  module Concatenation0
+    def repetition
+      elements[1]
+    end
+  end
+
+  module Concatenation1
+    def repetition
+      elements[0]
+    end
+
+  end
+
+  module Concatenation2
+    def inline_module
+      elements[1]
+    end
+
+  end
+
+  module Concatenation3
+    def ast
+      rep2 = elements[0].elements[1].elements.map {|x| x.repetition}
+      # warn ["seq!!!", elements.size, elements[0], "bar", elements[1].elements].inspect
+      e = [elements[0].elements[0], *rep2].map {|e| e.ast}.compact
+      inline_module.ast_wrap(e.size == 1 ? e[0] : ["seq", *e])
+    end
+    def clean_abnf
+      elements[0].clean_abnf + elements[2].text_value
+    end
+  end
+
+  def _nt_concatenation
+    start_index = index
+    if node_cache[:concatenation].has_key?(index)
+      cached = node_cache[:concatenation][index]
+      if cached
+        node_cache[:concatenation][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    i1, s1 = index, []
+    r2 = _nt_repetition
+    s1 << r2
+    if r2
+      s3, i3 = [], index
+      loop do
+        i4, s4 = index, []
+        s5, i5 = [], index
+        loop do
+          r6 = _nt_c_wsp
+          if r6
+            s5 << r6
+          else
+            break
+          end
+        end
+        if s5.empty?
+          @index = i5
+          r5 = nil
+        else
+          r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+        end
+        s4 << r5
+        if r5
+          r7 = _nt_repetition
+          s4 << r7
+        end
+        if s4.last
+          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+          r4.extend(Concatenation0)
+        else
+          @index = i4
+          r4 = nil
+        end
+        if r4
+          s3 << r4
+        else
+          break
+        end
+      end
+      r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+      s1 << r3
+      if r3
+        s8, i8 = [], index
+        loop do
+          r9 = _nt_c_wsp
+          if r9
+            s8 << r9
+          else
+            break
+          end
+        end
+        r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
+        s1 << r8
+      end
+    end
+    if s1.last
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+      r1.extend(Concatenation1)
+    else
+      @index = i1
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      r10 = _nt_inline_module
+      s0 << r10
+      if r10
+        s11, i11 = [], index
+        loop do
+          r12 = _nt_c_wsp
+          if r12
+            s11 << r12
+          else
+            break
+          end
+        end
+        r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
+        s0 << r11
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Concatenation2)
+      r0.extend(Concatenation3)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:concatenation][start_index] = r0
+
+    r0
+  end
+
+  module Repetition0
+    def repeat_c
+      elements[0]
+    end
+
+    def element
+      elements[1]
+    end
+  end
+
+  module Repetition1
+    def ast
+                                                     elements[0].ast_wrap(element.ast)
+                                                  end
+  end
+
+  def _nt_repetition
+    start_index = index
+    if node_cache[:repetition].has_key?(index)
+      cached = node_cache[:repetition][index]
+      if cached
+        node_cache[:repetition][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_repeat_c
+    s0 << r1
+    if r1
+      r2 = _nt_element
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Repetition0)
+      r0.extend(Repetition1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:repetition][start_index] = r0
+
+    r0
+  end
+
+  module RepeatC0
+  end
+
+  module RepeatC1
+    def ast_wrap(a)
+                                                       s = 1
+                                                       e = 1
+                                                       el = elements.map {|e| e.text_value}
+                                                       if el[1] == "*"
+                                                         if el[0] != ""
+                                                           s = el[0].to_i
+                                                         else
+                                                           s = 0
+                                                         end
+                                                         if el[2] != ""
+                                                           e = el[2].to_i
+                                                         else
+                                                           e = true
+                                                         end
+                                                       end
+                                                       occ = [s, e]
+                                                       if occ == [1, 1]
+                                                         a
+                                                       else
+                                                         ["rep", s, e, a]
+                                                       end
+                                                   end
+  end
+
+  def _nt_repeat_c
+    start_index = index
+    if node_cache[:repeat_c].has_key?(index)
+      cached = node_cache[:repeat_c][index]
+      if cached
+        node_cache[:repeat_c][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    i1, s1 = index, []
+    s2, i2 = [], index
+    loop do
+      r3 = _nt_DIGIT
+      if r3
+        s2 << r3
+      else
+        break
+      end
+    end
+    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+    s1 << r2
+    if r2
+      if (match_len = has_terminal?("*", false, index))
+        r4 = true
+        @index += match_len
+      else
+        terminal_parse_failure('"*"')
+        r4 = nil
+      end
+      s1 << r4
+      if r4
+        s5, i5 = [], index
+        loop do
+          r6 = _nt_DIGIT
+          if r6
+            s5 << r6
+          else
+            break
+          end
+        end
+        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+        s1 << r5
+      end
+    end
+    if s1.last
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+      r1.extend(RepeatC0)
+    else
+      @index = i1
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+      r0.extend(RepeatC1)
+      r0.extend(RepeatC1)
+    else
+      s7, i7 = [], index
+      loop do
+        r8 = _nt_DIGIT
+        if r8
+          s7 << r8
+        else
+          break
+        end
+      end
+      r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
+      if r7
+        r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
+        r0 = r7
+        r0.extend(RepeatC1)
+        r0.extend(RepeatC1)
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:repeat_c][start_index] = r0
+
+    r0
+  end
+
+  module Element0
+    def ast() elements[0].ast end
+  end
+
+  def _nt_element
+    start_index = index
+    if node_cache[:element].has_key?(index)
+      cached = node_cache[:element][index]
+      if cached
+        node_cache[:element][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_rulename
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      r2 = _nt_group
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        r3 = _nt_option
+        if r3
+          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+          r0 = r3
+        else
+          r4 = _nt_char_val
+          if r4
+            r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+            r0 = r4
+          else
+            r5 = _nt_num_val
+            if r5
+              r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+              r0 = r5
+            else
+              r6 = _nt_prose_val
+              r6.extend(Element0)
+              r6.extend(Element0)
+              if r6
+                r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+                r0 = r6
+              else
+                @index = i0
+                r0 = nil
+              end
+            end
+          end
+        end
+      end
+    end
+
+    node_cache[:element][start_index] = r0
+
+    r0
+  end
+
+  module Group0
+    def alternation
+      elements[2]
+    end
+
+  end
+
+  module Group1
+    def ast() alternation.ast end
+  end
+
+  def _nt_group
+    start_index = index
+    if node_cache[:group].has_key?(index)
+      cached = node_cache[:group][index]
+      if cached
+        node_cache[:group][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    if (match_len = has_terminal?("(", false, index))
+      r1 = true
+      @index += match_len
+    else
+      terminal_parse_failure('"("')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        r3 = _nt_c_wsp
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+      if r2
+        r4 = _nt_alternation
+        s0 << r4
+        if r4
+          if (match_len = has_terminal?(")", false, index))
+            r5 = true
+            @index += match_len
+          else
+            terminal_parse_failure('")"')
+            r5 = nil
+          end
+          s0 << r5
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Group0)
+      r0.extend(Group1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:group][start_index] = r0
+
+    r0
+  end
+
+  module Option0
+    def alternation
+      elements[2]
+    end
+
+  end
+
+  module Option1
+    def ast() ["rep", 0, 1, alternation.ast] end
+  end
+
+  def _nt_option
+    start_index = index
+    if node_cache[:option].has_key?(index)
+      cached = node_cache[:option][index]
+      if cached
+        node_cache[:option][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    if (match_len = has_terminal?("[", false, index))
+      r1 = true
+      @index += match_len
+    else
+      terminal_parse_failure('"["')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        r3 = _nt_c_wsp
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+      if r2
+        r4 = _nt_alternation
+        s0 << r4
+        if r4
+          if (match_len = has_terminal?("]", false, index))
+            r5 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"]"')
+            r5 = nil
+          end
+          s0 << r5
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Option0)
+      r0.extend(Option1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:option][start_index] = r0
+
+    r0
+  end
+
+  module NumVal0
+    def a
+      elements[1]
+    end
+  end
+
+  module NumVal1
+    def ast() a.ast end
+  end
+
+  def _nt_num_val
+    start_index = index
+    if node_cache[:num_val].has_key?(index)
+      cached = node_cache[:num_val][index]
+      if cached
+        node_cache[:num_val][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    if (match_len = has_terminal?("%", false, index))
+      r1 = true
+      @index += match_len
+    else
+      terminal_parse_failure('"%"')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      i2 = index
+      r3 = _nt_bin_val
+      if r3
+        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+        r2 = r3
+      else
+        r4 = _nt_dec_val
+        if r4
+          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+          r2 = r4
+        else
+          r5 = _nt_hex_val
+          if r5
+            r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+            r2 = r5
+          else
+            @index = i2
+            r2 = nil
+          end
+        end
+      end
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(NumVal0)
+      r0.extend(NumVal1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:num_val][start_index] = r0
+
+    r0
+  end
+
+  module BinVal0
+  end
+
+  module BinVal1
+    def b
+      elements[0]
+    end
+  end
+
+  module BinVal2
+  end
+
+  module BinVal3
+    def c
+      elements[0]
+    end
+  end
+
+  module BinVal4
+    def a
+      elements[1]
+    end
+
+  end
+
+  module BinVal5
+    def ast() ast_from_percent(2, elements[1].text_value, elements[2].text_value) end
+  end
+
+  def _nt_bin_val
+    start_index = index
+    if node_cache[:bin_val].has_key?(index)
+      cached = node_cache[:bin_val][index]
+      if cached
+        node_cache[:bin_val][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    if (match_len = has_terminal?("b", false, index))
+      r1 = true
+      @index += match_len
+    else
+      terminal_parse_failure('"b"')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        r3 = _nt_BIT
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      if s2.empty?
+        @index = i2
+        r2 = nil
+      else
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      end
+      s0 << r2
+      if r2
+        i5 = index
+        i6, s6 = index, []
+        s7, i7 = [], index
+        loop do
+          i8, s8 = index, []
+          if (match_len = has_terminal?(".", false, index))
+            r9 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"."')
+            r9 = nil
+          end
+          s8 << r9
+          if r9
+            s10, i10 = [], index
+            loop do
+              r11 = _nt_BIT
+              if r11
+                s10 << r11
+              else
+                break
+              end
+            end
+            if s10.empty?
+              @index = i10
+              r10 = nil
+            else
+              r10 = instantiate_node(SyntaxNode,input, i10...index, s10)
+            end
+            s8 << r10
+          end
+          if s8.last
+            r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
+            r8.extend(BinVal0)
+          else
+            @index = i8
+            r8 = nil
+          end
+          if r8
+            s7 << r8
+          else
+            break
+          end
+        end
+        if s7.empty?
+          @index = i7
+          r7 = nil
+        else
+          r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
+        end
+        s6 << r7
+        if s6.last
+          r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
+          r6.extend(BinVal1)
+        else
+          @index = i6
+          r6 = nil
+        end
+        if r6
+          r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+          r5 = r6
+        else
+          i12, s12 = index, []
+          i13, s13 = index, []
+          if (match_len = has_terminal?("-", false, index))
+            r14 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"-"')
+            r14 = nil
+          end
+          s13 << r14
+          if r14
+            s15, i15 = [], index
+            loop do
+              r16 = _nt_BIT
+              if r16
+                s15 << r16
+              else
+                break
+              end
+            end
+            if s15.empty?
+              @index = i15
+              r15 = nil
+            else
+              r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
+            end
+            s13 << r15
+          end
+          if s13.last
+            r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
+            r13.extend(BinVal2)
+          else
+            @index = i13
+            r13 = nil
+          end
+          s12 << r13
+          if s12.last
+            r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
+            r12.extend(BinVal3)
+          else
+            @index = i12
+            r12 = nil
+          end
+          if r12
+            r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
+            r5 = r12
+          else
+            @index = i5
+            r5 = nil
+          end
+        end
+        if r5
+          r4 = r5
+        else
+          r4 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s0 << r4
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(BinVal4)
+      r0.extend(BinVal5)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:bin_val][start_index] = r0
+
+    r0
+  end
+
+  module DecVal0
+  end
+
+  module DecVal1
+    def b
+      elements[0]
+    end
+  end
+
+  module DecVal2
+  end
+
+  module DecVal3
+    def c
+      elements[0]
+    end
+  end
+
+  module DecVal4
+    def a
+      elements[1]
+    end
+
+  end
+
+  module DecVal5
+    def ast() ast_from_percent(10, elements[1].text_value, elements[2].text_value) end
+  end
+
+  def _nt_dec_val
+    start_index = index
+    if node_cache[:dec_val].has_key?(index)
+      cached = node_cache[:dec_val][index]
+      if cached
+        node_cache[:dec_val][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    if (match_len = has_terminal?("d", false, index))
+      r1 = true
+      @index += match_len
+    else
+      terminal_parse_failure('"d"')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        r3 = _nt_DIGIT
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      if s2.empty?
+        @index = i2
+        r2 = nil
+      else
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      end
+      s0 << r2
+      if r2
+        i5 = index
+        i6, s6 = index, []
+        s7, i7 = [], index
+        loop do
+          i8, s8 = index, []
+          if (match_len = has_terminal?(".", false, index))
+            r9 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"."')
+            r9 = nil
+          end
+          s8 << r9
+          if r9
+            s10, i10 = [], index
+            loop do
+              r11 = _nt_DIGIT
+              if r11
+                s10 << r11
+              else
+                break
+              end
+            end
+            if s10.empty?
+              @index = i10
+              r10 = nil
+            else
+              r10 = instantiate_node(SyntaxNode,input, i10...index, s10)
+            end
+            s8 << r10
+          end
+          if s8.last
+            r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
+            r8.extend(DecVal0)
+          else
+            @index = i8
+            r8 = nil
+          end
+          if r8
+            s7 << r8
+          else
+            break
+          end
+        end
+        if s7.empty?
+          @index = i7
+          r7 = nil
+        else
+          r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
+        end
+        s6 << r7
+        if s6.last
+          r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
+          r6.extend(DecVal1)
+        else
+          @index = i6
+          r6 = nil
+        end
+        if r6
+          r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+          r5 = r6
+        else
+          i12, s12 = index, []
+          i13, s13 = index, []
+          if (match_len = has_terminal?("-", false, index))
+            r14 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"-"')
+            r14 = nil
+          end
+          s13 << r14
+          if r14
+            s15, i15 = [], index
+            loop do
+              r16 = _nt_DIGIT
+              if r16
+                s15 << r16
+              else
+                break
+              end
+            end
+            if s15.empty?
+              @index = i15
+              r15 = nil
+            else
+              r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
+            end
+            s13 << r15
+          end
+          if s13.last
+            r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
+            r13.extend(DecVal2)
+          else
+            @index = i13
+            r13 = nil
+          end
+          s12 << r13
+          if s12.last
+            r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
+            r12.extend(DecVal3)
+          else
+            @index = i12
+            r12 = nil
+          end
+          if r12
+            r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
+            r5 = r12
+          else
+            @index = i5
+            r5 = nil
+          end
+        end
+        if r5
+          r4 = r5
+        else
+          r4 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s0 << r4
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(DecVal4)
+      r0.extend(DecVal5)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:dec_val][start_index] = r0
+
+    r0
+  end
+
+  module HexVal0
+  end
+
+  module HexVal1
+    def b
+      elements[0]
+    end
+  end
+
+  module HexVal2
+  end
+
+  module HexVal3
+    def c
+      elements[0]
+    end
+  end
+
+  module HexVal4
+    def a
+      elements[1]
+    end
+
+  end
+
+  module HexVal5
+    def ast() ast_from_percent(16, elements[1].text_value, elements[2].text_value) end
+  end
+
+  def _nt_hex_val
+    start_index = index
+    if node_cache[:hex_val].has_key?(index)
+      cached = node_cache[:hex_val][index]
+      if cached
+        node_cache[:hex_val][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    if (match_len = has_terminal?("x", false, index))
+      r1 = true
+      @index += match_len
+    else
+      terminal_parse_failure('"x"')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        r3 = _nt_HEXDIG
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      if s2.empty?
+        @index = i2
+        r2 = nil
+      else
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      end
+      s0 << r2
+      if r2
+        i5 = index
+        i6, s6 = index, []
+        s7, i7 = [], index
+        loop do
+          i8, s8 = index, []
+          if (match_len = has_terminal?(".", false, index))
+            r9 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"."')
+            r9 = nil
+          end
+          s8 << r9
+          if r9
+            s10, i10 = [], index
+            loop do
+              r11 = _nt_HEXDIG
+              if r11
+                s10 << r11
+              else
+                break
+              end
+            end
+            if s10.empty?
+              @index = i10
+              r10 = nil
+            else
+              r10 = instantiate_node(SyntaxNode,input, i10...index, s10)
+            end
+            s8 << r10
+          end
+          if s8.last
+            r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
+            r8.extend(HexVal0)
+          else
+            @index = i8
+            r8 = nil
+          end
+          if r8
+            s7 << r8
+          else
+            break
+          end
+        end
+        if s7.empty?
+          @index = i7
+          r7 = nil
+        else
+          r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
+        end
+        s6 << r7
+        if s6.last
+          r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
+          r6.extend(HexVal1)
+        else
+          @index = i6
+          r6 = nil
+        end
+        if r6
+          r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+          r5 = r6
+        else
+          i12, s12 = index, []
+          i13, s13 = index, []
+          if (match_len = has_terminal?("-", false, index))
+            r14 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"-"')
+            r14 = nil
+          end
+          s13 << r14
+          if r14
+            s15, i15 = [], index
+            loop do
+              r16 = _nt_HEXDIG
+              if r16
+                s15 << r16
+              else
+                break
+              end
+            end
+            if s15.empty?
+              @index = i15
+              r15 = nil
+            else
+              r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
+            end
+            s13 << r15
+          end
+          if s13.last
+            r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
+            r13.extend(HexVal2)
+          else
+            @index = i13
+            r13 = nil
+          end
+          s12 << r13
+          if s12.last
+            r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
+            r12.extend(HexVal3)
+          else
+            @index = i12
+            r12 = nil
+          end
+          if r12
+            r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
+            r5 = r12
+          else
+            @index = i5
+            r5 = nil
+          end
+        end
+        if r5
+          r4 = r5
+        else
+          r4 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s0 << r4
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(HexVal4)
+      r0.extend(HexVal5)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:hex_val][start_index] = r0
+
+    r0
+  end
+
+  module ProseVal0
+    def a
+      elements[1]
+    end
+
+  end
+
+  module ProseVal1
+    def ast() ["prose", a.text_value] end
+  end
+
+  def _nt_prose_val
+    start_index = index
+    if node_cache[:prose_val].has_key?(index)
+      cached = node_cache[:prose_val][index]
+      if cached
+        node_cache[:prose_val][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    if (match_len = has_terminal?("<", false, index))
+      r1 = true
+      @index += match_len
+    else
+      terminal_parse_failure('"<"')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        if has_terminal?(@regexps[gr = '\A[ -=?-~]'] ||= Regexp.new(gr), :regexp, index)
+          r3 = true
+          @index += 1
+        else
+          terminal_parse_failure('[ -=?-~]')
+          r3 = nil
+        end
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+      if r2
+        if (match_len = has_terminal?(">", false, index))
+          r4 = true
+          @index += match_len
+        else
+          terminal_parse_failure('">"')
+          r4 = nil
+        end
+        s0 << r4
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(ProseVal0)
+      r0.extend(ProseVal1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:prose_val][start_index] = r0
+
+    r0
+  end
+
+  def _nt_ALPHA
+    start_index = index
+    if node_cache[:ALPHA].has_key?(index)
+      cached = node_cache[:ALPHA][index]
+      if cached
+        node_cache[:ALPHA][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    if has_terminal?(@regexps[gr = '\A[A-Za-z]'] ||= Regexp.new(gr), :regexp, index)
+      r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      terminal_parse_failure('[A-Za-z]')
+      r0 = nil
+    end
+
+    node_cache[:ALPHA][start_index] = r0
+
+    r0
+  end
+
+  def _nt_BIT
+    start_index = index
+    if node_cache[:BIT].has_key?(index)
+      cached = node_cache[:BIT][index]
+      if cached
+        node_cache[:BIT][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    if (match_len = has_terminal?("0", false, index))
+      r1 = true
+      @index += match_len
+    else
+      terminal_parse_failure('"0"')
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      if (match_len = has_terminal?("1", false, index))
+        r2 = true
+        @index += match_len
+      else
+        terminal_parse_failure('"1"')
+        r2 = nil
+      end
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:BIT][start_index] = r0
+
+    r0
+  end
+
+  module CRLF0
+    def CR
+      elements[0]
+    end
+
+    def LF
+      elements[1]
+    end
+  end
+
+  def _nt_CRLF
+    start_index = index
+    if node_cache[:CRLF].has_key?(index)
+      cached = node_cache[:CRLF][index]
+      if cached
+        node_cache[:CRLF][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_CR
+    s0 << r1
+    if r1
+      r2 = _nt_LF
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(CRLF0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:CRLF][start_index] = r0
+
+    r0
+  end
+
+  def _nt_CR
+    start_index = index
+    if node_cache[:CR].has_key?(index)
+      cached = node_cache[:CR][index]
+      if cached
+        node_cache[:CR][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    if has_terminal?(@regexps[gr = '\A[\\r]'] ||= Regexp.new(gr), :regexp, index)
+      r1 = true
+      @index += 1
+    else
+      terminal_parse_failure('[\\r]')
+      r1 = nil
+    end
+    if r1
+      r0 = r1
+    else
+      r0 = instantiate_node(SyntaxNode,input, index...index)
+    end
+
+    node_cache[:CR][start_index] = r0
+
+    r0
+  end
+
+  def _nt_LF
+    start_index = index
+    if node_cache[:LF].has_key?(index)
+      cached = node_cache[:LF][index]
+      if cached
+        node_cache[:LF][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    if has_terminal?(@regexps[gr = '\A[\\n]'] ||= Regexp.new(gr), :regexp, index)
+      r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      terminal_parse_failure('[\\n]')
+      r0 = nil
+    end
+
+    node_cache[:LF][start_index] = r0
+
+    r0
+  end
+
+  def _nt_DIGIT
+    start_index = index
+    if node_cache[:DIGIT].has_key?(index)
+      cached = node_cache[:DIGIT][index]
+      if cached
+        node_cache[:DIGIT][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
+      r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      terminal_parse_failure('[0-9]')
+      r0 = nil
+    end
+
+    node_cache[:DIGIT][start_index] = r0
+
+    r0
+  end
+
+  def _nt_DQUOTE
+    start_index = index
+    if node_cache[:DQUOTE].has_key?(index)
+      cached = node_cache[:DQUOTE][index]
+      if cached
+        node_cache[:DQUOTE][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    if has_terminal?(@regexps[gr = '\A["]'] ||= Regexp.new(gr), :regexp, index)
+      r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      terminal_parse_failure('["]')
+      r0 = nil
+    end
+
+    node_cache[:DQUOTE][start_index] = r0
+
+    r0
+  end
+
+  def _nt_HEXDIG
+    start_index = index
+    if node_cache[:HEXDIG].has_key?(index)
+      cached = node_cache[:HEXDIG][index]
+      if cached
+        node_cache[:HEXDIG][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_DIGIT
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      if has_terminal?(@regexps[gr = '\A[A-Fa-f]'] ||= Regexp.new(gr), :regexp, index)
+        r2 = true
+        @index += 1
+      else
+        terminal_parse_failure('[A-Fa-f]')
+        r2 = nil
+      end
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:HEXDIG][start_index] = r0
+
+    r0
+  end
+
+  def _nt_WSP
+    start_index = index
+    if node_cache[:WSP].has_key?(index)
+      cached = node_cache[:WSP][index]
+      if cached
+        node_cache[:WSP][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_SP
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      r2 = _nt_HTAB
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:WSP][start_index] = r0
+
+    r0
+  end
+
+  def _nt_HTAB
+    start_index = index
+    if node_cache[:HTAB].has_key?(index)
+      cached = node_cache[:HTAB][index]
+      if cached
+        node_cache[:HTAB][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    if has_terminal?(@regexps[gr = '\A[\\t]'] ||= Regexp.new(gr), :regexp, index)
+      r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      terminal_parse_failure('[\\t]')
+      r0 = nil
+    end
+
+    node_cache[:HTAB][start_index] = r0
+
+    r0
+  end
+
+  def _nt_SP
+    start_index = index
+    if node_cache[:SP].has_key?(index)
+      cached = node_cache[:SP][index]
+      if cached
+        node_cache[:SP][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    if (match_len = has_terminal?(" ", false, index))
+      r0 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      @index += match_len
+    else
+      terminal_parse_failure('" "')
+      r0 = nil
+    end
+
+    node_cache[:SP][start_index] = r0
+
+    r0
+  end
+
+  def _nt_VCHAR
+    start_index = index
+    if node_cache[:VCHAR].has_key?(index)
+      cached = node_cache[:VCHAR][index]
+      if cached
+        node_cache[:VCHAR][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    if has_terminal?(@regexps[gr = '\A[!-~]'] ||= Regexp.new(gr), :regexp, index)
+      r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      terminal_parse_failure('[!-~]')
+      r0 = nil
+    end
+
+    node_cache[:VCHAR][start_index] = r0
+
+    r0
+  end
+
+  def _nt_char_val
+    start_index = index
+    if node_cache[:char_val].has_key?(index)
+      cached = node_cache[:char_val][index]
+      if cached
+        node_cache[:char_val][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_case_insensitive_string
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      r2 = _nt_case_sensitive_string
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:char_val][start_index] = r0
+
+    r0
+  end
+
+  module CaseInsensitiveString0
+    def quoted_string
+      elements[1]
+    end
+  end
+
+  module CaseInsensitiveString1
+    def ast() ["ci", quoted_string.ast] end
+  end
+
+  def _nt_case_insensitive_string
+    start_index = index
+    if node_cache[:case_insensitive_string].has_key?(index)
+      cached = node_cache[:case_insensitive_string][index]
+      if cached
+        node_cache[:case_insensitive_string][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    if (match_len = has_terminal?("%i", false, index))
+      r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      @index += match_len
+    else
+      terminal_parse_failure('"%i"')
+      r2 = nil
+    end
+    if r2
+      r1 = r2
+    else
+      r1 = instantiate_node(SyntaxNode,input, index...index)
+    end
+    s0 << r1
+    if r1
+      r3 = _nt_quoted_string
+      s0 << r3
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(CaseInsensitiveString0)
+      r0.extend(CaseInsensitiveString1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:case_insensitive_string][start_index] = r0
+
+    r0
+  end
+
+  module CaseSensitiveString0
+    def quoted_string
+      elements[1]
+    end
+  end
+
+  module CaseSensitiveString1
+    def ast() ["cs", quoted_string.ast] end
+  end
+
+  def _nt_case_sensitive_string
+    start_index = index
+    if node_cache[:case_sensitive_string].has_key?(index)
+      cached = node_cache[:case_sensitive_string][index]
+      if cached
+        node_cache[:case_sensitive_string][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    if (match_len = has_terminal?("%s", false, index))
+      r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      @index += match_len
+    else
+      terminal_parse_failure('"%s"')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      r2 = _nt_quoted_string
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(CaseSensitiveString0)
+      r0.extend(CaseSensitiveString1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:case_sensitive_string][start_index] = r0
+
+    r0
+  end
+
+  module QuotedString0
+    def DQUOTE1
+      elements[0]
+    end
+
+    def DQUOTE2
+      elements[2]
+    end
+  end
+
+  module QuotedString1
+    def ast() elements[1].text_value end
+  end
+
+  def _nt_quoted_string
+    start_index = index
+    if node_cache[:quoted_string].has_key?(index)
+      cached = node_cache[:quoted_string][index]
+      if cached
+        node_cache[:quoted_string][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_DQUOTE
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        if has_terminal?(@regexps[gr = '\A[ !#-~]'] ||= Regexp.new(gr), :regexp, index)
+          r3 = true
+          @index += 1
+        else
+          terminal_parse_failure('[ !#-~]')
+          r3 = nil
+        end
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+      if r2
+        r4 = _nt_DQUOTE
+        s0 << r4
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(QuotedString0)
+      r0.extend(QuotedString1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:quoted_string][start_index] = r0
+
+    r0
+  end
+
+  module InlineModule10
+  end
+
+  module InlineModule11
+  end
+
+  def _nt_inline_module1
+    start_index = index
+    if node_cache[:inline_module1].has_key?(index)
+      cached = node_cache[:inline_module1][index]
+      if cached
+        node_cache[:inline_module1][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    if (match_len = has_terminal?('{', false, index))
+      r1 = true
+      @index += match_len
+    else
+      terminal_parse_failure('\'{\'')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        i3 = index
+        r4 = _nt_inline_module1
+        if r4
+          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+          r3 = r4
+        else
+          i5, s5 = index, []
+          i6 = index
+          if has_terminal?(@regexps[gr = '\A[{}]'] ||= Regexp.new(gr), :regexp, index)
+            r7 = true
+            @index += 1
+          else
+            terminal_parse_failure('[{}]')
+            r7 = nil
+          end
+          if r7
+            @index = i6
+            r6 = nil
+            terminal_parse_failure('[{}]', true)
+          else
+            @terminal_failures.pop
+            @index = i6
+            r6 = instantiate_node(SyntaxNode,input, index...index)
+          end
+          s5 << r6
+          if r6
+            if index < input_length
+              r8 = true
+              @index += 1
+            else
+              terminal_parse_failure("any character")
+              r8 = nil
+            end
+            s5 << r8
+          end
+          if s5.last
+            r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+            r5.extend(InlineModule10)
+          else
+            @index = i5
+            r5 = nil
+          end
+          if r5
+            r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+            r3 = r5
+          else
+            @index = i3
+            r3 = nil
+          end
+        end
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+      if r2
+        if (match_len = has_terminal?('}', false, index))
+          r9 = true
+          @index += match_len
+        else
+          terminal_parse_failure('\'}\'')
+          r9 = nil
+        end
+        s0 << r9
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(InlineModule11)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:inline_module1][start_index] = r0
+
+    r0
+  end
+
+  module InlineModule0
+    def ast_wrap(a) ["im", a, text_value] end
+  end
+
+  module InlineModule1
+    def ast_wrap(a) a end
+  end
+
+  def _nt_inline_module
+    start_index = index
+    if node_cache[:inline_module].has_key?(index)
+      cached = node_cache[:inline_module][index]
+      if cached
+        node_cache[:inline_module][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_inline_module1
+    r1.extend(InlineModule0)
+    r1.extend(InlineModule0)
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      if (match_len = has_terminal?('', false, index))
+        r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+        r2.extend(InlineModule1)
+        @index += match_len
+      else
+        terminal_parse_failure('\'\'')
+        r2 = nil
+      end
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:inline_module][start_index] = r0
+
+    r0
+  end
+
+end
+
+class ABNFParser < Treetop::Runtime::CompiledParser
+  include ABNF
+end
+
+