cddlc 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9e4a9fe5e7434a8b5f5bea9b9194c988206f74e95aef1e4d2e46067968367727
+  data.tar.gz: de11c07b72815e2e6580ed35b36d4d0b56f39e282b3072f84d00e836b6bcd2aa
+SHA512:
+  metadata.gz: 62ca200613f056851f397a41a57e64fd49fa0ff2196d0433d706760c05f11468ae3a6ed7652fc4ee5f4387476744e36f2f06f07f67efc14b68774460b55023cd
+  data.tar.gz: b1b7560dbfe6f712f31b415138f37bde551a095fcb7a42a7afc82268db416de5eca5f1dff0d3d9f8cf02b82b39b9880d3fb19e7dc405186ffba61acd6b2d029a

data/bin/cddlc

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+require 'pp'
+require 'yaml'
+require 'treetop'
+require 'json'
+
+require_relative '../lib/parser/cddl-util.rb'
+
+Encoding.default_external = Encoding::UTF_8
+require 'optparse'
+require 'ostruct'
+
+$options = OpenStruct.new
+begin
+  op = OptionParser.new do |opts|
+    opts.banner = "Usage: cddlc.rb [options] file.cddl"
+
+    opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+      $options.verbose = v
+    end
+    opts.on("-tFMT", "--to=FMT", [:neat, :json, :yaml], "Target format") do |v|
+      $options.target = v
+    end
+  end
+  op.parse!
+rescue Exception => e
+  warn e
+  exit 1
+end
+
+if ARGV == []
+  puts op
+  exit 1
+end
+cddl_file = ARGF.read
+
+parser = CDDLParser.new
+ast = parser.parse cddl_file
+if ast
+#  puts ast.to_yaml
+  result = ast.ast
+  case $options.target
+  when :json, nil
+    pp result
+  when :neat
+    require 'neatjson'
+    puts JSON.neat_generate(result, after_comma: 1, after_colon: 1)
+  when :yaml
+    puts result.to_yaml
+  else
+    warn ["Unknown target format: ", $options.target].inspect
+  end
+else
+  warn parser.failure_reason
+  parser.failure_reason =~ /^(Expected .+) after/m
+  warn "#{$1.gsub("\n", '<<<NEWLINE>>>')}:"
+  warn cddl_file.lines.to_a[parser.failure_line - 1]
+  warn "#{'~' * (parser.failure_column - 1)}^"
+end

data/cddlc.gemspec

@@ -0,0 +1,20 @@
+Gem::Specification.new do |s|
+  s.name = "cddlc"
+  s.version = "0.0.1"
+  s.summary = "CDDL (Concise Data Definition Language) converters and miscellaneous tools"
+  s.description = %q{cddlc implements converters and miscellaneous tools for CDDL, RFC 8610}
+  s.author = "Carsten Bormann"
+  s.email = "cabo@tzi.org"
+  s.license = "MIT"
+  s.homepage = "http://github.com/cabo/cddlc"
+  s.files = Dir['lib/**/*.rb'] + %w(cddlc.gemspec) + Dir['bin/**/*.rb']
+  s.executables = Dir['bin/*'].map {|x| File.basename(x)}
+  s.required_ruby_version = '>= 1.9.2'
+
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency 'bundler', '~>1'
+  s.add_dependency 'treetop', '~>1'
+  s.add_dependency 'json'
+  s.add_dependency 'neatjson'
+end

data/lib/parser/cddl-util.rb

@@ -0,0 +1,51 @@
+
+require_relative './cddl'
+
+class Treetop::Runtime::SyntaxNode
+  def ast
+    fail "undefined_ast #{inspect}"
+  end
+  def ast1                      # devhack
+    "#{inspect[10..20]}--#{text_value[0..15]}"
+  end
+  def mkgen(name, genparm)
+    nm = name.text_value
+    if el = genparm.elements
+      ["gen", nm, *genparm.ast] # XXX
+    else
+      ["name", nm]
+    end
+  end
+  def wrapop(op, first, rest)
+    a = first.ast
+    b = rest.map(&:ast)
+    if b.size != 0
+      [op, a, *b]
+    else
+      a
+    end
+  end
+  def wrapop0(op, all)
+    a = all.map(&:ast)
+    if a.size == 1
+      a[0]
+    else
+      [op, *a]
+    end
+  end
+  def tvtoi(el, default)
+    v = el.text_value
+    if v == ''
+      default
+    else
+      v.to_i
+    end
+  end
+  def repwrap(el, val)
+    if el.text_value == ''
+      val
+    else
+      ["rep", *el.ast, val]
+    end
+  end
+end

data/lib/parser/cddl.rb

@@ -0,0 +1,4016 @@
+# Encoding: UTF-8
+# Autogenerated from a Treetop grammar. Edits may be lost.
+
+
+module CDDL
+  include Treetop::Runtime
+
+  def root
+    @root ||= :cddl
+  end
+
+  module Cddl0
+    def r__rule
+      elements[0]
+    end
+
+    def S
+      elements[1]
+    end
+  end
+
+  module Cddl1
+    def S
+      elements[0]
+    end
+
+  end
+
+  module Cddl2
+    def ast
+      ["cddl", *elements[1].elements.map(&:r__rule).map(&:ast)]
+    end
+  end
+
+  def _nt_cddl
+    start_index = index
+    if node_cache[:cddl].has_key?(index)
+      cached = node_cache[:cddl][index]
+      if cached
+        node_cache[:cddl][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_S
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        i3, s3 = index, []
+        r4 = _nt_r__rule
+        s3 << r4
+        if r4
+          r5 = _nt_S
+          s3 << r5
+        end
+        if s3.last
+          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+          r3.extend(Cddl0)
+        else
+          @index = i3
+          r3 = nil
+        end
+        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
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Cddl1)
+      r0.extend(Cddl2)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:cddl][start_index] = r0
+
+    r0
+  end
+
+  module R_rule0
+    def typename
+      elements[0]
+    end
+
+    def S1
+      elements[2]
+    end
+
+    def assignt
+      elements[3]
+    end
+
+    def S2
+      elements[4]
+    end
+
+    def type
+      elements[5]
+    end
+  end
+
+  module R_rule1
+    def ast
+      [assignt.text_value, mkgen(typename, elements[1]), type.ast]
+    end
+  end
+
+  module R_rule2
+    def groupname
+      elements[0]
+    end
+
+    def S1
+      elements[2]
+    end
+
+    def assigng
+      elements[3]
+    end
+
+    def S2
+      elements[4]
+    end
+
+    def grpent
+      elements[5]
+    end
+  end
+
+  module R_rule3
+    def ast
+      [assigng.text_value, mkgen(groupname, elements[1]), grpent.ast]
+    end
+  end
+
+  def _nt_r__rule
+    start_index = index
+    if node_cache[:r__rule].has_key?(index)
+      cached = node_cache[:r__rule][index]
+      if cached
+        node_cache[:r__rule][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    i1, s1 = index, []
+    r2 = _nt_typename
+    s1 << r2
+    if r2
+      r4 = _nt_genericparm
+      if r4
+        r3 = r4
+      else
+        r3 = instantiate_node(SyntaxNode,input, index...index)
+      end
+      s1 << r3
+      if r3
+        r5 = _nt_S
+        s1 << r5
+        if r5
+          r6 = _nt_assignt
+          s1 << r6
+          if r6
+            r7 = _nt_S
+            s1 << r7
+            if r7
+              r8 = _nt_type
+              s1 << r8
+            end
+          end
+        end
+      end
+    end
+    if s1.last
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+      r1.extend(R_rule0)
+      r1.extend(R_rule1)
+    else
+      @index = i1
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      i9, s9 = index, []
+      r10 = _nt_groupname
+      s9 << r10
+      if r10
+        r12 = _nt_genericparm
+        if r12
+          r11 = r12
+        else
+          r11 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s9 << r11
+        if r11
+          r13 = _nt_S
+          s9 << r13
+          if r13
+            r14 = _nt_assigng
+            s9 << r14
+            if r14
+              r15 = _nt_S
+              s9 << r15
+              if r15
+                r16 = _nt_grpent
+                s9 << r16
+              end
+            end
+          end
+        end
+      end
+      if s9.last
+        r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
+        r9.extend(R_rule2)
+        r9.extend(R_rule3)
+      else
+        @index = i9
+        r9 = nil
+      end
+      if r9
+        r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
+        r0 = r9
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:r__rule][start_index] = r0
+
+    r0
+  end
+
+  def _nt_typename
+    start_index = index
+    if node_cache[:typename].has_key?(index)
+      cached = node_cache[:typename][index]
+      if cached
+        node_cache[:typename][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    r0 = _nt_id
+
+    node_cache[:typename][start_index] = r0
+
+    r0
+  end
+
+  def _nt_groupname
+    start_index = index
+    if node_cache[:groupname].has_key?(index)
+      cached = node_cache[:groupname][index]
+      if cached
+        node_cache[:groupname][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    r0 = _nt_id
+
+    node_cache[:groupname][start_index] = r0
+
+    r0
+  end
+
+  def _nt_assignt
+    start_index = index
+    if node_cache[:assignt].has_key?(index)
+      cached = node_cache[:assignt][index]
+      if cached
+        node_cache[:assignt][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?("=", false, index))
+      r1 = true
+      @index += match_len
+    else
+      terminal_parse_failure('"="')
+      r1 = nil
+    end
+    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))
+        @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[:assignt][start_index] = r0
+
+    r0
+  end
+
+  def _nt_assigng
+    start_index = index
+    if node_cache[:assigng].has_key?(index)
+      cached = node_cache[:assigng][index]
+      if cached
+        node_cache[:assigng][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?("=", false, index))
+      r1 = true
+      @index += match_len
+    else
+      terminal_parse_failure('"="')
+      r1 = nil
+    end
+    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))
+        @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[:assigng][start_index] = r0
+
+    r0
+  end
+
+  module Genericparm0
+    def S1
+      elements[1]
+    end
+
+    def id
+      elements[2]
+    end
+
+    def S2
+      elements[3]
+    end
+  end
+
+  module Genericparm1
+    def S1
+      elements[1]
+    end
+
+    def id
+      elements[2]
+    end
+
+    def S2
+      elements[3]
+    end
+
+  end
+
+  module Genericparm2
+    def ast() [id.text_value, *elements[4].elements.map{|x| x.id.text_value}] end
+  end
+
+  def _nt_genericparm
+    start_index = index
+    if node_cache[:genericparm].has_key?(index)
+      cached = node_cache[:genericparm][index]
+      if cached
+        node_cache[:genericparm][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
+      r2 = _nt_S
+      s0 << r2
+      if r2
+        r3 = _nt_id
+        s0 << r3
+        if r3
+          r4 = _nt_S
+          s0 << r4
+          if r4
+            s5, i5 = [], index
+            loop do
+              i6, s6 = index, []
+              if (match_len = has_terminal?(",", false, index))
+                r7 = true
+                @index += match_len
+              else
+                terminal_parse_failure('","')
+                r7 = nil
+              end
+              s6 << r7
+              if r7
+                r8 = _nt_S
+                s6 << r8
+                if r8
+                  r9 = _nt_id
+                  s6 << r9
+                  if r9
+                    r10 = _nt_S
+                    s6 << r10
+                  end
+                end
+              end
+              if s6.last
+                r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
+                r6.extend(Genericparm0)
+              else
+                @index = i6
+                r6 = nil
+              end
+              if r6
+                s5 << r6
+              else
+                break
+              end
+            end
+            r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+            s0 << r5
+            if r5
+              if (match_len = has_terminal?(">", false, index))
+                r11 = true
+                @index += match_len
+              else
+                terminal_parse_failure('">"')
+                r11 = nil
+              end
+              s0 << r11
+            end
+          end
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Genericparm1)
+      r0.extend(Genericparm2)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:genericparm][start_index] = r0
+
+    r0
+  end
+
+  module Genericarg0
+    def S1
+      elements[1]
+    end
+
+    def type1
+      elements[2]
+    end
+
+    def S2
+      elements[3]
+    end
+  end
+
+  module Genericarg1
+    def S1
+      elements[1]
+    end
+
+    def type1
+      elements[2]
+    end
+
+    def S2
+      elements[3]
+    end
+
+  end
+
+  module Genericarg2
+    def ast() [type1.ast, *elements[4].elements.map{|x| x.type1.ast}] end
+  end
+
+  def _nt_genericarg
+    start_index = index
+    if node_cache[:genericarg].has_key?(index)
+      cached = node_cache[:genericarg][index]
+      if cached
+        node_cache[:genericarg][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
+      r2 = _nt_S
+      s0 << r2
+      if r2
+        r3 = _nt_type1
+        s0 << r3
+        if r3
+          r4 = _nt_S
+          s0 << r4
+          if r4
+            s5, i5 = [], index
+            loop do
+              i6, s6 = index, []
+              if (match_len = has_terminal?(",", false, index))
+                r7 = true
+                @index += match_len
+              else
+                terminal_parse_failure('","')
+                r7 = nil
+              end
+              s6 << r7
+              if r7
+                r8 = _nt_S
+                s6 << r8
+                if r8
+                  r9 = _nt_type1
+                  s6 << r9
+                  if r9
+                    r10 = _nt_S
+                    s6 << r10
+                  end
+                end
+              end
+              if s6.last
+                r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
+                r6.extend(Genericarg0)
+              else
+                @index = i6
+                r6 = nil
+              end
+              if r6
+                s5 << r6
+              else
+                break
+              end
+            end
+            r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+            s0 << r5
+            if r5
+              if (match_len = has_terminal?(">", false, index))
+                r11 = true
+                @index += match_len
+              else
+                terminal_parse_failure('">"')
+                r11 = nil
+              end
+              s0 << r11
+            end
+          end
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Genericarg1)
+      r0.extend(Genericarg2)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:genericarg][start_index] = r0
+
+    r0
+  end
+
+  module Type0
+    def S1
+      elements[0]
+    end
+
+    def S2
+      elements[2]
+    end
+
+    def type1
+      elements[3]
+    end
+  end
+
+  module Type1
+    def type1
+      elements[0]
+    end
+
+  end
+
+  module Type2
+    def ast
+      wrapop("tcho", type1, elements[1].elements.map(&:type1))
+    end
+  end
+
+  def _nt_type
+    start_index = index
+    if node_cache[:type].has_key?(index)
+      cached = node_cache[:type][index]
+      if cached
+        node_cache[:type][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_type1
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        i3, s3 = index, []
+        r4 = _nt_S
+        s3 << r4
+        if r4
+          if (match_len = has_terminal?("/", false, index))
+            r5 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"/"')
+            r5 = nil
+          end
+          s3 << r5
+          if r5
+            r6 = _nt_S
+            s3 << r6
+            if r6
+              r7 = _nt_type1
+              s3 << r7
+            end
+          end
+        end
+        if s3.last
+          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+          r3.extend(Type0)
+        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(Type1)
+      r0.extend(Type2)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:type][start_index] = r0
+
+    r0
+  end
+
+  module Type10
+    def S1
+      elements[0]
+    end
+
+    def S2
+      elements[2]
+    end
+
+    def type2
+      elements[3]
+    end
+  end
+
+  module Type11
+    def type2
+      elements[0]
+    end
+
+  end
+
+  module Type12
+    def ast
+      a = type2.ast
+      if el = elements[1].elements
+        ["op", el[1].text_value, a, el[3].ast]
+      else
+        a
+      end
+    end
+  end
+
+  def _nt_type1
+    start_index = index
+    if node_cache[:type1].has_key?(index)
+      cached = node_cache[:type1][index]
+      if cached
+        node_cache[:type1][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_type2
+    s0 << r1
+    if r1
+      i3, s3 = index, []
+      r4 = _nt_S
+      s3 << r4
+      if r4
+        i5 = index
+        r6 = _nt_rangeop
+        if r6
+          r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+          r5 = r6
+        else
+          r7 = _nt_ctlop
+          if r7
+            r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
+            r5 = r7
+          else
+            @index = i5
+            r5 = nil
+          end
+        end
+        s3 << r5
+        if r5
+          r8 = _nt_S
+          s3 << r8
+          if r8
+            r9 = _nt_type2
+            s3 << r9
+          end
+        end
+      end
+      if s3.last
+        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+        r3.extend(Type10)
+      else
+        @index = i3
+        r3 = nil
+      end
+      if r3
+        r2 = r3
+      else
+        r2 = instantiate_node(SyntaxNode,input, index...index)
+      end
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Type11)
+      r0.extend(Type12)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:type1][start_index] = r0
+
+    r0
+  end
+
+  module Type20
+    def typename
+      elements[0]
+    end
+
+  end
+
+  module Type21
+    def ast() mkgen(typename, elements[1]) end
+  end
+
+  module Type22
+    def S1
+      elements[1]
+    end
+
+    def type
+      elements[2]
+    end
+
+    def S2
+      elements[3]
+    end
+
+  end
+
+  module Type23
+    def ast() elements[2].ast end
+  end
+
+  module Type24
+    def S1
+      elements[1]
+    end
+
+    def group
+      elements[2]
+    end
+
+    def S2
+      elements[3]
+    end
+
+  end
+
+  module Type25
+    def ast() ["map", group.ast] end
+  end
+
+  module Type26
+    def S1
+      elements[1]
+    end
+
+    def group
+      elements[2]
+    end
+
+    def S2
+      elements[3]
+    end
+
+  end
+
+  module Type27
+    def ast() ["ary", group.ast] end
+  end
+
+  module Type28
+    def S
+      elements[1]
+    end
+
+    def typename
+      elements[2]
+    end
+
+  end
+
+  module Type29
+    def ast () ["unwrap", mkgen(typename, elements[3])] end
+  end
+
+  module Type210
+    def S1
+      elements[1]
+    end
+
+    def S2
+      elements[3]
+    end
+
+    def group
+      elements[4]
+    end
+
+    def S3
+      elements[5]
+    end
+
+  end
+
+  module Type211
+    def ast() ["enum", group.ast] end
+  end
+
+  module Type212
+    def S
+      elements[1]
+    end
+
+    def groupname
+      elements[2]
+    end
+
+  end
+
+  module Type213
+    def ast() ["enum", mkgen(groupname, elements[3])] end
+  end
+
+  module Type214
+    def uint
+      elements[1]
+    end
+  end
+
+  module Type215
+    def S1
+      elements[4]
+    end
+
+    def type
+      elements[5]
+    end
+
+    def S2
+      elements[6]
+    end
+
+  end
+
+  module Type216
+    def ast
+              el = elements[2].elements
+              ["prim", 6, el && el[1].text_value.to_i, elements[5].ast]
+            end
+  end
+
+  module Type217
+    def uint
+      elements[1]
+    end
+  end
+
+  module Type218
+    def DIGIT
+      elements[1]
+    end
+
+  end
+
+  module Type219
+    def ast
+              ["prim", elements[1].text_value.to_i,
+               *(el = elements[2].elements) ? [el[1].text_value.to_i] : []]
+            end
+  end
+
+  module Type220
+    def ast() ["prim"] end
+  end
+
+  def _nt_type2
+    start_index = index
+    if node_cache[:type2].has_key?(index)
+      cached = node_cache[:type2][index]
+      if cached
+        node_cache[:type2][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_value
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      i2, s2 = index, []
+      r3 = _nt_typename
+      s2 << r3
+      if r3
+        r5 = _nt_genericarg
+        if r5
+          r4 = r5
+        else
+          r4 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s2 << r4
+      end
+      if s2.last
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+        r2.extend(Type20)
+        r2.extend(Type21)
+      else
+        @index = i2
+        r2 = nil
+      end
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        i6, s6 = index, []
+        if (match_len = has_terminal?("(", false, index))
+          r7 = true
+          @index += match_len
+        else
+          terminal_parse_failure('"("')
+          r7 = nil
+        end
+        s6 << r7
+        if r7
+          r8 = _nt_S
+          s6 << r8
+          if r8
+            r9 = _nt_type
+            s6 << r9
+            if r9
+              r10 = _nt_S
+              s6 << r10
+              if r10
+                if (match_len = has_terminal?(")", false, index))
+                  r11 = true
+                  @index += match_len
+                else
+                  terminal_parse_failure('")"')
+                  r11 = nil
+                end
+                s6 << r11
+              end
+            end
+          end
+        end
+        if s6.last
+          r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
+          r6.extend(Type22)
+          r6.extend(Type23)
+        else
+          @index = i6
+          r6 = nil
+        end
+        if r6
+          r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+          r0 = r6
+        else
+          i12, s12 = index, []
+          if (match_len = has_terminal?("{", false, index))
+            r13 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"{"')
+            r13 = nil
+          end
+          s12 << r13
+          if r13
+            r14 = _nt_S
+            s12 << r14
+            if r14
+              r15 = _nt_group
+              s12 << r15
+              if r15
+                r16 = _nt_S
+                s12 << r16
+                if r16
+                  if (match_len = has_terminal?("}", false, index))
+                    r17 = true
+                    @index += match_len
+                  else
+                    terminal_parse_failure('"}"')
+                    r17 = nil
+                  end
+                  s12 << r17
+                end
+              end
+            end
+          end
+          if s12.last
+            r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
+            r12.extend(Type24)
+            r12.extend(Type25)
+          else
+            @index = i12
+            r12 = nil
+          end
+          if r12
+            r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
+            r0 = r12
+          else
+            i18, s18 = index, []
+            if (match_len = has_terminal?("[", false, index))
+              r19 = true
+              @index += match_len
+            else
+              terminal_parse_failure('"["')
+              r19 = nil
+            end
+            s18 << r19
+            if r19
+              r20 = _nt_S
+              s18 << r20
+              if r20
+                r21 = _nt_group
+                s18 << r21
+                if r21
+                  r22 = _nt_S
+                  s18 << r22
+                  if r22
+                    if (match_len = has_terminal?("]", false, index))
+                      r23 = true
+                      @index += match_len
+                    else
+                      terminal_parse_failure('"]"')
+                      r23 = nil
+                    end
+                    s18 << r23
+                  end
+                end
+              end
+            end
+            if s18.last
+              r18 = instantiate_node(SyntaxNode,input, i18...index, s18)
+              r18.extend(Type26)
+              r18.extend(Type27)
+            else
+              @index = i18
+              r18 = nil
+            end
+            if r18
+              r18 = SyntaxNode.new(input, (index-1)...index) if r18 == true
+              r0 = r18
+            else
+              i24, s24 = index, []
+              if (match_len = has_terminal?("~", false, index))
+                r25 = true
+                @index += match_len
+              else
+                terminal_parse_failure('"~"')
+                r25 = nil
+              end
+              s24 << r25
+              if r25
+                r26 = _nt_S
+                s24 << r26
+                if r26
+                  r27 = _nt_typename
+                  s24 << r27
+                  if r27
+                    r29 = _nt_genericarg
+                    if r29
+                      r28 = r29
+                    else
+                      r28 = instantiate_node(SyntaxNode,input, index...index)
+                    end
+                    s24 << r28
+                  end
+                end
+              end
+              if s24.last
+                r24 = instantiate_node(SyntaxNode,input, i24...index, s24)
+                r24.extend(Type28)
+                r24.extend(Type29)
+              else
+                @index = i24
+                r24 = nil
+              end
+              if r24
+                r24 = SyntaxNode.new(input, (index-1)...index) if r24 == true
+                r0 = r24
+              else
+                i30, s30 = index, []
+                if (match_len = has_terminal?("&", false, index))
+                  r31 = true
+                  @index += match_len
+                else
+                  terminal_parse_failure('"&"')
+                  r31 = nil
+                end
+                s30 << r31
+                if r31
+                  r32 = _nt_S
+                  s30 << r32
+                  if r32
+                    if (match_len = has_terminal?("(", false, index))
+                      r33 = true
+                      @index += match_len
+                    else
+                      terminal_parse_failure('"("')
+                      r33 = nil
+                    end
+                    s30 << r33
+                    if r33
+                      r34 = _nt_S
+                      s30 << r34
+                      if r34
+                        r35 = _nt_group
+                        s30 << r35
+                        if r35
+                          r36 = _nt_S
+                          s30 << r36
+                          if r36
+                            if (match_len = has_terminal?(")", false, index))
+                              r37 = true
+                              @index += match_len
+                            else
+                              terminal_parse_failure('")"')
+                              r37 = nil
+                            end
+                            s30 << r37
+                          end
+                        end
+                      end
+                    end
+                  end
+                end
+                if s30.last
+                  r30 = instantiate_node(SyntaxNode,input, i30...index, s30)
+                  r30.extend(Type210)
+                  r30.extend(Type211)
+                else
+                  @index = i30
+                  r30 = nil
+                end
+                if r30
+                  r30 = SyntaxNode.new(input, (index-1)...index) if r30 == true
+                  r0 = r30
+                else
+                  i38, s38 = index, []
+                  if (match_len = has_terminal?("&", false, index))
+                    r39 = true
+                    @index += match_len
+                  else
+                    terminal_parse_failure('"&"')
+                    r39 = nil
+                  end
+                  s38 << r39
+                  if r39
+                    r40 = _nt_S
+                    s38 << r40
+                    if r40
+                      r41 = _nt_groupname
+                      s38 << r41
+                      if r41
+                        r43 = _nt_genericarg
+                        if r43
+                          r42 = r43
+                        else
+                          r42 = instantiate_node(SyntaxNode,input, index...index)
+                        end
+                        s38 << r42
+                      end
+                    end
+                  end
+                  if s38.last
+                    r38 = instantiate_node(SyntaxNode,input, i38...index, s38)
+                    r38.extend(Type212)
+                    r38.extend(Type213)
+                  else
+                    @index = i38
+                    r38 = nil
+                  end
+                  if r38
+                    r38 = SyntaxNode.new(input, (index-1)...index) if r38 == true
+                    r0 = r38
+                  else
+                    i44, s44 = index, []
+                    if (match_len = has_terminal?("#", false, index))
+                      r45 = true
+                      @index += match_len
+                    else
+                      terminal_parse_failure('"#"')
+                      r45 = nil
+                    end
+                    s44 << r45
+                    if r45
+                      if (match_len = has_terminal?("6", false, index))
+                        r46 = true
+                        @index += match_len
+                      else
+                        terminal_parse_failure('"6"')
+                        r46 = nil
+                      end
+                      s44 << r46
+                      if r46
+                        i48, s48 = index, []
+                        if (match_len = has_terminal?(".", false, index))
+                          r49 = true
+                          @index += match_len
+                        else
+                          terminal_parse_failure('"."')
+                          r49 = nil
+                        end
+                        s48 << r49
+                        if r49
+                          r50 = _nt_uint
+                          s48 << r50
+                        end
+                        if s48.last
+                          r48 = instantiate_node(SyntaxNode,input, i48...index, s48)
+                          r48.extend(Type214)
+                        else
+                          @index = i48
+                          r48 = nil
+                        end
+                        if r48
+                          r47 = r48
+                        else
+                          r47 = instantiate_node(SyntaxNode,input, index...index)
+                        end
+                        s44 << r47
+                        if r47
+                          if (match_len = has_terminal?("(", false, index))
+                            r51 = true
+                            @index += match_len
+                          else
+                            terminal_parse_failure('"("')
+                            r51 = nil
+                          end
+                          s44 << r51
+                          if r51
+                            r52 = _nt_S
+                            s44 << r52
+                            if r52
+                              r53 = _nt_type
+                              s44 << r53
+                              if r53
+                                r54 = _nt_S
+                                s44 << r54
+                                if r54
+                                  if (match_len = has_terminal?(")", false, index))
+                                    r55 = true
+                                    @index += match_len
+                                  else
+                                    terminal_parse_failure('")"')
+                                    r55 = nil
+                                  end
+                                  s44 << r55
+                                end
+                              end
+                            end
+                          end
+                        end
+                      end
+                    end
+                    if s44.last
+                      r44 = instantiate_node(SyntaxNode,input, i44...index, s44)
+                      r44.extend(Type215)
+                      r44.extend(Type216)
+                    else
+                      @index = i44
+                      r44 = nil
+                    end
+                    if r44
+                      r44 = SyntaxNode.new(input, (index-1)...index) if r44 == true
+                      r0 = r44
+                    else
+                      i56, s56 = index, []
+                      if (match_len = has_terminal?("#", false, index))
+                        r57 = true
+                        @index += match_len
+                      else
+                        terminal_parse_failure('"#"')
+                        r57 = nil
+                      end
+                      s56 << r57
+                      if r57
+                        r58 = _nt_DIGIT
+                        s56 << r58
+                        if r58
+                          i60, s60 = index, []
+                          if (match_len = has_terminal?(".", false, index))
+                            r61 = true
+                            @index += match_len
+                          else
+                            terminal_parse_failure('"."')
+                            r61 = nil
+                          end
+                          s60 << r61
+                          if r61
+                            r62 = _nt_uint
+                            s60 << r62
+                          end
+                          if s60.last
+                            r60 = instantiate_node(SyntaxNode,input, i60...index, s60)
+                            r60.extend(Type217)
+                          else
+                            @index = i60
+                            r60 = nil
+                          end
+                          if r60
+                            r59 = r60
+                          else
+                            r59 = instantiate_node(SyntaxNode,input, index...index)
+                          end
+                          s56 << r59
+                        end
+                      end
+                      if s56.last
+                        r56 = instantiate_node(SyntaxNode,input, i56...index, s56)
+                        r56.extend(Type218)
+                        r56.extend(Type219)
+                      else
+                        @index = i56
+                        r56 = nil
+                      end
+                      if r56
+                        r56 = SyntaxNode.new(input, (index-1)...index) if r56 == true
+                        r0 = r56
+                      else
+                        if (match_len = has_terminal?("#", false, index))
+                          r63 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+                          r63.extend(Type220)
+                          @index += match_len
+                        else
+                          terminal_parse_failure('"#"')
+                          r63 = nil
+                        end
+                        if r63
+                          r63 = SyntaxNode.new(input, (index-1)...index) if r63 == true
+                          r0 = r63
+                        else
+                          @index = i0
+                          r0 = nil
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    node_cache[:type2][start_index] = r0
+
+    r0
+  end
+
+  def _nt_rangeop
+    start_index = index
+    if node_cache[:rangeop].has_key?(index)
+      cached = node_cache[:rangeop][index]
+      if cached
+        node_cache[:rangeop][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?("...", false, index))
+      r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      @index += match_len
+    else
+      terminal_parse_failure('"..."')
+      r1 = nil
+    end
+    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))
+        @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[:rangeop][start_index] = r0
+
+    r0
+  end
+
+  module Ctlop0
+    def id
+      elements[1]
+    end
+  end
+
+  def _nt_ctlop
+    start_index = index
+    if node_cache[:ctlop].has_key?(index)
+      cached = node_cache[:ctlop][index]
+      if cached
+        node_cache[:ctlop][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
+      r2 = _nt_id
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Ctlop0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:ctlop][start_index] = r0
+
+    r0
+  end
+
+  module Group0
+    def S1
+      elements[0]
+    end
+
+    def S2
+      elements[2]
+    end
+
+    def grpchoice
+      elements[3]
+    end
+  end
+
+  module Group1
+    def grpchoice
+      elements[0]
+    end
+
+  end
+
+  module Group2
+    def ast
+      wrapop("gcho", grpchoice, elements[1].elements.map(&:grpchoice))
+    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, []
+    r1 = _nt_grpchoice
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        i3, s3 = index, []
+        r4 = _nt_S
+        s3 << r4
+        if r4
+          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
+          s3 << r5
+          if r5
+            r6 = _nt_S
+            s3 << r6
+            if r6
+              r7 = _nt_grpchoice
+              s3 << r7
+            end
+          end
+        end
+        if s3.last
+          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+          r3.extend(Group0)
+        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(Group1)
+      r0.extend(Group2)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:group][start_index] = r0
+
+    r0
+  end
+
+  module Grpchoice0
+    def grpent
+      elements[0]
+    end
+
+    def optcom
+      elements[1]
+    end
+  end
+
+  module Grpchoice1
+    def ast
+      wrapop0("seq", elements.map(&:grpent)) #[0].elements)
+    end
+  end
+
+  def _nt_grpchoice
+    start_index = index
+    if node_cache[:grpchoice].has_key?(index)
+      cached = node_cache[:grpchoice][index]
+      if cached
+        node_cache[:grpchoice][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, s1 = index, []
+      r2 = _nt_grpent
+      s1 << r2
+      if r2
+        r3 = _nt_optcom
+        s1 << r3
+      end
+      if s1.last
+        r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+        r1.extend(Grpchoice0)
+      else
+        @index = i1
+        r1 = nil
+      end
+      if r1
+        s0 << r1
+      else
+        break
+      end
+    end
+    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+    r0.extend(Grpchoice1)
+    r0.extend(Grpchoice1)
+
+    node_cache[:grpchoice][start_index] = r0
+
+    r0
+  end
+
+  module Grpent0
+    def memberkey
+      elements[0]
+    end
+
+    def S
+      elements[1]
+    end
+  end
+
+  module Grpent1
+    def type
+      elements[2]
+    end
+  end
+
+  module Grpent2
+    def ast() repwrap(elements[0], ["mem", elements[1].elements ? elements[1].memberkey.ast : nil, elements[2].ast]) end
+  end
+
+  module Grpent3
+    def groupname
+      elements[1]
+    end
+
+  end
+
+  module Grpent4
+    def S1
+      elements[2]
+    end
+
+    def group
+      elements[3]
+    end
+
+    def S2
+      elements[4]
+    end
+
+  end
+
+  module Grpent5
+    def ast() repwrap(elements[0], group.ast()) end
+  end
+
+  def _nt_grpent
+    start_index = index
+    if node_cache[:grpent].has_key?(index)
+      cached = node_cache[:grpent][index]
+      if cached
+        node_cache[:grpent][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    i1, s1 = index, []
+    r3 = _nt_occurs
+    if r3
+      r2 = r3
+    else
+      r2 = instantiate_node(SyntaxNode,input, index...index)
+    end
+    s1 << r2
+    if r2
+      i5, s5 = index, []
+      r6 = _nt_memberkey
+      s5 << r6
+      if r6
+        r7 = _nt_S
+        s5 << r7
+      end
+      if s5.last
+        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+        r5.extend(Grpent0)
+      else
+        @index = i5
+        r5 = nil
+      end
+      if r5
+        r4 = r5
+      else
+        r4 = instantiate_node(SyntaxNode,input, index...index)
+      end
+      s1 << r4
+      if r4
+        r8 = _nt_type
+        s1 << r8
+      end
+    end
+    if s1.last
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+      r1.extend(Grpent1)
+      r1.extend(Grpent2)
+    else
+      @index = i1
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      i9, s9 = index, []
+      r11 = _nt_occurs
+      if r11
+        r10 = r11
+      else
+        r10 = instantiate_node(SyntaxNode,input, index...index)
+      end
+      s9 << r10
+      if r10
+        r12 = _nt_groupname
+        s9 << r12
+        if r12
+          r14 = _nt_genericarg
+          if r14
+            r13 = r14
+          else
+            r13 = instantiate_node(SyntaxNode,input, index...index)
+          end
+          s9 << r13
+        end
+      end
+      if s9.last
+        r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
+        r9.extend(Grpent3)
+      else
+        @index = i9
+        r9 = nil
+      end
+      if r9
+        r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
+        r0 = r9
+      else
+        i15, s15 = index, []
+        r17 = _nt_occurs
+        if r17
+          r16 = r17
+        else
+          r16 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s15 << r16
+        if r16
+          if (match_len = has_terminal?("(", false, index))
+            r18 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"("')
+            r18 = nil
+          end
+          s15 << r18
+          if r18
+            r19 = _nt_S
+            s15 << r19
+            if r19
+              r20 = _nt_group
+              s15 << r20
+              if r20
+                r21 = _nt_S
+                s15 << r21
+                if r21
+                  if (match_len = has_terminal?(")", false, index))
+                    r22 = true
+                    @index += match_len
+                  else
+                    terminal_parse_failure('")"')
+                    r22 = nil
+                  end
+                  s15 << r22
+                end
+              end
+            end
+          end
+        end
+        if s15.last
+          r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
+          r15.extend(Grpent4)
+          r15.extend(Grpent5)
+        else
+          @index = i15
+          r15 = nil
+        end
+        if r15
+          r15 = SyntaxNode.new(input, (index-1)...index) if r15 == true
+          r0 = r15
+        else
+          @index = i0
+          r0 = nil
+        end
+      end
+    end
+
+    node_cache[:grpent][start_index] = r0
+
+    r0
+  end
+
+  module Memberkey0
+    def S
+      elements[1]
+    end
+  end
+
+  module Memberkey1
+    def type1
+      elements[0]
+    end
+
+    def S
+      elements[1]
+    end
+
+  end
+
+  module Memberkey2
+    def ast() type1.ast end
+  end
+
+  module Memberkey3
+    def bareword
+      elements[0]
+    end
+
+    def S
+      elements[1]
+    end
+
+  end
+
+  module Memberkey4
+    def ast() ["text", bareword.text_value] end
+  end
+
+  module Memberkey5
+    def value
+      elements[0]
+    end
+
+    def S
+      elements[1]
+    end
+
+  end
+
+  module Memberkey6
+    def ast() value.ast end
+  end
+
+  def _nt_memberkey
+    start_index = index
+    if node_cache[:memberkey].has_key?(index)
+      cached = node_cache[:memberkey][index]
+      if cached
+        node_cache[:memberkey][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    i1, s1 = index, []
+    r2 = _nt_type1
+    s1 << r2
+    if r2
+      r3 = _nt_S
+      s1 << r3
+      if r3
+        i5, s5 = index, []
+        if (match_len = has_terminal?("^", false, index))
+          r6 = true
+          @index += match_len
+        else
+          terminal_parse_failure('"^"')
+          r6 = nil
+        end
+        s5 << r6
+        if r6
+          r7 = _nt_S
+          s5 << r7
+        end
+        if s5.last
+          r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+          r5.extend(Memberkey0)
+        else
+          @index = i5
+          r5 = nil
+        end
+        if r5
+          r4 = r5
+        else
+          r4 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s1 << r4
+        if r4
+          if (match_len = has_terminal?("=>", false, index))
+            r8 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+            @index += match_len
+          else
+            terminal_parse_failure('"=>"')
+            r8 = nil
+          end
+          s1 << r8
+        end
+      end
+    end
+    if s1.last
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+      r1.extend(Memberkey1)
+      r1.extend(Memberkey2)
+    else
+      @index = i1
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      i9, s9 = index, []
+      r10 = _nt_bareword
+      s9 << r10
+      if r10
+        r11 = _nt_S
+        s9 << r11
+        if r11
+          if (match_len = has_terminal?(":", false, index))
+            r12 = true
+            @index += match_len
+          else
+            terminal_parse_failure('":"')
+            r12 = nil
+          end
+          s9 << r12
+        end
+      end
+      if s9.last
+        r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
+        r9.extend(Memberkey3)
+        r9.extend(Memberkey4)
+      else
+        @index = i9
+        r9 = nil
+      end
+      if r9
+        r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
+        r0 = r9
+      else
+        i13, s13 = index, []
+        r14 = _nt_value
+        s13 << r14
+        if r14
+          r15 = _nt_S
+          s13 << r15
+          if r15
+            if (match_len = has_terminal?(":", false, index))
+              r16 = true
+              @index += match_len
+            else
+              terminal_parse_failure('":"')
+              r16 = nil
+            end
+            s13 << r16
+          end
+        end
+        if s13.last
+          r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
+          r13.extend(Memberkey5)
+          r13.extend(Memberkey6)
+        else
+          @index = i13
+          r13 = nil
+        end
+        if r13
+          r13 = SyntaxNode.new(input, (index-1)...index) if r13 == true
+          r0 = r13
+        else
+          @index = i0
+          r0 = nil
+        end
+      end
+    end
+
+    node_cache[:memberkey][start_index] = r0
+
+    r0
+  end
+
+  def _nt_bareword
+    start_index = index
+    if node_cache[:bareword].has_key?(index)
+      cached = node_cache[:bareword][index]
+      if cached
+        node_cache[:bareword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    r0 = _nt_id
+
+    node_cache[:bareword][start_index] = r0
+
+    r0
+  end
+
+  module Optcom0
+    def S
+      elements[1]
+    end
+  end
+
+  module Optcom1
+    def S
+      elements[0]
+    end
+
+  end
+
+  def _nt_optcom
+    start_index = index
+    if node_cache[:optcom].has_key?(index)
+      cached = node_cache[:optcom][index]
+      if cached
+        node_cache[:optcom][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_S
+    s0 << r1
+    if r1
+      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
+        r5 = _nt_S
+        s3 << r5
+      end
+      if s3.last
+        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+        r3.extend(Optcom0)
+      else
+        @index = i3
+        r3 = nil
+      end
+      if r3
+        r2 = r3
+      else
+        r2 = instantiate_node(SyntaxNode,input, index...index)
+      end
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Optcom1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:optcom][start_index] = r0
+
+    r0
+  end
+
+  module Occurs0
+    def occur
+      elements[0]
+    end
+
+    def S
+      elements[1]
+    end
+  end
+
+  module Occurs1
+    def ast() elements[0].ast end
+  end
+
+  def _nt_occurs
+    start_index = index
+    if node_cache[:occurs].has_key?(index)
+      cached = node_cache[:occurs][index]
+      if cached
+        node_cache[:occurs][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_occur
+    s0 << r1
+    if r1
+      r2 = _nt_S
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Occurs0)
+      r0.extend(Occurs1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:occurs][start_index] = r0
+
+    r0
+  end
+
+  module Occur0
+  end
+
+  module Occur1
+    def ast() [tvtoi(elements[0], 0), tvtoi(elements[2], false)] end
+  end
+
+  module Occur2
+    def ast() [1, false] end
+  end
+
+  module Occur3
+    def ast() [0, 1] end
+  end
+
+  def _nt_occur
+    start_index = index
+    if node_cache[:occur].has_key?(index)
+      cached = node_cache[:occur][index]
+      if cached
+        node_cache[:occur][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    i1, s1 = index, []
+    r3 = _nt_uint
+    if r3
+      r2 = r3
+    else
+      r2 = instantiate_node(SyntaxNode,input, index...index)
+    end
+    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
+        r6 = _nt_uint
+        if r6
+          r5 = r6
+        else
+          r5 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s1 << r5
+      end
+    end
+    if s1.last
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+      r1.extend(Occur0)
+      r1.extend(Occur1)
+    else
+      @index = i1
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      if (match_len = has_terminal?("+", false, index))
+        r7 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+        r7.extend(Occur2)
+        @index += match_len
+      else
+        terminal_parse_failure('"+"')
+        r7 = nil
+      end
+      if r7
+        r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
+        r0 = r7
+      else
+        if (match_len = has_terminal?("?", false, index))
+          r8 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+          r8.extend(Occur3)
+          @index += match_len
+        else
+          terminal_parse_failure('"?"')
+          r8 = nil
+        end
+        if r8
+          r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
+          r0 = r8
+        else
+          @index = i0
+          r0 = nil
+        end
+      end
+    end
+
+    node_cache[:occur][start_index] = r0
+
+    r0
+  end
+
+  module Uint0
+    def DIGIT1
+      elements[0]
+    end
+
+  end
+
+  module Uint1
+  end
+
+  module Uint2
+  end
+
+  def _nt_uint
+    start_index = index
+    if node_cache[:uint].has_key?(index)
+      cached = node_cache[:uint][index]
+      if cached
+        node_cache[:uint][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    i1, s1 = index, []
+    r2 = _nt_DIGIT1
+    s1 << r2
+    if r2
+      s3, i3 = [], index
+      loop do
+        r4 = _nt_DIGIT
+        if r4
+          s3 << r4
+        else
+          break
+        end
+      end
+      r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+      s1 << r3
+    end
+    if s1.last
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+      r1.extend(Uint0)
+    else
+      @index = i1
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      i5, s5 = index, []
+      if (match_len = has_terminal?("0x", :insens, index))
+        r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+        @index += match_len
+      else
+        terminal_parse_failure('"0x"')
+        r6 = nil
+      end
+      s5 << r6
+      if r6
+        s7, i7 = [], index
+        loop do
+          r8 = _nt_HEXDIG
+          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
+        s5 << r7
+      end
+      if s5.last
+        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+        r5.extend(Uint1)
+      else
+        @index = i5
+        r5 = nil
+      end
+      if r5
+        r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+        r0 = r5
+      else
+        i9, s9 = index, []
+        if (match_len = has_terminal?("0b", :insens, index))
+          r10 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+          @index += match_len
+        else
+          terminal_parse_failure('"0b"')
+          r10 = nil
+        end
+        s9 << r10
+        if r10
+          s11, i11 = [], index
+          loop do
+            r12 = _nt_BINDIG
+            if r12
+              s11 << r12
+            else
+              break
+            end
+          end
+          if s11.empty?
+            @index = i11
+            r11 = nil
+          else
+            r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
+          end
+          s9 << r11
+        end
+        if s9.last
+          r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
+          r9.extend(Uint2)
+        else
+          @index = i9
+          r9 = nil
+        end
+        if r9
+          r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
+          r0 = r9
+        else
+          if (match_len = has_terminal?("0", false, index))
+            r13 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"0"')
+            r13 = nil
+          end
+          if r13
+            r13 = SyntaxNode.new(input, (index-1)...index) if r13 == true
+            r0 = r13
+          else
+            @index = i0
+            r0 = nil
+          end
+        end
+      end
+    end
+
+    node_cache[:uint][start_index] = r0
+
+    r0
+  end
+
+  module Value0
+    def ast() ["number", text_value] end
+  end
+
+  def _nt_value
+    start_index = index
+    if node_cache[:value].has_key?(index)
+      cached = node_cache[:value][index]
+      if cached
+        node_cache[:value][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_number
+    r1.extend(Value0)
+    r1.extend(Value0)
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      r2 = _nt_text
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        r3 = _nt_bytes
+        if r3
+          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+          r0 = r3
+        else
+          @index = i0
+          r0 = nil
+        end
+      end
+    end
+
+    node_cache[:value][start_index] = r0
+
+    r0
+  end
+
+  module Int0
+    def uint
+      elements[1]
+    end
+  end
+
+  def _nt_int
+    start_index = index
+    if node_cache[:int].has_key?(index)
+      cached = node_cache[:int][index]
+      if cached
+        node_cache[:int][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))
+      r2 = true
+      @index += match_len
+    else
+      terminal_parse_failure('"-"')
+      r2 = nil
+    end
+    if r2
+      r1 = r2
+    else
+      r1 = instantiate_node(SyntaxNode,input, index...index)
+    end
+    s0 << r1
+    if r1
+      r3 = _nt_uint
+      s0 << r3
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Int0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:int][start_index] = r0
+
+    r0
+  end
+
+  module Number0
+    def fraction
+      elements[1]
+    end
+  end
+
+  module Number1
+    def exponent
+      elements[1]
+    end
+  end
+
+  module Number2
+    def int
+      elements[0]
+    end
+
+  end
+
+  def _nt_number
+    start_index = index
+    if node_cache[:number].has_key?(index)
+      cached = node_cache[:number][index]
+      if cached
+        node_cache[:number][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_hexfloat
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      i2, s2 = index, []
+      r3 = _nt_int
+      s2 << r3
+      if r3
+        i5, s5 = index, []
+        if (match_len = has_terminal?(".", false, index))
+          r6 = true
+          @index += match_len
+        else
+          terminal_parse_failure('"."')
+          r6 = nil
+        end
+        s5 << r6
+        if r6
+          r7 = _nt_fraction
+          s5 << r7
+        end
+        if s5.last
+          r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+          r5.extend(Number0)
+        else
+          @index = i5
+          r5 = nil
+        end
+        if r5
+          r4 = r5
+        else
+          r4 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s2 << r4
+        if r4
+          i9, s9 = index, []
+          if (match_len = has_terminal?("e", :insens, index))
+            r10 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+            @index += match_len
+          else
+            terminal_parse_failure('"e"')
+            r10 = nil
+          end
+          s9 << r10
+          if r10
+            r11 = _nt_exponent
+            s9 << r11
+          end
+          if s9.last
+            r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
+            r9.extend(Number1)
+          else
+            @index = i9
+            r9 = nil
+          end
+          if r9
+            r8 = r9
+          else
+            r8 = instantiate_node(SyntaxNode,input, index...index)
+          end
+          s2 << r8
+        end
+      end
+      if s2.last
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+        r2.extend(Number2)
+      else
+        @index = i2
+        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[:number][start_index] = r0
+
+    r0
+  end
+
+  module Hexfloat0
+  end
+
+  module Hexfloat1
+    def exponent
+      elements[5]
+    end
+  end
+
+  def _nt_hexfloat
+    start_index = index
+    if node_cache[:hexfloat].has_key?(index)
+      cached = node_cache[:hexfloat][index]
+      if cached
+        node_cache[:hexfloat][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))
+      r2 = true
+      @index += match_len
+    else
+      terminal_parse_failure('"-"')
+      r2 = nil
+    end
+    if r2
+      r1 = r2
+    else
+      r1 = instantiate_node(SyntaxNode,input, index...index)
+    end
+    s0 << r1
+    if r1
+      if (match_len = has_terminal?("0x", :insens, index))
+        r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+        @index += match_len
+      else
+        terminal_parse_failure('"0x"')
+        r3 = nil
+      end
+      s0 << r3
+      if r3
+        s4, i4 = [], index
+        loop do
+          r5 = _nt_HEXDIG
+          if r5
+            s4 << r5
+          else
+            break
+          end
+        end
+        if s4.empty?
+          @index = i4
+          r4 = nil
+        else
+          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+        end
+        s0 << r4
+        if r4
+          i7, s7 = index, []
+          if (match_len = has_terminal?(".", false, index))
+            r8 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"."')
+            r8 = nil
+          end
+          s7 << r8
+          if r8
+            s9, i9 = [], index
+            loop do
+              r10 = _nt_HEXDIG
+              if r10
+                s9 << r10
+              else
+                break
+              end
+            end
+            if s9.empty?
+              @index = i9
+              r9 = nil
+            else
+              r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
+            end
+            s7 << r9
+          end
+          if s7.last
+            r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
+            r7.extend(Hexfloat0)
+          else
+            @index = i7
+            r7 = nil
+          end
+          if r7
+            r6 = r7
+          else
+            r6 = instantiate_node(SyntaxNode,input, index...index)
+          end
+          s0 << r6
+          if r6
+            if (match_len = has_terminal?("p", :insens, index))
+              r11 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+              @index += match_len
+            else
+              terminal_parse_failure('"p"')
+              r11 = nil
+            end
+            s0 << r11
+            if r11
+              r12 = _nt_exponent
+              s0 << r12
+            end
+          end
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Hexfloat1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:hexfloat][start_index] = r0
+
+    r0
+  end
+
+  def _nt_fraction
+    start_index = index
+    if node_cache[:fraction].has_key?(index)
+      cached = node_cache[:fraction][index]
+      if cached
+        node_cache[:fraction][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      r1 = _nt_DIGIT
+      if r1
+        s0 << r1
+      else
+        break
+      end
+    end
+    if s0.empty?
+      @index = i0
+      r0 = nil
+    else
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+    end
+
+    node_cache[:fraction][start_index] = r0
+
+    r0
+  end
+
+  module Exponent0
+  end
+
+  def _nt_exponent
+    start_index = index
+    if node_cache[:exponent].has_key?(index)
+      cached = node_cache[:exponent][index]
+      if cached
+        node_cache[:exponent][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    i2 = index
+    if (match_len = has_terminal?("+", false, index))
+      r3 = true
+      @index += match_len
+    else
+      terminal_parse_failure('"+"')
+      r3 = nil
+    end
+    if r3
+      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+      r2 = r3
+    else
+      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
+        r2 = r4
+      else
+        @index = i2
+        r2 = nil
+      end
+    end
+    if r2
+      r1 = r2
+    else
+      r1 = instantiate_node(SyntaxNode,input, index...index)
+    end
+    s0 << r1
+    if r1
+      s5, i5 = [], index
+      loop do
+        r6 = _nt_DIGIT
+        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
+      s0 << r5
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Exponent0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:exponent][start_index] = r0
+
+    r0
+  end
+
+  module Text0
+  end
+
+  module Text1
+    def ast() ["text", elements[1].elements.map(&:ast).join] end
+  end
+
+  def _nt_text
+    start_index = index
+    if node_cache[:text].has_key?(index)
+      cached = node_cache[:text][index]
+      if cached
+        node_cache[:text][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_SCHAR
+        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(Text0)
+      r0.extend(Text1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:text][start_index] = r0
+
+    r0
+  end
+
+  module SCHAR0
+    def ast() text_value end
+  end
+
+  module SCHAR1
+    def ast() text_value end
+  end
+
+  module SCHAR2
+    def ast() text_value end
+  end
+
+  module SCHAR3
+    def ast() text_value end
+  end
+
+  def _nt_SCHAR
+    start_index = index
+    if node_cache[:SCHAR].has_key?(index)
+      cached = node_cache[:SCHAR][index]
+      if cached
+        node_cache[:SCHAR][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    if has_terminal?(@regexps[gr = '\A[\\ -!]'] ||= Regexp.new(gr), :regexp, index)
+      r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      r1.extend(SCHAR0)
+      r1.extend(SCHAR0)
+      @index += 1
+    else
+      terminal_parse_failure('[\\ -!]')
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      if has_terminal?(@regexps[gr = '\A[\\#-\\[]'] ||= Regexp.new(gr), :regexp, index)
+        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        r2.extend(SCHAR1)
+        r2.extend(SCHAR1)
+        @index += 1
+      else
+        terminal_parse_failure('[\\#-\\[]')
+        r2 = nil
+      end
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        if has_terminal?(@regexps[gr = '\A[\\]-~]'] ||= Regexp.new(gr), :regexp, index)
+          r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          r3.extend(SCHAR2)
+          r3.extend(SCHAR2)
+          @index += 1
+        else
+          terminal_parse_failure('[\\]-~]')
+          r3 = nil
+        end
+        if r3
+          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+          r0 = r3
+        else
+          if has_terminal?(@regexps[gr = '\A[€-􏿽]'] ||= Regexp.new(gr), :regexp, index)
+            r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            r4.extend(SCHAR3)
+            r4.extend(SCHAR3)
+            @index += 1
+          else
+            terminal_parse_failure('[€-􏿽]')
+            r4 = nil
+          end
+          if r4
+            r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+            r0 = r4
+          else
+            r5 = _nt_SESC
+            if r5
+              r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+              r0 = r5
+            else
+              @index = i0
+              r0 = nil
+            end
+          end
+        end
+      end
+    end
+
+    node_cache[:SCHAR][start_index] = r0
+
+    r0
+  end
+
+  module SESC0
+  end
+
+  module SESC1
+    def ast() JSON.load("\"\\#{elements[1].text_value}\"") end
+  end
+
+  def _nt_SESC
+    start_index = index
+    if node_cache[:SESC].has_key?(index)
+      cached = node_cache[:SESC][index]
+      if cached
+        node_cache[:SESC][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
+      if has_terminal?(@regexps[gr = '\A[\\ -~]'] ||= Regexp.new(gr), :regexp, index)
+        r3 = true
+        @index += 1
+      else
+        terminal_parse_failure('[\\ -~]')
+        r3 = nil
+      end
+      if r3
+        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+        r2 = r3
+      else
+        if has_terminal?(@regexps[gr = '\A[€-􏿽]'] ||= Regexp.new(gr), :regexp, index)
+          r4 = true
+          @index += 1
+        else
+          terminal_parse_failure('[€-􏿽]')
+          r4 = nil
+        end
+        if r4
+          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+          r2 = r4
+        else
+          @index = i2
+          r2 = nil
+        end
+      end
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(SESC0)
+      r0.extend(SESC1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:SESC][start_index] = r0
+
+    r0
+  end
+
+  module Bytes0
+  end
+
+  module Bytes1
+    def ast() ["bytes", text_value] end
+  end
+
+  def _nt_bytes
+    start_index = index
+    if node_cache[:bytes].has_key?(index)
+      cached = node_cache[:bytes][index]
+      if cached
+        node_cache[:bytes][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r2 = _nt_bsqual
+    if r2
+      r1 = r2
+    else
+      r1 = instantiate_node(SyntaxNode,input, index...index)
+    end
+    s0 << r1
+    if r1
+      if (match_len = has_terminal?("'", false, index))
+        r3 = true
+        @index += match_len
+      else
+        terminal_parse_failure('"\'"')
+        r3 = nil
+      end
+      s0 << r3
+      if r3
+        s4, i4 = [], index
+        loop do
+          r5 = _nt_BCHAR
+          if r5
+            s4 << r5
+          else
+            break
+          end
+        end
+        r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+        s0 << r4
+        if r4
+          if (match_len = has_terminal?("'", false, index))
+            r6 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"\'"')
+            r6 = nil
+          end
+          s0 << r6
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Bytes0)
+      r0.extend(Bytes1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:bytes][start_index] = r0
+
+    r0
+  end
+
+  def _nt_BCHAR
+    start_index = index
+    if node_cache[:BCHAR].has_key?(index)
+      cached = node_cache[:BCHAR][index]
+      if cached
+        node_cache[:BCHAR][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    if has_terminal?(@regexps[gr = '\A[\\ -&]'] ||= Regexp.new(gr), :regexp, index)
+      r1 = true
+      @index += 1
+    else
+      terminal_parse_failure('[\\ -&]')
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      if has_terminal?(@regexps[gr = '\A[\\(-\\[]'] ||= Regexp.new(gr), :regexp, index)
+        r2 = true
+        @index += 1
+      else
+        terminal_parse_failure('[\\(-\\[]')
+        r2 = nil
+      end
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        if has_terminal?(@regexps[gr = '\A[\\]-􏿽]'] ||= Regexp.new(gr), :regexp, index)
+          r3 = true
+          @index += 1
+        else
+          terminal_parse_failure('[\\]-􏿽]')
+          r3 = nil
+        end
+        if r3
+          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+          r0 = r3
+        else
+          r4 = _nt_SESC
+          if r4
+            r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+            r0 = r4
+          else
+            r5 = _nt_CRLF
+            if r5
+              r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+              r0 = r5
+            else
+              @index = i0
+              r0 = nil
+            end
+          end
+        end
+      end
+    end
+
+    node_cache[:BCHAR][start_index] = r0
+
+    r0
+  end
+
+  def _nt_bsqual
+    start_index = index
+    if node_cache[:bsqual].has_key?(index)
+      cached = node_cache[:bsqual][index]
+      if cached
+        node_cache[:bsqual][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?("h", :insens, index))
+      r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      @index += match_len
+    else
+      terminal_parse_failure('"h"')
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      if (match_len = has_terminal?("b64", :insens, index))
+        r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+        @index += match_len
+      else
+        terminal_parse_failure('"b64"')
+        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[:bsqual][start_index] = r0
+
+    r0
+  end
+
+  module Id0
+  end
+
+  module Id1
+    def EALPHA
+      elements[0]
+    end
+
+  end
+
+  def _nt_id
+    start_index = index
+    if node_cache[:id].has_key?(index)
+      cached = node_cache[:id][index]
+      if cached
+        node_cache[:id][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_EALPHA
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        i3, s3 = index, []
+        s4, i4 = [], index
+        loop do
+          i5 = index
+          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
+            r5 = r6
+          else
+            if (match_len = has_terminal?(".", false, index))
+              r7 = true
+              @index += match_len
+            else
+              terminal_parse_failure('"."')
+              r7 = nil
+            end
+            if r7
+              r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
+              r5 = r7
+            else
+              @index = i5
+              r5 = nil
+            end
+          end
+          if r5
+            s4 << r5
+          else
+            break
+          end
+        end
+        r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+        s3 << r4
+        if r4
+          i8 = index
+          r9 = _nt_EALPHA
+          if r9
+            r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
+            r8 = r9
+          else
+            r10 = _nt_DIGIT
+            if r10
+              r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
+              r8 = r10
+            else
+              @index = i8
+              r8 = nil
+            end
+          end
+          s3 << r8
+        end
+        if s3.last
+          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+          r3.extend(Id0)
+        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(Id1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:id][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
+
+    i0 = index
+    if has_terminal?(@regexps[gr = '\A[A-Z]'] ||= Regexp.new(gr), :regexp, index)
+      r1 = true
+      @index += 1
+    else
+      terminal_parse_failure('[A-Z]')
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      if has_terminal?(@regexps[gr = '\A[a-z]'] ||= Regexp.new(gr), :regexp, index)
+        r2 = true
+        @index += 1
+      else
+        terminal_parse_failure('[a-z]')
+        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[:ALPHA][start_index] = r0
+
+    r0
+  end
+
+  def _nt_EALPHA
+    start_index = index
+    if node_cache[:EALPHA].has_key?(index)
+      cached = node_cache[:EALPHA][index]
+      if cached
+        node_cache[:EALPHA][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_ALPHA
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      if (match_len = has_terminal?("@", false, index))
+        r2 = true
+        @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
+        if (match_len = has_terminal?("_", false, index))
+          r3 = true
+          @index += match_len
+        else
+          terminal_parse_failure('"_"')
+          r3 = nil
+        end
+        if r3
+          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+          r0 = r3
+        else
+          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
+            r0 = r4
+          else
+            @index = i0
+            r0 = nil
+          end
+        end
+      end
+    end
+
+    node_cache[:EALPHA][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_DIGIT1
+    start_index = index
+    if node_cache[:DIGIT1].has_key?(index)
+      cached = node_cache[:DIGIT1][index]
+      if cached
+        node_cache[:DIGIT1][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[1-9]'] ||= Regexp.new(gr), :regexp, index)
+      r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      terminal_parse_failure('[1-9]')
+      r0 = nil
+    end
+
+    node_cache[:DIGIT1][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 (match_len = has_terminal?("a", :insens, index))
+        r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+        @index += match_len
+      else
+        terminal_parse_failure('"A"')
+        r2 = nil
+      end
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        if (match_len = has_terminal?("b", :insens, index))
+          r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+          @index += match_len
+        else
+          terminal_parse_failure('"B"')
+          r3 = nil
+        end
+        if r3
+          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+          r0 = r3
+        else
+          if (match_len = has_terminal?("c", :insens, index))
+            r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+            @index += match_len
+          else
+            terminal_parse_failure('"C"')
+            r4 = nil
+          end
+          if r4
+            r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+            r0 = r4
+          else
+            if (match_len = has_terminal?("d", :insens, index))
+              r5 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+              @index += match_len
+            else
+              terminal_parse_failure('"D"')
+              r5 = nil
+            end
+            if r5
+              r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+              r0 = r5
+            else
+              if (match_len = has_terminal?("e", :insens, index))
+                r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+                @index += match_len
+              else
+                terminal_parse_failure('"E"')
+                r6 = nil
+              end
+              if r6
+                r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+                r0 = r6
+              else
+                if (match_len = has_terminal?("f", :insens, index))
+                  r7 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+                  @index += match_len
+                else
+                  terminal_parse_failure('"F"')
+                  r7 = nil
+                end
+                if r7
+                  r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
+                  r0 = r7
+                else
+                  @index = i0
+                  r0 = nil
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    node_cache[:HEXDIG][start_index] = r0
+
+    r0
+  end
+
+  def _nt_BINDIG
+    start_index = index
+    if node_cache[:BINDIG].has_key?(index)
+      cached = node_cache[:BINDIG][index]
+      if cached
+        node_cache[:BINDIG][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-1]'] ||= Regexp.new(gr), :regexp, index)
+      r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      terminal_parse_failure('[0-1]')
+      r0 = nil
+    end
+
+    node_cache[:BINDIG][start_index] = r0
+
+    r0
+  end
+
+  def _nt_S
+    start_index = index
+    if node_cache[:S].has_key?(index)
+      cached = node_cache[:S][index]
+      if cached
+        node_cache[:S][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      r1 = _nt_WS
+      if r1
+        s0 << r1
+      else
+        break
+      end
+    end
+    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+
+    node_cache[:S][start_index] = r0
+
+    r0
+  end
+
+  def _nt_WS
+    start_index = index
+    if node_cache[:WS].has_key?(index)
+      cached = node_cache[:WS][index]
+      if cached
+        node_cache[:WS][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_NL
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:WS][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_NL
+    start_index = index
+    if node_cache[:NL].has_key?(index)
+      cached = node_cache[:NL][index]
+      if cached
+        node_cache[: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
+    else
+      r2 = _nt_CRLF
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:NL][start_index] = r0
+
+    r0
+  end
+
+  module COMMENT0
+    def CRLF
+      elements[2]
+    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
+        r3 = _nt_PCHAR
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+      if r2
+        r4 = _nt_CRLF
+        s0 << r4
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(COMMENT0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:COMMENT][start_index] = r0
+
+    r0
+  end
+
+  def _nt_PCHAR
+    start_index = index
+    if node_cache[:PCHAR].has_key?(index)
+      cached = node_cache[:PCHAR][index]
+      if cached
+        node_cache[:PCHAR][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    if has_terminal?(@regexps[gr = '\A[\\ -~]'] ||= Regexp.new(gr), :regexp, index)
+      r1 = true
+      @index += 1
+    else
+      terminal_parse_failure('[\\ -~]')
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      if has_terminal?(@regexps[gr = '\A[€-􏿽]'] ||= Regexp.new(gr), :regexp, index)
+        r2 = true
+        @index += 1
+      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[:PCHAR][start_index] = r0
+
+    r0
+  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 = index
+    if (match_len = has_terminal?("\n", false, index))
+      r1 = true
+      @index += match_len
+    else
+      terminal_parse_failure('"\\n"')
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      if (match_len = has_terminal?("\r\n", false, index))
+        r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+        @index += match_len
+      else
+        terminal_parse_failure('"\\r\\n"')
+        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[:CRLF][start_index] = r0
+
+    r0
+  end
+
+end
+
+class CDDLParser < Treetop::Runtime::CompiledParser
+  include CDDL
+end
+