module CDDLGRAMMAR

Autogenerated from a Treetop grammar. Edits may be lost.

Public Instance Methods

_nt_ALPHA() click to toggle source
# File lib/parser/cddlgrammar.rb, line 4082
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
_nt_BCHAR() click to toggle source
# File lib/parser/cddlgrammar.rb, line 3846
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
          if (match_len = has_terminal?("\\'", false, index))
            r5 = instantiate_node(SyntaxNode,input, index...(index + match_len))
            @index += match_len
          else
            terminal_parse_failure('"\\\\\'"')
            r5 = nil
          end
          if r5
            r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
            r0 = r5
          else
            r6 = _nt_CRLF
            if r6
              r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
              r0 = r6
            else
              @index = i0
              r0 = nil
            end
          end
        end
      end
    end
  end

  node_cache[:BCHAR][start_index] = r0

  r0
end
_nt_BINDIG() click to toggle source
# File lib/parser/cddlgrammar.rb, line 4334
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
_nt_COMMENT() click to toggle source
# File lib/parser/cddlgrammar.rb, line 4479
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
_nt_CRLF() click to toggle source
# File lib/parser/cddlgrammar.rb, line 4573
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
_nt_DIGIT() click to toggle source
# File lib/parser/cddlgrammar.rb, line 4188
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
_nt_DIGIT1() click to toggle source
# File lib/parser/cddlgrammar.rb, line 4212
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
_nt_EALPHA() click to toggle source
# File lib/parser/cddlgrammar.rb, line 4126
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
_nt_HEXDIG() click to toggle source
# File lib/parser/cddlgrammar.rb, line 4236
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
_nt_NL() click to toggle source
# File lib/parser/cddlgrammar.rb, line 4441
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
_nt_PCHAR() click to toggle source
# File lib/parser/cddlgrammar.rb, line 4529
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
_nt_S() click to toggle source
# File lib/parser/cddlgrammar.rb, line 4358
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
_nt_SCHAR() click to toggle source
# File lib/parser/cddlgrammar.rb, line 3026
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
_nt_SESC() click to toggle source
# File lib/parser/cddlgrammar.rb, line 3121
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 (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
        if (match_len = has_terminal?("\\", false, index))
          r5 = true
          @index += match_len
        else
          terminal_parse_failure('"\\\\"')
          r5 = nil
        end
        if r5
          r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
          r2 = r5
        else
          if (match_len = has_terminal?("b", false, index))
            r6 = true
            @index += match_len
          else
            terminal_parse_failure('"b"')
            r6 = nil
          end
          if r6
            r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
            r2 = r6
          else
            if (match_len = has_terminal?("f", false, index))
              r7 = true
              @index += match_len
            else
              terminal_parse_failure('"f"')
              r7 = nil
            end
            if r7
              r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
              r2 = r7
            else
              if (match_len = has_terminal?("n", false, index))
                r8 = true
                @index += match_len
              else
                terminal_parse_failure('"n"')
                r8 = nil
              end
              if r8
                r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
                r2 = r8
              else
                if (match_len = has_terminal?("r", false, index))
                  r9 = true
                  @index += match_len
                else
                  terminal_parse_failure('"r"')
                  r9 = nil
                end
                if r9
                  r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
                  r2 = r9
                else
                  if (match_len = has_terminal?("t", false, index))
                    r10 = true
                    @index += match_len
                  else
                    terminal_parse_failure('"t"')
                    r10 = nil
                  end
                  if r10
                    r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
                    r2 = r10
                  else
                    i11, s11 = index, []
                    if (match_len = has_terminal?("u", false, index))
                      r12 = true
                      @index += match_len
                    else
                      terminal_parse_failure('"u"')
                      r12 = nil
                    end
                    s11 << r12
                    if r12
                      r13 = _nt_hexchar
                      s11 << r13
                    end
                    if s11.last
                      r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
                      r11.extend(SESC0)
                    else
                      @index = i11
                      r11 = nil
                    end
                    if r11
                      r11 = SyntaxNode.new(input, (index-1)...index) if r11 == true
                      r2 = r11
                    else
                      @index = i2
                      r2 = nil
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(SESC1)
    r0.extend(SESC2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:SESC][start_index] = r0

  r0
end
_nt_SP() click to toggle source
# File lib/parser/cddlgrammar.rb, line 4417
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
_nt_WS() click to toggle source
# File lib/parser/cddlgrammar.rb, line 4385
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
_nt_assigng() click to toggle source
# File lib/parser/cddlgrammar.rb, line 332
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
_nt_assignt() click to toggle source
# File lib/parser/cddlgrammar.rb, line 288
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
_nt_bareword() click to toggle source
# File lib/parser/cddlgrammar.rb, line 2112
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
_nt_bsqual() click to toggle source
# File lib/parser/cddlgrammar.rb, line 3926
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
_nt_bytes() click to toggle source
# File lib/parser/cddlgrammar.rb, line 3780
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
_nt_cddlgrammar() click to toggle source
# File lib/parser/cddlgrammar.rb, line 35
def _nt_cddlgrammar
  start_index = index
  if node_cache[:cddlgrammar].has_key?(index)
    cached = node_cache[:cddlgrammar][index]
    if cached
      node_cache[:cddlgrammar][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(Cddlgrammar0)
      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(Cddlgrammar1)
    r0.extend(Cddlgrammar2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:cddlgrammar][start_index] = r0

  r0
end
_nt_ctlop() click to toggle source
# File lib/parser/cddlgrammar.rb, line 1534
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
_nt_exponent() click to toggle source
# File lib/parser/cddlgrammar.rb, line 2870
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
_nt_fraction() click to toggle source
# File lib/parser/cddlgrammar.rb, line 2835
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
_nt_genericarg() click to toggle source
# File lib/parser/cddlgrammar.rb, line 538
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
_nt_genericparm() click to toggle source
# File lib/parser/cddlgrammar.rb, line 409
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
_nt_group() click to toggle source
# File lib/parser/cddlgrammar.rb, line 1598
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
_nt_groupname() click to toggle source
# File lib/parser/cddlgrammar.rb, line 270
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
_nt_grpchoice() click to toggle source
# File lib/parser/cddlgrammar.rb, line 1682
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
_nt_grpent() click to toggle source
# File lib/parser/cddlgrammar.rb, line 1770
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
_nt_hexchar() click to toggle source
# File lib/parser/cddlgrammar.rb, line 3292
def _nt_hexchar
  start_index = index
  if node_cache[:hexchar].has_key?(index)
    cached = node_cache[:hexchar][index]
    if cached
      node_cache[:hexchar][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_non_surrogate
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i2, s2 = index, []
    r3 = _nt_high_surrogate
    s2 << r3
    if r3
      if (match_len = has_terminal?("\\", false, index))
        r4 = true
        @index += match_len
      else
        terminal_parse_failure('"\\\\"')
        r4 = nil
      end
      s2 << r4
      if r4
        if (match_len = has_terminal?("u", false, index))
          r5 = true
          @index += match_len
        else
          terminal_parse_failure('"u"')
          r5 = nil
        end
        s2 << r5
        if r5
          r6 = _nt_low_surrogate
          s2 << r6
        end
      end
    end
    if s2.last
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
      r2.extend(Hexchar0)
    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[:hexchar][start_index] = r0

  r0
end
_nt_hexfloat() click to toggle source
# File lib/parser/cddlgrammar.rb, line 2713
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
_nt_high_surrogate() click to toggle source
# File lib/parser/cddlgrammar.rb, line 3548
def _nt_high_surrogate
  start_index = index
  if node_cache[:high_surrogate].has_key?(index)
    cached = node_cache[:high_surrogate][index]
    if cached
      node_cache[:high_surrogate][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?("d", :insens, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('"D"')
    r1 = nil
  end
  s0 << r1
  if r1
    i2 = index
    if (match_len = has_terminal?("8", false, index))
      r3 = true
      @index += match_len
    else
      terminal_parse_failure('"8"')
      r3 = nil
    end
    if r3
      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
      r2 = r3
    else
      if (match_len = has_terminal?("9", false, index))
        r4 = true
        @index += match_len
      else
        terminal_parse_failure('"9"')
        r4 = nil
      end
      if r4
        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
        r2 = r4
      else
        if (match_len = has_terminal?("a", :insens, index))
          r5 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('"A"')
          r5 = nil
        end
        if r5
          r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
          r2 = r5
        else
          if (match_len = has_terminal?("b", :insens, index))
            r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
            @index += match_len
          else
            terminal_parse_failure('"B"')
            r6 = nil
          end
          if r6
            r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
            r2 = r6
          else
            @index = i2
            r2 = nil
          end
        end
      end
    end
    s0 << r2
    if r2
      s7, i7 = [], index
      loop do
        r8 = _nt_HEXDIG
        if r8
          s7 << r8
        else
          break
        end
        if s7.size == 2
          break
        end
      end
      if s7.size < 2
        @index = i7
        r7 = nil
      else
        if s7.size < 2
          @terminal_failures.pop
        end
        r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
      end
      s0 << r7
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(HighSurrogate0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:high_surrogate][start_index] = r0

  r0
end
_nt_id() click to toggle source
# File lib/parser/cddlgrammar.rb, line 3980
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
_nt_int() click to toggle source
# File lib/parser/cddlgrammar.rb, line 2546
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
_nt_low_surrogate() click to toggle source
# File lib/parser/cddlgrammar.rb, line 3662
def _nt_low_surrogate
  start_index = index
  if node_cache[:low_surrogate].has_key?(index)
    cached = node_cache[:low_surrogate][index]
    if cached
      node_cache[:low_surrogate][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?("d", :insens, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('"D"')
    r1 = nil
  end
  s0 << r1
  if r1
    i2 = index
    if (match_len = has_terminal?("c", :insens, index))
      r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('"C"')
      r3 = nil
    end
    if r3
      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
      r2 = r3
    else
      if (match_len = has_terminal?("d", :insens, index))
        r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
        @index += match_len
      else
        terminal_parse_failure('"D"')
        r4 = nil
      end
      if r4
        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
        r2 = r4
      else
        if (match_len = has_terminal?("e", :insens, index))
          r5 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('"E"')
          r5 = nil
        end
        if r5
          r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
          r2 = r5
        else
          if (match_len = has_terminal?("f", :insens, index))
            r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
            @index += match_len
          else
            terminal_parse_failure('"F"')
            r6 = nil
          end
          if r6
            r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
            r2 = r6
          else
            @index = i2
            r2 = nil
          end
        end
      end
    end
    s0 << r2
    if r2
      s7, i7 = [], index
      loop do
        r8 = _nt_HEXDIG
        if r8
          s7 << r8
        else
          break
        end
        if s7.size == 2
          break
        end
      end
      if s7.size < 2
        @index = i7
        r7 = nil
      else
        if s7.size < 2
          @terminal_failures.pop
        end
        r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
      end
      s0 << r7
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(LowSurrogate0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:low_surrogate][start_index] = r0

  r0
end
_nt_memberkey() click to toggle source
# File lib/parser/cddlgrammar.rb, line 1974
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
_nt_non_surrogate() click to toggle source
# File lib/parser/cddlgrammar.rb, line 3363
def _nt_non_surrogate
  start_index = index
  if node_cache[:non_surrogate].has_key?(index)
    cached = node_cache[:non_surrogate][index]
    if cached
      node_cache[:non_surrogate][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  i2 = index
  r3 = _nt_DIGIT
  if r3
    r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
    r2 = r3
  else
    if (match_len = has_terminal?("a", :insens, index))
      r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('"A"')
      r4 = nil
    end
    if r4
      r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
      r2 = r4
    else
      if (match_len = has_terminal?("b", :insens, index))
        r5 = instantiate_node(SyntaxNode,input, index...(index + match_len))
        @index += match_len
      else
        terminal_parse_failure('"B"')
        r5 = nil
      end
      if r5
        r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
        r2 = r5
      else
        if (match_len = has_terminal?("c", :insens, index))
          r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('"C"')
          r6 = nil
        end
        if r6
          r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
          r2 = r6
        else
          if (match_len = has_terminal?("e", :insens, index))
            r7 = instantiate_node(SyntaxNode,input, index...(index + match_len))
            @index += match_len
          else
            terminal_parse_failure('"E"')
            r7 = nil
          end
          if r7
            r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
            r2 = r7
          else
            if (match_len = has_terminal?("f", :insens, index))
              r8 = instantiate_node(SyntaxNode,input, index...(index + match_len))
              @index += match_len
            else
              terminal_parse_failure('"F"')
              r8 = nil
            end
            if r8
              r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
              r2 = r8
            else
              @index = i2
              r2 = nil
            end
          end
        end
      end
    end
  end
  s1 << r2
  if r2
    s9, i9 = [], index
    loop do
      r10 = _nt_HEXDIG
      if r10
        s9 << r10
      else
        break
      end
      if s9.size == 3
        break
      end
    end
    if s9.size < 3
      @index = i9
      r9 = nil
    else
      if s9.size < 3
        @terminal_failures.pop
      end
      r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
    end
    s1 << r9
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(NonSurrogate0)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i11, s11 = index, []
    if (match_len = has_terminal?("d", :insens, index))
      r12 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('"D"')
      r12 = nil
    end
    s11 << r12
    if r12
      if has_terminal?(@regexps[gr = '\A[0-7]'] ||= Regexp.new(gr), :regexp, index)
        r13 = true
        @index += 1
      else
        terminal_parse_failure('[0-7]')
        r13 = nil
      end
      s11 << r13
      if r13
        s14, i14 = [], index
        loop do
          r15 = _nt_HEXDIG
          if r15
            s14 << r15
          else
            break
          end
          if s14.size == 2
            break
          end
        end
        if s14.size < 2
          @index = i14
          r14 = nil
        else
          if s14.size < 2
            @terminal_failures.pop
          end
          r14 = instantiate_node(SyntaxNode,input, i14...index, s14)
        end
        s11 << r14
      end
    end
    if s11.last
      r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
      r11.extend(NonSurrogate1)
    else
      @index = i11
      r11 = nil
    end
    if r11
      r11 = SyntaxNode.new(input, (index-1)...index) if r11 == true
      r0 = r11
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:non_surrogate][start_index] = r0

  r0
end
_nt_number() click to toggle source
# File lib/parser/cddlgrammar.rb, line 2607
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
_nt_occur() click to toggle source
# File lib/parser/cddlgrammar.rb, line 2259
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
_nt_occurs() click to toggle source
# File lib/parser/cddlgrammar.rb, line 2212
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
_nt_optcom() click to toggle source
# File lib/parser/cddlgrammar.rb, line 2143
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
_nt_r__rule() click to toggle source
# File lib/parser/cddlgrammar.rb, line 150
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
_nt_rangeop() click to toggle source
# File lib/parser/cddlgrammar.rb, line 1484
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
_nt_text() click to toggle source
# File lib/parser/cddlgrammar.rb, line 2953
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
_nt_type() click to toggle source
# File lib/parser/cddlgrammar.rb, line 661
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
_nt_type1() click to toggle source
# File lib/parser/cddlgrammar.rb, line 761
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
_nt_type2() click to toggle source
# File lib/parser/cddlgrammar.rb, line 1006
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
_nt_typename() click to toggle source
# File lib/parser/cddlgrammar.rb, line 252
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
_nt_uint() click to toggle source
# File lib/parser/cddlgrammar.rb, line 2358
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
_nt_value() click to toggle source
# File lib/parser/cddlgrammar.rb, line 2500
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
root() click to toggle source
# File lib/parser/cddlgrammar.rb, line 8
def root
  @root ||= :cddlgrammar
end