coral0 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 617764e826438c671e5b1ac86770c765647b08f5b8990f784255fd5f1c1cf053
+  data.tar.gz: 76e96c0d957d447227c9c1b4624391ae001576f94a6a48a50d41bea3b24b0144
+SHA512:
+  metadata.gz: 16330de9442bd3e5c992d226005f6ea44f7fff1b79af4a6df753867b181bfe632e3d7dd34db934f6859d0bca20fda92d30d47be4bfbc65d5ada732b735920047
+  data.tar.gz: ef487c9a7fad5119761447088f2456d0e53403a8b60a334ca675185f8b4a2bf59e1c2a9602e35596aaff7d1a782e331e9d697e927aa2a9886f7ee4fd9c513d15

data/bin/coral0

@@ -0,0 +1,109 @@
+#!/usr/bin/env ruby -KU
+require 'pp'
+require 'yaml'
+require 'treetop'
+require 'scanf'
+require 'time'
+require 'json'
+
+Encoding.default_external = Encoding::UTF_8
+
+require 'coral'
+
+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
+
+
+def process_text(input, output)
+  warn "* converting locally from CoRAL Text #{input} to CoRAL JSON #{output}" if $options.verbose
+  coral_file = File.read(input)
+  parser = CORALParser.new
+  ast = parser.parse coral_file
+  if ast
+    puts "Writing to #{output}."
+    File.open(output, "w") do |f|
+      # f.write JSON.pretty_generate(ast.ast)
+      PP.pp(ast.ast, f)
+    end
+  else
+    puts parser.failure_reason
+    parser.failure_reason =~ /^(Expected .+) after/m
+    puts "#{$1.gsub("\n", '<<<NEWLINE>>>')}:"
+    puts coral_file.lines.to_a[parser.failure_line - 1]
+    puts "#{'~' * (parser.failure_column - 1)}^"
+  end
+end
+
+require 'optparse'
+require 'ostruct'
+$options = OpenStruct.new
+
+op = OptionParser.new do |opts|
+  opts.banner = "Usage: coral0 [options] file.coral|file.coral-text|file.coral-json"
+
+  opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+    $options.verbose = v
+  end
+end
+op.parse!
+
+case ARGV.size
+when 1
+  fn = ARGV[0]
+  case fn
+  when /(.*)\.coral-text\z/
+    process_text(fn, "#$1.coral-json")
+  else
+    warn "Unknown file type: #{fn}"
+    exit 1
+  end
+else
+  puts op
+  exit 1
+end

data/coral0.gemspec

@@ -0,0 +1,16 @@
+Gem::Specification.new do |s|
+  s.name = "coral0"
+  s.version = "0.1.0"
+  s.summary = "Support tools for the CoRAL IoT format"
+  s.description = %q{Support tools for the CoRAL IoT format}
+  s.author = "Carsten Bormann"
+  s.email = "cabo@tzi.org"
+  s.license = "MIT"
+  s.homepage = "http://github.com/cabo/coral0"
+  s.files = Dir['lib/**/*.rb'] + %w(coral0.gemspec) + Dir['bin/*']
+  s.executables = Dir['bin/*'].map {|x| File.basename(x)}
+  s.required_ruby_version = '>= 2.3'
+  s.require_paths = ["lib"]
+  s.add_dependency('abnftt', '~> 0.1')
+  s.add_dependency('treetop')
+end

data/lib/coral.rb

@@ -0,0 +1,3454 @@
+# Encoding: UTF-8
+# Autogenerated from a Treetop grammar. Edits may be lost.
+
+
+module CORAL
+  include Treetop::Runtime
+
+  def root
+    @root ||= :body
+  end
+
+  module Body0
+    def S
+      elements[1]
+    end
+  end
+
+  module Body1
+    def S
+      elements[0]
+    end
+
+  end
+
+  module Body2
+    def ast
+      ["coral", *elements[1].elements.map{|el| el.elements[0].ast}]
+    end
+  end
+
+  def _nt_body
+    start_index = index
+    if node_cache[:body].has_key?(index)
+      cached = node_cache[:body][index]
+      if cached
+        node_cache[:body][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, []
+        i4 = index
+        r5 = _nt_link
+        if r5
+          r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+          r4 = r5
+        else
+          r6 = _nt_form
+          if r6
+            r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+            r4 = r6
+          else
+            r7 = _nt_representation
+            if r7
+              r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
+              r4 = r7
+            else
+              r8 = _nt_directive
+              if r8
+                r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
+                r4 = r8
+              else
+                @index = i4
+                r4 = nil
+              end
+            end
+          end
+        end
+        s3 << r4
+        if r4
+          r9 = _nt_S
+          s3 << r9
+        end
+        if s3.last
+          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+          r3.extend(Body0)
+        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(Body1)
+      r0.extend(Body2)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:body][start_index] = r0
+
+    r0
+  end
+
+  module Link0
+    def S1
+      elements[0]
+    end
+
+    def S2
+      elements[2]
+    end
+
+    def body
+      elements[3]
+    end
+
+    def S3
+      elements[4]
+    end
+
+  end
+
+  module Link1
+    def relationtype
+      elements[0]
+    end
+
+    def S
+      elements[1]
+    end
+
+    def linktarget
+      elements[2]
+    end
+
+  end
+
+  module Link2
+    def ast
+      ["link", relationtype.ast, linktarget.ast, elements[3].respond_to?(:body) && elements[3].body.ast]
+    end
+  end
+
+  def _nt_link
+    start_index = index
+    if node_cache[:link].has_key?(index)
+      cached = node_cache[:link][index]
+      if cached
+        node_cache[:link][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_relationtype
+    s0 << r1
+    if r1
+      r2 = _nt_S
+      s0 << r2
+      if r2
+        r3 = _nt_linktarget
+        s0 << r3
+        if r3
+          i5, s5 = index, []
+          r6 = _nt_S
+          s5 << r6
+          if r6
+            if (match_len = has_terminal?("{", false, index))
+              r7 = true
+              @index += match_len
+            else
+              terminal_parse_failure('"{"')
+              r7 = nil
+            end
+            s5 << r7
+            if r7
+              r8 = _nt_S
+              s5 << r8
+              if r8
+                r9 = _nt_body
+                s5 << r9
+                if r9
+                  r10 = _nt_S
+                  s5 << r10
+                  if r10
+                    if (match_len = has_terminal?("}", false, index))
+                      r11 = true
+                      @index += match_len
+                    else
+                      terminal_parse_failure('"}"')
+                      r11 = nil
+                    end
+                    s5 << r11
+                  end
+                end
+              end
+            end
+          end
+          if s5.last
+            r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+            r5.extend(Link0)
+          else
+            @index = i5
+            r5 = nil
+          end
+          if r5
+            r4 = r5
+          else
+            r4 = instantiate_node(SyntaxNode,input, index...index)
+          end
+          s0 << r4
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Link1)
+      r0.extend(Link2)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:link][start_index] = r0
+
+    r0
+  end
+
+  def _nt_relationtype
+    start_index = index
+    if node_cache[:relationtype].has_key?(index)
+      cached = node_cache[:relationtype][index]
+      if cached
+        node_cache[:relationtype][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    r0 = _nt_iqs
+
+    node_cache[:relationtype][start_index] = r0
+
+    r0
+  end
+
+  def _nt_iqs
+    start_index = index
+    if node_cache[:iqs].has_key?(index)
+      cached = node_cache[:iqs][index]
+      if cached
+        node_cache[:iqs][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_iri
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      r2 = _nt_qualifiedname
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        r3 = _nt_simplename
+        if r3
+          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+          r0 = r3
+        else
+          @index = i0
+          r0 = nil
+        end
+      end
+    end
+
+    node_cache[:iqs][start_index] = r0
+
+    r0
+  end
+
+  module Simplename0
+    def ast
+      ["simple", text_value]
+    end
+  end
+
+  def _nt_simplename
+    start_index = index
+    if node_cache[:simplename].has_key?(index)
+      cached = node_cache[:simplename][index]
+      if cached
+        node_cache[:simplename][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    r0 = _nt_identifier
+    r0.extend(Simplename0)
+    r0.extend(Simplename0)
+
+    node_cache[:simplename][start_index] = r0
+
+    r0
+  end
+
+  module Qualifiedname0
+    def identifier1
+      elements[0]
+    end
+
+    def identifier2
+      elements[2]
+    end
+  end
+
+  module Qualifiedname1
+    def ast
+      ["qual", identifier1.ast, identifier2.ast]
+    end
+  end
+
+  def _nt_qualifiedname
+    start_index = index
+    if node_cache[:qualifiedname].has_key?(index)
+      cached = node_cache[:qualifiedname][index]
+      if cached
+        node_cache[:qualifiedname][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_identifier
+    s0 << r1
+    if r1
+      if (match_len = has_terminal?(":", false, index))
+        r2 = true
+        @index += match_len
+      else
+        terminal_parse_failure('":"')
+        r2 = nil
+      end
+      s0 << r2
+      if r2
+        r3 = _nt_identifier
+        s0 << r3
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Qualifiedname0)
+      r0.extend(Qualifiedname1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:qualifiedname][start_index] = r0
+
+    r0
+  end
+
+  def _nt_linktarget
+    start_index = index
+    if node_cache[:linktarget].has_key?(index)
+      cached = node_cache[:linktarget][index]
+      if cached
+        node_cache[:linktarget][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_iriref
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      r2 = _nt_literal
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:linktarget][start_index] = r0
+
+    r0
+  end
+
+  module Form0
+    def S1
+      elements[0]
+    end
+
+    def S2
+      elements[2]
+    end
+
+    def formfields
+      elements[3]
+    end
+
+    def S3
+      elements[4]
+    end
+
+  end
+
+  module Form1
+    def operationtype
+      elements[0]
+    end
+
+    def S1
+      elements[1]
+    end
+
+    def S2
+      elements[3]
+    end
+
+    def method
+      elements[4]
+    end
+
+    def S3
+      elements[5]
+    end
+
+    def submissiontarget
+      elements[6]
+    end
+
+  end
+
+  module Form2
+    def ast
+      ["form", operationtype.ast, method.ast, submissiontarget.ast, elements[7].respond_to?(:formfields) ? elements[7].formfields.ast : []]
+    end
+  end
+
+  def _nt_form
+    start_index = index
+    if node_cache[:form].has_key?(index)
+      cached = node_cache[:form][index]
+      if cached
+        node_cache[:form][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_operationtype
+    s0 << r1
+    if r1
+      r2 = _nt_S
+      s0 << r2
+      if r2
+        if (match_len = has_terminal?("->", false, index))
+          r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+          @index += match_len
+        else
+          terminal_parse_failure('"->"')
+          r3 = nil
+        end
+        s0 << r3
+        if r3
+          r4 = _nt_S
+          s0 << r4
+          if r4
+            r5 = _nt_method
+            s0 << r5
+            if r5
+              r6 = _nt_S
+              s0 << r6
+              if r6
+                r7 = _nt_submissiontarget
+                s0 << r7
+                if r7
+                  i9, s9 = index, []
+                  r10 = _nt_S
+                  s9 << r10
+                  if r10
+                    if (match_len = has_terminal?("[", false, index))
+                      r11 = true
+                      @index += match_len
+                    else
+                      terminal_parse_failure('"["')
+                      r11 = nil
+                    end
+                    s9 << r11
+                    if r11
+                      r12 = _nt_S
+                      s9 << r12
+                      if r12
+                        r13 = _nt_formfields
+                        s9 << r13
+                        if r13
+                          r14 = _nt_S
+                          s9 << r14
+                          if r14
+                            if (match_len = has_terminal?("]", false, index))
+                              r15 = true
+                              @index += match_len
+                            else
+                              terminal_parse_failure('"]"')
+                              r15 = nil
+                            end
+                            s9 << r15
+                          end
+                        end
+                      end
+                    end
+                  end
+                  if s9.last
+                    r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
+                    r9.extend(Form0)
+                  else
+                    @index = i9
+                    r9 = nil
+                  end
+                  if r9
+                    r8 = r9
+                  else
+                    r8 = instantiate_node(SyntaxNode,input, index...index)
+                  end
+                  s0 << r8
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Form1)
+      r0.extend(Form2)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:form][start_index] = r0
+
+    r0
+  end
+
+  def _nt_operationtype
+    start_index = index
+    if node_cache[:operationtype].has_key?(index)
+      cached = node_cache[:operationtype][index]
+      if cached
+        node_cache[:operationtype][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    r0 = _nt_iqs
+
+    node_cache[:operationtype][start_index] = r0
+
+    r0
+  end
+
+  def _nt_method
+    start_index = index
+    if node_cache[:method].has_key?(index)
+      cached = node_cache[:method][index]
+      if cached
+        node_cache[:method][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    r0 = _nt_identifier
+
+    node_cache[:method][start_index] = r0
+
+    r0
+  end
+
+  def _nt_submissiontarget
+    start_index = index
+    if node_cache[:submissiontarget].has_key?(index)
+      cached = node_cache[:submissiontarget][index]
+      if cached
+        node_cache[:submissiontarget][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    r0 = _nt_iriref
+
+    node_cache[:submissiontarget][start_index] = r0
+
+    r0
+  end
+
+  module Formfields0
+    def formfieldtype
+      elements[0]
+    end
+
+    def S1
+      elements[1]
+    end
+
+    def formfieldvalue
+      elements[2]
+    end
+
+    def S2
+      elements[3]
+    end
+  end
+
+  module Formfields1
+    def ast
+      elements.map{|x| [x.formfieldtype.ast, x.formfieldvalue.ast]}
+    end
+  end
+
+  def _nt_formfields
+    start_index = index
+    if node_cache[:formfields].has_key?(index)
+      cached = node_cache[:formfields][index]
+      if cached
+        node_cache[:formfields][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_formfieldtype
+      s1 << r2
+      if r2
+        r3 = _nt_S
+        s1 << r3
+        if r3
+          r4 = _nt_formfieldvalue
+          s1 << r4
+          if r4
+            r5 = _nt_S
+            s1 << r5
+          end
+        end
+      end
+      if s1.last
+        r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+        r1.extend(Formfields0)
+      else
+        @index = i1
+        r1 = nil
+      end
+      if r1
+        s0 << r1
+      else
+        break
+      end
+    end
+    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+    r0.extend(Formfields1)
+    r0.extend(Formfields1)
+
+    node_cache[:formfields][start_index] = r0
+
+    r0
+  end
+
+  def _nt_formfieldtype
+    start_index = index
+    if node_cache[:formfieldtype].has_key?(index)
+      cached = node_cache[:formfieldtype][index]
+      if cached
+        node_cache[:formfieldtype][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    r0 = _nt_iqs
+
+    node_cache[:formfieldtype][start_index] = r0
+
+    r0
+  end
+
+  def _nt_formfieldvalue
+    start_index = index
+    if node_cache[:formfieldvalue].has_key?(index)
+      cached = node_cache[:formfieldvalue][index]
+      if cached
+        node_cache[:formfieldvalue][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_iriref
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      r2 = _nt_literal
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:formfieldvalue][start_index] = r0
+
+    r0
+  end
+
+  module Representation0
+    def S1
+      elements[0]
+    end
+
+    def S2
+      elements[2]
+    end
+
+    def representationmetadata
+      elements[3]
+    end
+
+  end
+
+  module Representation1
+    def S
+      elements[1]
+    end
+
+    def bytes
+      elements[2]
+    end
+
+  end
+
+  module Representation2
+    def ast
+      ["repr", bytes.ast, elements[3].respond_to?(:representationmetadata) ? elements[3].representationmetadata.ast : []]
+    end
+  end
+
+  def _nt_representation
+    start_index = index
+    if node_cache[:representation].has_key?(index)
+      cached = node_cache[:representation][index]
+      if cached
+        node_cache[:representation][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_bytes
+        s0 << r3
+        if r3
+          i5, s5 = index, []
+          r6 = _nt_S
+          s5 << r6
+          if r6
+            if (match_len = has_terminal?("[", false, index))
+              r7 = true
+              @index += match_len
+            else
+              terminal_parse_failure('"["')
+              r7 = nil
+            end
+            s5 << r7
+            if r7
+              r8 = _nt_S
+              s5 << r8
+              if r8
+                r9 = _nt_representationmetadata
+                s5 << r9
+                if r9
+                  if (match_len = has_terminal?("]", false, index))
+                    r10 = true
+                    @index += match_len
+                  else
+                    terminal_parse_failure('"]"')
+                    r10 = nil
+                  end
+                  s5 << r10
+                end
+              end
+            end
+          end
+          if s5.last
+            r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+            r5.extend(Representation0)
+          else
+            @index = i5
+            r5 = nil
+          end
+          if r5
+            r4 = r5
+          else
+            r4 = instantiate_node(SyntaxNode,input, index...index)
+          end
+          s0 << r4
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Representation1)
+      r0.extend(Representation2)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:representation][start_index] = r0
+
+    r0
+  end
+
+  module Representationmetadata0
+    def metadataname
+      elements[0]
+    end
+
+    def S1
+      elements[1]
+    end
+
+    def metadatavalue
+      elements[2]
+    end
+
+    def S2
+      elements[3]
+    end
+  end
+
+  module Representationmetadata1
+    def ast
+      elements.map{|x| [x.metadataname.ast, x.metadatavalue.ast]}
+    end
+  end
+
+  def _nt_representationmetadata
+    start_index = index
+    if node_cache[:representationmetadata].has_key?(index)
+      cached = node_cache[:representationmetadata][index]
+      if cached
+        node_cache[:representationmetadata][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_metadataname
+      s1 << r2
+      if r2
+        r3 = _nt_S
+        s1 << r3
+        if r3
+          r4 = _nt_metadatavalue
+          s1 << r4
+          if r4
+            r5 = _nt_S
+            s1 << r5
+          end
+        end
+      end
+      if s1.last
+        r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+        r1.extend(Representationmetadata0)
+      else
+        @index = i1
+        r1 = nil
+      end
+      if r1
+        s0 << r1
+      else
+        break
+      end
+    end
+    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+    r0.extend(Representationmetadata1)
+    r0.extend(Representationmetadata1)
+
+    node_cache[:representationmetadata][start_index] = r0
+
+    r0
+  end
+
+  def _nt_metadataname
+    start_index = index
+    if node_cache[:metadataname].has_key?(index)
+      cached = node_cache[:metadataname][index]
+      if cached
+        node_cache[:metadataname][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    r0 = _nt_iqs
+
+    node_cache[:metadataname][start_index] = r0
+
+    r0
+  end
+
+  def _nt_metadatavalue
+    start_index = index
+    if node_cache[:metadatavalue].has_key?(index)
+      cached = node_cache[:metadatavalue][index]
+      if cached
+        node_cache[:metadatavalue][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_iriref
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      r2 = _nt_literal
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:metadatavalue][start_index] = r0
+
+    r0
+  end
+
+  def _nt_directive
+    start_index = index
+    if node_cache[:directive].has_key?(index)
+      cached = node_cache[:directive][index]
+      if cached
+        node_cache[:directive][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_basedirective
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      r2 = _nt_usingdirective
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:directive][start_index] = r0
+
+    r0
+  end
+
+  module Basedirective0
+    def S
+      elements[1]
+    end
+
+    def base
+      elements[2]
+    end
+  end
+
+  module Basedirective1
+    def ast
+      ["base", base.ast]
+    end
+  end
+
+  def _nt_basedirective
+    start_index = index
+    if node_cache[:basedirective].has_key?(index)
+      cached = node_cache[:basedirective][index]
+      if cached
+        node_cache[:basedirective][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?("#base", :insens, index))
+      r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      @index += match_len
+    else
+      terminal_parse_failure('"#base"')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      r2 = _nt_S
+      s0 << r2
+      if r2
+        r3 = _nt_base
+        s0 << r3
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Basedirective0)
+      r0.extend(Basedirective1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:basedirective][start_index] = r0
+
+    r0
+  end
+
+  def _nt_base
+    start_index = index
+    if node_cache[:base].has_key?(index)
+      cached = node_cache[:base][index]
+      if cached
+        node_cache[:base][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    r0 = _nt_iriref
+
+    node_cache[:base][start_index] = r0
+
+    r0
+  end
+
+  module Usingdirective0
+    def S1
+      elements[0]
+    end
+
+    def identifier
+      elements[1]
+    end
+
+    def S2
+      elements[2]
+    end
+
+  end
+
+  module Usingdirective1
+    def S
+      elements[2]
+    end
+
+    def iri
+      elements[3]
+    end
+  end
+
+  module Usingdirective2
+    def ast
+      ["using", elements[1].respond_to?(:identifier) && elements[1].identifier.ast, iri.ast]
+    end
+  end
+
+  def _nt_usingdirective
+    start_index = index
+    if node_cache[:usingdirective].has_key?(index)
+      cached = node_cache[:usingdirective][index]
+      if cached
+        node_cache[:usingdirective][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?("#using", :insens, index))
+      r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      @index += match_len
+    else
+      terminal_parse_failure('"#using"')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      i3, s3 = index, []
+      r4 = _nt_S
+      s3 << r4
+      if r4
+        r5 = _nt_identifier
+        s3 << r5
+        if r5
+          r6 = _nt_S
+          s3 << r6
+          if r6
+            if (match_len = has_terminal?("=", false, index))
+              r7 = true
+              @index += match_len
+            else
+              terminal_parse_failure('"="')
+              r7 = nil
+            end
+            s3 << r7
+          end
+        end
+      end
+      if s3.last
+        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+        r3.extend(Usingdirective0)
+      else
+        @index = i3
+        r3 = nil
+      end
+      if r3
+        r2 = r3
+      else
+        r2 = instantiate_node(SyntaxNode,input, index...index)
+      end
+      s0 << r2
+      if r2
+        r8 = _nt_S
+        s0 << r8
+        if r8
+          r9 = _nt_iri
+          s0 << r9
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Usingdirective1)
+      r0.extend(Usingdirective2)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:usingdirective][start_index] = r0
+
+    r0
+  end
+
+  module Iri0
+    def ast
+      ["iri", text_value[1...-1]]
+    end
+  end
+
+  def _nt_iri
+    start_index = index
+    if node_cache[:iri].has_key?(index)
+      cached = node_cache[:iri][index]
+      if cached
+        node_cache[:iri][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    r0 = _nt_angled
+    r0.extend(Iri0)
+    r0.extend(Iri0)
+
+    node_cache[:iri][start_index] = r0
+
+    r0
+  end
+
+  module Iriref0
+    def ast
+      ["iriref", text_value[1...-1]]
+    end
+  end
+
+  def _nt_iriref
+    start_index = index
+    if node_cache[:iriref].has_key?(index)
+      cached = node_cache[:iriref][index]
+      if cached
+        node_cache[:iriref][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    r0 = _nt_angled
+    r0.extend(Iriref0)
+    r0.extend(Iriref0)
+
+    node_cache[:iriref][start_index] = r0
+
+    r0
+  end
+
+  module Identifier0
+    def ast
+      text_value
+    end
+  end
+
+  def _nt_identifier
+    start_index = index
+    if node_cache[:identifier].has_key?(index)
+      cached = node_cache[:identifier][index]
+      if cached
+        node_cache[:identifier][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    r0 = _nt_id
+    r0.extend(Identifier0)
+    r0.extend(Identifier0)
+
+    node_cache[:identifier][start_index] = r0
+
+    r0
+  end
+
+  module Boolean0
+    def ast1() true end
+  end
+
+  module Boolean1
+    def ast1() false end
+  end
+
+  def _nt_boolean
+    start_index = index
+    if node_cache[:boolean].has_key?(index)
+      cached = node_cache[:boolean][index]
+      if cached
+        node_cache[:boolean][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?("true", :insens, index))
+      r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      r1.extend(Boolean0)
+      @index += match_len
+    else
+      terminal_parse_failure('"true"')
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      if (match_len = has_terminal?("false", :insens, index))
+        r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+        r2.extend(Boolean1)
+        @index += match_len
+      else
+        terminal_parse_failure('"false"')
+        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[:boolean][start_index] = r0
+
+    r0
+  end
+
+  module Literal0
+    def ast
+      ["literal", ast1]
+    end
+  end
+
+  def _nt_literal
+    start_index = index
+    if node_cache[:literal].has_key?(index)
+      cached = node_cache[:literal][index]
+      if cached
+        node_cache[:literal][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    i1 = index
+    r2 = _nt_boolean
+    if r2
+      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+      r1 = r2
+      r1.extend(Literal0)
+      r1.extend(Literal0)
+    else
+      r3 = _nt_number
+      if r3
+        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+        r1 = r3
+        r1.extend(Literal0)
+        r1.extend(Literal0)
+      else
+        r4 = _nt_text
+        if r4
+          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+          r1 = r4
+          r1.extend(Literal0)
+          r1.extend(Literal0)
+        else
+          @index = i1
+          r1 = nil
+        end
+      end
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      r5 = _nt_datetime
+      if r5
+        r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+        r0 = r5
+      else
+        r6 = _nt_bytes
+        if r6
+          r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+          r0 = r6
+        else
+          @index = i0
+          r0 = nil
+        end
+      end
+    end
+
+    node_cache[:literal][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 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
+
+  module Number3
+    def ast1
+      eval(text_value)
+    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)
+        r2.extend(Number3)
+      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[4]
+    end
+  end
+
+  module Hexfloat2
+    def ast1
+      Float(text_value)
+    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?("0x", :insens, index))
+      r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      @index += match_len
+    else
+      terminal_parse_failure('"0x"')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        r3 = _nt_HEXDIG
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      if s2.empty?
+        @index = i2
+        r2 = nil
+      else
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      end
+      s0 << r2
+      if r2
+        i5, 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
+          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(Hexfloat0)
+        else
+          @index = i5
+          r5 = nil
+        end
+        if r5
+          r4 = r5
+        else
+          r4 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s0 << r4
+        if r4
+          if (match_len = has_terminal?("p", :insens, index))
+            r9 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+            @index += match_len
+          else
+            terminal_parse_failure('"p"')
+            r9 = nil
+          end
+          s0 << r9
+          if r9
+            r10 = _nt_exponent
+            s0 << r10
+          end
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Hexfloat1)
+      r0.extend(Hexfloat2)
+    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 ast1
+      eval(text_value)
+    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
+
+  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 = 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
+          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
+            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
+
+  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
+      r3 = _nt_hexadecimalescape
+      if r3
+        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+        r2 = r3
+      else
+        r4 = _nt_unicodeescape
+        if r4
+          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+          r2 = r4
+        else
+          i5 = index
+          if has_terminal?(@regexps[gr = '\A[\\ -~]'] ||= Regexp.new(gr), :regexp, index)
+            r6 = true
+            @index += 1
+          else
+            terminal_parse_failure('[\\ -~]')
+            r6 = nil
+          end
+          if r6
+            r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+            r5 = r6
+          else
+            if has_terminal?(@regexps[gr = '\A[€-􏿽]'] ||= Regexp.new(gr), :regexp, index)
+              r7 = true
+              @index += 1
+            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
+            r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+            r2 = r5
+          else
+            @index = i2
+            r2 = nil
+          end
+        end
+      end
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(SESC0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:SESC][start_index] = r0
+
+    r0
+  end
+
+  module Hexadecimalescape0
+    def HEXDIG
+      elements[1]
+    end
+  end
+
+  def _nt_hexadecimalescape
+    start_index = index
+    if node_cache[:hexadecimalescape].has_key?(index)
+      cached = node_cache[:hexadecimalescape][index]
+      if cached
+        node_cache[:hexadecimalescape][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    if (match_len = has_terminal?("x", :insens, index))
+      r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      @index += match_len
+    else
+      terminal_parse_failure('"x"')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      r2 = _nt_HEXDIG
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Hexadecimalescape0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:hexadecimalescape][start_index] = r0
+
+    r0
+  end
+
+  module Unicodeescape0
+    def HEXDIG
+      elements[1]
+    end
+  end
+
+  module Unicodeescape1
+    def HEXDIG
+      elements[1]
+    end
+  end
+
+  def _nt_unicodeescape
+    start_index = index
+    if node_cache[:unicodeescape].has_key?(index)
+      cached = node_cache[:unicodeescape][index]
+      if cached
+        node_cache[:unicodeescape][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    i1, s1 = index, []
+    if (match_len = has_terminal?("u", false, index))
+      r2 = true
+      @index += match_len
+    else
+      terminal_parse_failure('"u"')
+      r2 = nil
+    end
+    s1 << r2
+    if r2
+      r3 = _nt_HEXDIG
+      s1 << r3
+    end
+    if s1.last
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+      r1.extend(Unicodeescape0)
+    else
+      @index = i1
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      i4, s4 = index, []
+      if (match_len = has_terminal?("U", false, index))
+        r5 = true
+        @index += match_len
+      else
+        terminal_parse_failure('"U"')
+        r5 = nil
+      end
+      s4 << r5
+      if r5
+        r6 = _nt_HEXDIG
+        s4 << r6
+      end
+      if s4.last
+        r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+        r4.extend(Unicodeescape1)
+      else
+        @index = i4
+        r4 = nil
+      end
+      if r4
+        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+        r0 = r4
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:unicodeescape][start_index] = r0
+
+    r0
+  end
+
+  module Angled0
+  end
+
+  def _nt_angled
+    start_index = index
+    if node_cache[:angled].has_key?(index)
+      cached = node_cache[:angled][index]
+      if cached
+        node_cache[:angled][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_ACHAR
+        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(Angled0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:angled][start_index] = r0
+
+    r0
+  end
+
+  def _nt_ACHAR
+    start_index = index
+    if node_cache[:ACHAR].has_key?(index)
+      cached = node_cache[:ACHAR][index]
+      if cached
+        node_cache[:ACHAR][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
+          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
+            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[:ACHAR][start_index] = r0
+
+    r0
+  end
+
+  module Datetime0
+    def DOLLAR1
+      elements[0]
+    end
+
+    def datetime1
+      elements[1]
+    end
+
+    def DOLLAR2
+      elements[2]
+    end
+  end
+
+  module Datetime1
+    def ast
+      datetime1.ast
+    end
+  end
+
+  def _nt_datetime
+    start_index = index
+    if node_cache[:datetime].has_key?(index)
+      cached = node_cache[:datetime][index]
+      if cached
+        node_cache[:datetime][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_DOLLAR
+    s0 << r1
+    if r1
+      r2 = _nt_datetime1
+      s0 << r2
+      if r2
+        r3 = _nt_DOLLAR
+        s0 << r3
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Datetime0)
+      r0.extend(Datetime1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:datetime][start_index] = r0
+
+    r0
+  end
+
+  module Datetime10
+    def ast
+      ["time", Time.parse(text_value).to_i]
+    end
+  end
+
+  def _nt_datetime1
+    start_index = index
+    if node_cache[:datetime1].has_key?(index)
+      cached = node_cache[:datetime1][index]
+      if cached
+        node_cache[:datetime1][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      i1 = index
+      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
+        r1 = 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
+          r1 = r3
+        else
+          @index = i1
+          r1 = nil
+        end
+      end
+      if r1
+        s0 << r1
+      else
+        break
+      end
+    end
+    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+    r0.extend(Datetime10)
+    r0.extend(Datetime10)
+
+    node_cache[:datetime1][start_index] = r0
+
+    r0
+  end
+
+  def _nt_DOLLAR
+    start_index = index
+    if node_cache[:DOLLAR].has_key?(index)
+      cached = node_cache[:DOLLAR][index]
+      if cached
+        node_cache[:DOLLAR][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[:DOLLAR][start_index] = r0
+
+    r0
+  end
+
+  module Bytes0
+  end
+
+  module Bytes1
+    def ast
+      ["bytes", elements[0].text_value, elements[2].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?("b16", :insens, index))
+        r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+        @index += match_len
+      else
+        terminal_parse_failure('"b16"')
+        r2 = nil
+      end
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        if (match_len = has_terminal?("b32", :insens, index))
+          r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+          @index += match_len
+        else
+          terminal_parse_failure('"b32"')
+          r3 = nil
+        end
+        if r3
+          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+          r0 = r3
+        else
+          if (match_len = has_terminal?("b64", :insens, index))
+            r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+            @index += match_len
+          else
+            terminal_parse_failure('"b64"')
+            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[: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 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      @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 CORALParser < Treetop::Runtime::CompiledParser
+  include CORAL
+end
+