Module: IPGRAMMAR

Includes:

Treetop::Runtime

Included in:

IPGRAMMARParser

Defined in:

lib/cbor-diagnostic-app/ipgrammar.rb

Defined Under Namespace

Modules: AppStringIp0, AppStringIp1, AppStringIp2, DecOctet0, DecOctet1, DecOctet2, DecOctet3, IPaddress0, IPaddress1, IPv4address0, IPv6address0, IPv6address1, IPv6address10, IPv6address11, IPv6address12, IPv6address13, IPv6address14, IPv6address15, IPv6address16, IPv6address17, IPv6address18, IPv6address19, IPv6address2, IPv6address20, IPv6address21, IPv6address22, IPv6address23, IPv6address24, IPv6address25, IPv6address3, IPv6address4, IPv6address5, IPv6address6, IPv6address7, IPv6address8, IPv6address9, Ls320, Uint0

Instance Method Summary

• #_nt_app_string_ip ⇒ Object
• #_nt_dec_octet ⇒ Object
• #_nt_DIGIT ⇒ Object
• #_nt_DIGIT1 ⇒ Object
• #_nt_h16 ⇒ Object
• #_nt_HEXDIG ⇒ Object
• #_nt_IPaddress ⇒ Object
• #_nt_IPv4address ⇒ Object
• #_nt_IPv6address ⇒ Object
• #_nt_ls32 ⇒ Object
• #_nt_uint ⇒ Object
• #root ⇒ Object

Instance Method Details

#_nt_app_string_ip ⇒ Object

# File 'lib/cbor-diagnostic-app/ipgrammar.rb', line 47

def _nt_app_string_ip
  start_index = index
  if node_cache[:app_string_ip].has_key?(index)
    cached = node_cache[:app_string_ip][index]
    if cached
      node_cache[:app_string_ip][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_IPaddress
  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_uint
      s3 << r5
    end
    if s3.last
      r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
      r3.extend(AppStringIp0)
    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(AppStringIp1)
    r0.extend(AppStringIp2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:app_string_ip][start_index] = r0

  r0
end

#_nt_dec_octet ⇒ Object

# File 'lib/cbor-diagnostic-app/ipgrammar.rb', line 1318

def _nt_dec_octet
  start_index = index
  if node_cache[:dec_octet].has_key?(index)
    cached = node_cache[:dec_octet][index]
    if cached
      node_cache[:dec_octet][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  if (match_len = has_terminal?("25", false, index))
    r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('"25"')
    r2 = nil
  end
  s1 << r2
  if r2
    if has_terminal?(@regexps[gr = '\A[0-5]'] ||= Regexp.new(gr), :regexp, index)
      r3 = true
      @index += 1
    else
      terminal_parse_failure('[0-5]')
      r3 = nil
    end
    s1 << r3
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(DecOctet0)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i4, s4 = index, []
    if (match_len = has_terminal?("2", false, index))
      r5 = true
      @index += match_len
    else
      terminal_parse_failure('"2"')
      r5 = nil
    end
    s4 << r5
    if r5
      if has_terminal?(@regexps[gr = '\A[0-4]'] ||= Regexp.new(gr), :regexp, index)
        r6 = true
        @index += 1
      else
        terminal_parse_failure('[0-4]')
        r6 = nil
      end
      s4 << r6
      if r6
        r7 = _nt_DIGIT
        s4 << r7
      end
    end
    if s4.last
      r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
      r4.extend(DecOctet1)
    else
      @index = i4
      r4 = nil
    end
    if r4
      r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
      r0 = r4
    else
      i8, s8 = index, []
      if (match_len = has_terminal?("1", false, index))
        r9 = true
        @index += match_len
      else
        terminal_parse_failure('"1"')
        r9 = nil
      end
      s8 << r9
      if r9
        s10, i10 = [], index
        loop do
          r11 = _nt_DIGIT
          if r11
            s10 << r11
          else
            break
          end
          if s10.size == 2
            break
          end
        end
        if s10.size < 2
          @index = i10
          r10 = nil
        else
          if s10.size < 2
            @terminal_failures.pop
          end
          r10 = instantiate_node(SyntaxNode,input, i10...index, s10)
        end
        s8 << r10
      end
      if s8.last
        r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
        r8.extend(DecOctet2)
      else
        @index = i8
        r8 = nil
      end
      if r8
        r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
        r0 = r8
      else
        i12, s12 = index, []
        if has_terminal?(@regexps[gr = '\A[1-9]'] ||= Regexp.new(gr), :regexp, index)
          r13 = true
          @index += 1
        else
          terminal_parse_failure('[1-9]')
          r13 = nil
        end
        s12 << r13
        if r13
          r14 = _nt_DIGIT
          s12 << r14
        end
        if s12.last
          r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
          r12.extend(DecOctet3)
        else
          @index = i12
          r12 = nil
        end
        if r12
          r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
          r0 = r12
        else
          r15 = _nt_DIGIT
          if r15
            r15 = SyntaxNode.new(input, (index-1)...index) if r15 == true
            r0 = r15
          else
            @index = i0
            r0 = nil
          end
        end
      end
    end
  end

  node_cache[:dec_octet][start_index] = r0

  r0
end

#_nt_DIGIT ⇒ Object

# File 'lib/cbor-diagnostic-app/ipgrammar.rb', line 1578

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 ⇒ Object

# File 'lib/cbor-diagnostic-app/ipgrammar.rb', line 1602

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_h16 ⇒ Object

# File 'lib/cbor-diagnostic-app/ipgrammar.rb', line 1110

def _nt_h16
  start_index = index
  if node_cache[:h16].has_key?(index)
    cached = node_cache[:h16][index]
    if cached
      node_cache[:h16][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_HEXDIG
    if r1
      s0 << r1
    else
      break
    end
    if s0.size == 4
      break
    end
  end
  if s0.size < 1
    @index = i0
    r0 = nil
  else
    if s0.size < 4
      @terminal_failures.pop
    end
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
  end

  node_cache[:h16][start_index] = r0

  r0
end

#_nt_HEXDIG ⇒ Object

# File 'lib/cbor-diagnostic-app/ipgrammar.rb', line 1480

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_IPaddress ⇒ Object

# File 'lib/cbor-diagnostic-app/ipgrammar.rb', line 111

def _nt_IPaddress
  start_index = index
  if node_cache[:IPaddress].has_key?(index)
    cached = node_cache[:IPaddress][index]
    if cached
      node_cache[:IPaddress][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_IPv4address
  r1.extend(IPaddress0)
  r1.extend(IPaddress0)
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r2 = _nt_IPv6address
    r2.extend(IPaddress1)
    r2.extend(IPaddress1)
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:IPaddress][start_index] = r0

  r0
end

#_nt_IPv4address ⇒ Object

# File 'lib/cbor-diagnostic-app/ipgrammar.rb', line 1231

def _nt_IPv4address
  start_index = index
  if node_cache[:IPv4address].has_key?(index)
    cached = node_cache[:IPv4address][index]
    if cached
      node_cache[:IPv4address][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_dec_octet
  s0 << r1
  if r1
    if (match_len = has_terminal?(".", false, index))
      r2 = true
      @index += match_len
    else
      terminal_parse_failure('"."')
      r2 = nil
    end
    s0 << r2
    if r2
      r3 = _nt_dec_octet
      s0 << r3
      if r3
        if (match_len = has_terminal?(".", false, index))
          r4 = true
          @index += match_len
        else
          terminal_parse_failure('"."')
          r4 = nil
        end
        s0 << r4
        if r4
          r5 = _nt_dec_octet
          s0 << r5
          if r5
            if (match_len = has_terminal?(".", false, index))
              r6 = true
              @index += match_len
            else
              terminal_parse_failure('"."')
              r6 = nil
            end
            s0 << r6
            if r6
              r7 = _nt_dec_octet
              s0 << r7
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(IPv4address0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:IPv4address][start_index] = r0

  r0
end

#_nt_IPv6address ⇒ Object

# File 'lib/cbor-diagnostic-app/ipgrammar.rb', line 315

def _nt_IPv6address
  start_index = index
  if node_cache[:IPv6address].has_key?(index)
    cached = node_cache[:IPv6address][index]
    if cached
      node_cache[:IPv6address][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  s2, i2 = [], index
  loop do
    i3, s3 = index, []
    r4 = _nt_h16
    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
    end
    if s3.last
      r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
      r3.extend(IPv6address0)
    else
      @index = i3
      r3 = nil
    end
    if r3
      s2 << r3
    else
      break
    end
    if s2.size == 6
      break
    end
  end
  if s2.size < 6
    @index = i2
    r2 = nil
  else
    if s2.size < 6
      @terminal_failures.pop
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
  end
  s1 << r2
  if r2
    r6 = _nt_ls32
    s1 << r6
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(IPv6address1)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i7, s7 = index, []
    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
    s7 << r8
    if r8
      s9, i9 = [], index
      loop do
        i10, s10 = index, []
        r11 = _nt_h16
        s10 << r11
        if r11
          if (match_len = has_terminal?(":", false, index))
            r12 = true
            @index += match_len
          else
            terminal_parse_failure('":"')
            r12 = nil
          end
          s10 << r12
        end
        if s10.last
          r10 = instantiate_node(SyntaxNode,input, i10...index, s10)
          r10.extend(IPv6address2)
        else
          @index = i10
          r10 = nil
        end
        if r10
          s9 << r10
        else
          break
        end
        if s9.size == 5
          break
        end
      end
      if s9.size < 5
        @index = i9
        r9 = nil
      else
        if s9.size < 5
          @terminal_failures.pop
        end
        r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
      end
      s7 << r9
      if r9
        r13 = _nt_ls32
        s7 << r13
      end
    end
    if s7.last
      r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
      r7.extend(IPv6address3)
    else
      @index = i7
      r7 = nil
    end
    if r7
      r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
      r0 = r7
    else
      i14, s14 = index, []
      r16 = _nt_h16
      if r16
        r15 = r16
      else
        r15 = instantiate_node(SyntaxNode,input, index...index)
      end
      s14 << r15
      if r15
        if (match_len = has_terminal?("::", false, index))
          r17 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('"::"')
          r17 = nil
        end
        s14 << r17
        if r17
          s18, i18 = [], index
          loop do
            i19, s19 = index, []
            r20 = _nt_h16
            s19 << r20
            if r20
              if (match_len = has_terminal?(":", false, index))
                r21 = true
                @index += match_len
              else
                terminal_parse_failure('":"')
                r21 = nil
              end
              s19 << r21
            end
            if s19.last
              r19 = instantiate_node(SyntaxNode,input, i19...index, s19)
              r19.extend(IPv6address4)
            else
              @index = i19
              r19 = nil
            end
            if r19
              s18 << r19
            else
              break
            end
            if s18.size == 4
              break
            end
          end
          if s18.size < 4
            @index = i18
            r18 = nil
          else
            if s18.size < 4
              @terminal_failures.pop
            end
            r18 = instantiate_node(SyntaxNode,input, i18...index, s18)
          end
          s14 << r18
          if r18
            r22 = _nt_ls32
            s14 << r22
          end
        end
      end
      if s14.last
        r14 = instantiate_node(SyntaxNode,input, i14...index, s14)
        r14.extend(IPv6address5)
      else
        @index = i14
        r14 = nil
      end
      if r14
        r14 = SyntaxNode.new(input, (index-1)...index) if r14 == true
        r0 = r14
      else
        i23, s23 = index, []
        i25, s25 = index, []
        r26 = _nt_h16
        s25 << r26
        if r26
          i28, s28 = index, []
          if (match_len = has_terminal?(":", false, index))
            r29 = true
            @index += match_len
          else
            terminal_parse_failure('":"')
            r29 = nil
          end
          s28 << r29
          if r29
            r30 = _nt_h16
            s28 << r30
          end
          if s28.last
            r28 = instantiate_node(SyntaxNode,input, i28...index, s28)
            r28.extend(IPv6address6)
          else
            @index = i28
            r28 = nil
          end
          if r28
            r27 = r28
          else
            r27 = instantiate_node(SyntaxNode,input, index...index)
          end
          s25 << r27
        end
        if s25.last
          r25 = instantiate_node(SyntaxNode,input, i25...index, s25)
          r25.extend(IPv6address7)
        else
          @index = i25
          r25 = nil
        end
        if r25
          r24 = r25
        else
          r24 = instantiate_node(SyntaxNode,input, index...index)
        end
        s23 << r24
        if r24
          if (match_len = has_terminal?("::", false, index))
            r31 = instantiate_node(SyntaxNode,input, index...(index + match_len))
            @index += match_len
          else
            terminal_parse_failure('"::"')
            r31 = nil
          end
          s23 << r31
          if r31
            s32, i32 = [], index
            loop do
              i33, s33 = index, []
              r34 = _nt_h16
              s33 << r34
              if r34
                if (match_len = has_terminal?(":", false, index))
                  r35 = true
                  @index += match_len
                else
                  terminal_parse_failure('":"')
                  r35 = nil
                end
                s33 << r35
              end
              if s33.last
                r33 = instantiate_node(SyntaxNode,input, i33...index, s33)
                r33.extend(IPv6address8)
              else
                @index = i33
                r33 = nil
              end
              if r33
                s32 << r33
              else
                break
              end
              if s32.size == 3
                break
              end
            end
            if s32.size < 3
              @index = i32
              r32 = nil
            else
              if s32.size < 3
                @terminal_failures.pop
              end
              r32 = instantiate_node(SyntaxNode,input, i32...index, s32)
            end
            s23 << r32
            if r32
              r36 = _nt_ls32
              s23 << r36
            end
          end
        end
        if s23.last
          r23 = instantiate_node(SyntaxNode,input, i23...index, s23)
          r23.extend(IPv6address9)
        else
          @index = i23
          r23 = nil
        end
        if r23
          r23 = SyntaxNode.new(input, (index-1)...index) if r23 == true
          r0 = r23
        else
          i37, s37 = index, []
          i39, s39 = index, []
          r40 = _nt_h16
          s39 << r40
          if r40
            s41, i41 = [], index
            loop do
              i42, s42 = index, []
              if (match_len = has_terminal?(":", false, index))
                r43 = true
                @index += match_len
              else
                terminal_parse_failure('":"')
                r43 = nil
              end
              s42 << r43
              if r43
                r44 = _nt_h16
                s42 << r44
              end
              if s42.last
                r42 = instantiate_node(SyntaxNode,input, i42...index, s42)
                r42.extend(IPv6address10)
              else
                @index = i42
                r42 = nil
              end
              if r42
                s41 << r42
              else
                break
              end
              if s41.size == 2
                break
              end
            end
            if s41.size < 2
              @terminal_failures.pop
            end
            r41 = instantiate_node(SyntaxNode,input, i41...index, s41)
            s39 << r41
          end
          if s39.last
            r39 = instantiate_node(SyntaxNode,input, i39...index, s39)
            r39.extend(IPv6address11)
          else
            @index = i39
            r39 = nil
          end
          if r39
            r38 = r39
          else
            r38 = instantiate_node(SyntaxNode,input, index...index)
          end
          s37 << r38
          if r38
            if (match_len = has_terminal?("::", false, index))
              r45 = instantiate_node(SyntaxNode,input, index...(index + match_len))
              @index += match_len
            else
              terminal_parse_failure('"::"')
              r45 = nil
            end
            s37 << r45
            if r45
              s46, i46 = [], index
              loop do
                i47, s47 = index, []
                r48 = _nt_h16
                s47 << r48
                if r48
                  if (match_len = has_terminal?(":", false, index))
                    r49 = true
                    @index += match_len
                  else
                    terminal_parse_failure('":"')
                    r49 = nil
                  end
                  s47 << r49
                end
                if s47.last
                  r47 = instantiate_node(SyntaxNode,input, i47...index, s47)
                  r47.extend(IPv6address12)
                else
                  @index = i47
                  r47 = nil
                end
                if r47
                  s46 << r47
                else
                  break
                end
                if s46.size == 2
                  break
                end
              end
              if s46.size < 2
                @index = i46
                r46 = nil
              else
                if s46.size < 2
                  @terminal_failures.pop
                end
                r46 = instantiate_node(SyntaxNode,input, i46...index, s46)
              end
              s37 << r46
              if r46
                r50 = _nt_ls32
                s37 << r50
              end
            end
          end
          if s37.last
            r37 = instantiate_node(SyntaxNode,input, i37...index, s37)
            r37.extend(IPv6address13)
          else
            @index = i37
            r37 = nil
          end
          if r37
            r37 = SyntaxNode.new(input, (index-1)...index) if r37 == true
            r0 = r37
          else
            i51, s51 = index, []
            i53, s53 = index, []
            r54 = _nt_h16
            s53 << r54
            if r54
              s55, i55 = [], index
              loop do
                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_h16
                  s56 << r58
                end
                if s56.last
                  r56 = instantiate_node(SyntaxNode,input, i56...index, s56)
                  r56.extend(IPv6address14)
                else
                  @index = i56
                  r56 = nil
                end
                if r56
                  s55 << r56
                else
                  break
                end
                if s55.size == 3
                  break
                end
              end
              if s55.size < 3
                @terminal_failures.pop
              end
              r55 = instantiate_node(SyntaxNode,input, i55...index, s55)
              s53 << r55
            end
            if s53.last
              r53 = instantiate_node(SyntaxNode,input, i53...index, s53)
              r53.extend(IPv6address15)
            else
              @index = i53
              r53 = nil
            end
            if r53
              r52 = r53
            else
              r52 = instantiate_node(SyntaxNode,input, index...index)
            end
            s51 << r52
            if r52
              if (match_len = has_terminal?("::", false, index))
                r59 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                @index += match_len
              else
                terminal_parse_failure('"::"')
                r59 = nil
              end
              s51 << r59
              if r59
                r60 = _nt_h16
                s51 << r60
                if r60
                  if (match_len = has_terminal?(":", false, index))
                    r61 = true
                    @index += match_len
                  else
                    terminal_parse_failure('":"')
                    r61 = nil
                  end
                  s51 << r61
                  if r61
                    r62 = _nt_ls32
                    s51 << r62
                  end
                end
              end
            end
            if s51.last
              r51 = instantiate_node(SyntaxNode,input, i51...index, s51)
              r51.extend(IPv6address16)
            else
              @index = i51
              r51 = nil
            end
            if r51
              r51 = SyntaxNode.new(input, (index-1)...index) if r51 == true
              r0 = r51
            else
              i63, s63 = index, []
              i65, s65 = index, []
              r66 = _nt_h16
              s65 << r66
              if r66
                s67, i67 = [], index
                loop do
                  i68, s68 = index, []
                  if (match_len = has_terminal?(":", false, index))
                    r69 = true
                    @index += match_len
                  else
                    terminal_parse_failure('":"')
                    r69 = nil
                  end
                  s68 << r69
                  if r69
                    r70 = _nt_h16
                    s68 << r70
                  end
                  if s68.last
                    r68 = instantiate_node(SyntaxNode,input, i68...index, s68)
                    r68.extend(IPv6address17)
                  else
                    @index = i68
                    r68 = nil
                  end
                  if r68
                    s67 << r68
                  else
                    break
                  end
                  if s67.size == 4
                    break
                  end
                end
                if s67.size < 4
                  @terminal_failures.pop
                end
                r67 = instantiate_node(SyntaxNode,input, i67...index, s67)
                s65 << r67
              end
              if s65.last
                r65 = instantiate_node(SyntaxNode,input, i65...index, s65)
                r65.extend(IPv6address18)
              else
                @index = i65
                r65 = nil
              end
              if r65
                r64 = r65
              else
                r64 = instantiate_node(SyntaxNode,input, index...index)
              end
              s63 << r64
              if r64
                if (match_len = has_terminal?("::", false, index))
                  r71 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                  @index += match_len
                else
                  terminal_parse_failure('"::"')
                  r71 = nil
                end
                s63 << r71
                if r71
                  r72 = _nt_ls32
                  s63 << r72
                end
              end
              if s63.last
                r63 = instantiate_node(SyntaxNode,input, i63...index, s63)
                r63.extend(IPv6address19)
              else
                @index = i63
                r63 = nil
              end
              if r63
                r63 = SyntaxNode.new(input, (index-1)...index) if r63 == true
                r0 = r63
              else
                i73, s73 = index, []
                i75, s75 = index, []
                r76 = _nt_h16
                s75 << r76
                if r76
                  s77, i77 = [], index
                  loop do
                    i78, s78 = index, []
                    if (match_len = has_terminal?(":", false, index))
                      r79 = true
                      @index += match_len
                    else
                      terminal_parse_failure('":"')
                      r79 = nil
                    end
                    s78 << r79
                    if r79
                      r80 = _nt_h16
                      s78 << r80
                    end
                    if s78.last
                      r78 = instantiate_node(SyntaxNode,input, i78...index, s78)
                      r78.extend(IPv6address20)
                    else
                      @index = i78
                      r78 = nil
                    end
                    if r78
                      s77 << r78
                    else
                      break
                    end
                    if s77.size == 5
                      break
                    end
                  end
                  if s77.size < 5
                    @terminal_failures.pop
                  end
                  r77 = instantiate_node(SyntaxNode,input, i77...index, s77)
                  s75 << r77
                end
                if s75.last
                  r75 = instantiate_node(SyntaxNode,input, i75...index, s75)
                  r75.extend(IPv6address21)
                else
                  @index = i75
                  r75 = nil
                end
                if r75
                  r74 = r75
                else
                  r74 = instantiate_node(SyntaxNode,input, index...index)
                end
                s73 << r74
                if r74
                  if (match_len = has_terminal?("::", false, index))
                    r81 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                    @index += match_len
                  else
                    terminal_parse_failure('"::"')
                    r81 = nil
                  end
                  s73 << r81
                  if r81
                    r82 = _nt_h16
                    s73 << r82
                  end
                end
                if s73.last
                  r73 = instantiate_node(SyntaxNode,input, i73...index, s73)
                  r73.extend(IPv6address22)
                else
                  @index = i73
                  r73 = nil
                end
                if r73
                  r73 = SyntaxNode.new(input, (index-1)...index) if r73 == true
                  r0 = r73
                else
                  i83, s83 = index, []
                  i85, s85 = index, []
                  r86 = _nt_h16
                  s85 << r86
                  if r86
                    s87, i87 = [], index
                    loop do
                      i88, s88 = index, []
                      if (match_len = has_terminal?(":", false, index))
                        r89 = true
                        @index += match_len
                      else
                        terminal_parse_failure('":"')
                        r89 = nil
                      end
                      s88 << r89
                      if r89
                        r90 = _nt_h16
                        s88 << r90
                      end
                      if s88.last
                        r88 = instantiate_node(SyntaxNode,input, i88...index, s88)
                        r88.extend(IPv6address23)
                      else
                        @index = i88
                        r88 = nil
                      end
                      if r88
                        s87 << r88
                      else
                        break
                      end
                      if s87.size == 6
                        break
                      end
                    end
                    if s87.size < 6
                      @terminal_failures.pop
                    end
                    r87 = instantiate_node(SyntaxNode,input, i87...index, s87)
                    s85 << r87
                  end
                  if s85.last
                    r85 = instantiate_node(SyntaxNode,input, i85...index, s85)
                    r85.extend(IPv6address24)
                  else
                    @index = i85
                    r85 = nil
                  end
                  if r85
                    r84 = r85
                  else
                    r84 = instantiate_node(SyntaxNode,input, index...index)
                  end
                  s83 << r84
                  if r84
                    if (match_len = has_terminal?("::", false, index))
                      r91 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                      @index += match_len
                    else
                      terminal_parse_failure('"::"')
                      r91 = nil
                    end
                    s83 << r91
                  end
                  if s83.last
                    r83 = instantiate_node(SyntaxNode,input, i83...index, s83)
                    r83.extend(IPv6address25)
                  else
                    @index = i83
                    r83 = nil
                  end
                  if r83
                    r83 = SyntaxNode.new(input, (index-1)...index) if r83 == true
                    r0 = r83
                  else
                    @index = i0
                    r0 = nil
                  end
                end
              end
            end
          end
        end
      end
    end
  end

  node_cache[:IPv6address][start_index] = r0

  r0
end

#_nt_ls32 ⇒ Object

# File 'lib/cbor-diagnostic-app/ipgrammar.rb', line 1158

def _nt_ls32
  start_index = index
  if node_cache[:ls32].has_key?(index)
    cached = node_cache[:ls32][index]
    if cached
      node_cache[:ls32][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_h16
  s1 << r2
  if r2
    if (match_len = has_terminal?(":", false, index))
      r3 = true
      @index += match_len
    else
      terminal_parse_failure('":"')
      r3 = nil
    end
    s1 << r3
    if r3
      r4 = _nt_h16
      s1 << r4
    end
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(Ls320)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r5 = _nt_IPv4address
    if r5
      r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
      r0 = r5
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:ls32][start_index] = r0

  r0
end

#_nt_uint ⇒ Object

# File 'lib/cbor-diagnostic-app/ipgrammar.rb', line 1633

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
  if (match_len = has_terminal?("0", false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('"0"')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i2, s2 = index, []
    r3 = _nt_DIGIT1
    s2 << r3
    if r3
      s4, i4 = [], index
      loop do
        r5 = _nt_DIGIT
        if r5
          s4 << r5
        else
          break
        end
      end
      r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
      s2 << r4
    end
    if s2.last
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
      r2.extend(Uint0)
    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[:uint][start_index] = r0

  r0
end

#root ⇒ Object

# File 'lib/cbor-diagnostic-app/ipgrammar.rb', line 8

def root
  @root ||= :app_string_ip
end