Module: JPTGRAMMAR

Includes:: Treetop::Runtime

Included in:: JPTGRAMMARParser

Defined in:: lib/parser/jptgrammar.rb

Defined Under Namespace

Modules: AbsSingularQuery0, AbsSingularQuery1, BracketedSelection0, BracketedSelection1, BracketedSelection2, ChildSegment0, ChildSegment1, ComparisonExpr0, ComparisonExpr1, DescendantSegment0, DescendantSegment1, DoubleQuoted0, DoubleQuoted1, DoubleQuoted2, DoubleQuoted3, DoubleQuoted4, Escapable0, Escapable1, Escapable2, Escapable3, Escapable4, Escapable5, Escapable6, Escapable7, Escapable8, Exp0, False0, FilterSelector0, FilterSelector1, Frac0, FunctionExpr0, FunctionExpr1, FunctionExpr2, FunctionExpr3, FunctionName0, Hexchar0, Hexchar1, Hexchar2, HighSurrogate0, IndexSegment0, IndexSegment1, IndexSelector0, Int0, Jptgrammar0, Jptgrammar1, JsonpathQuery0, JsonpathQuery1, LogicalAndExpr0, LogicalAndExpr1, LogicalAndExpr2, LogicalOrExpr0, LogicalOrExpr1, LogicalOrExpr2, LowSurrogate0, MemberNameShorthand0, MemberNameShorthand1, NameSegment0, NameSegment1, NameSegment2, NameSegment3, NonSurrogate0, NonSurrogate1, NormalEscapable0, NormalHexchar0, NormalHexchar1, NormalHexchar2, NormalHexchar3, NormalHexchar4, NormalIndexSegment0, NormalIndexSelector0, NormalNameSelector0, NormalSingleQuoted0, NormalizedPath0, Null0, Number0, Number1, ParenExpr0, ParenExpr1, ParenExpr2, RelQuery0, RelQuery1, RelSingularQuery0, RelSingularQuery1, Segments0, Segments1, SingleQuoted0, SingleQuoted1, SingleQuoted2, SingleQuoted3, SingleQuoted4, SingularQuerySegments0, SingularQuerySegments1, SliceSelector0, SliceSelector1, SliceSelector2, SliceSelector3, SliceSelector4, SliceSelector5, StringLiteral0, StringLiteral1, StringLiteral2, StringLiteral3, TestExpr0, TestExpr1, TestExpr2, True0, Unescaped0, WildcardSelector0

Instance Method Summary collapse

Instance Method Details

#_nt_abs_singular_query ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 2995

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

  i0, s0 = index, []
  r1 = _nt_root_identifier
  s0 << r1
  if r1
    r2 = _nt_singular_query_segments
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(AbsSingularQuery0)
    r0.extend(AbsSingularQuery1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:abs_singular_query][start_index] = r0

  r0
end

#_nt_ALPHA ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 4328

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

# File 'lib/parser/jptgrammar.rb', line 166

def _nt_B
  start_index = index
  if node_cache[:B].has_key?(index)
    cached = node_cache[:B][index]
    if cached
      node_cache[:B][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?("\t", false, index))
      r2 = true
      @index += match_len
    else
      terminal_parse_failure('"\\t"')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      if (match_len = has_terminal?("\n", false, index))
        r3 = true
        @index += match_len
      else
        terminal_parse_failure('"\\n"')
        r3 = nil
      end
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
      else
        if (match_len = has_terminal?("\r", false, index))
          r4 = true
          @index += match_len
        else
          terminal_parse_failure('"\\r"')
          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[:B][start_index] = r0

  r0
end

#_nt_basic_expr ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 2273

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

  i0 = index
  r1 = _nt_paren_expr
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r2 = _nt_comparison_expr
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      r3 = _nt_test_expr
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
      else
        @index = i0
        r0 = nil
      end
    end
  end

  node_cache[:basic_expr][start_index] = r0

  r0
end

#_nt_bracketed_selection ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 4060

def _nt_bracketed_selection
  start_index = index
  if node_cache[:bracketed_selection].has_key?(index)
    cached = node_cache[:bracketed_selection][index]
    if cached
      node_cache[:bracketed_selection][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_selector
      s0 << r3
      if r3
        s4, i4 = [], index
        loop do
          i5, s5 = index, []
          r6 = _nt_S
          s5 << r6
          if r6
            if (match_len = has_terminal?(",", false, index))
              r7 = true
              @index += match_len
            else
              terminal_parse_failure('","')
              r7 = nil
            end
            s5 << r7
            if r7
              r8 = _nt_S
              s5 << r8
              if r8
                r9 = _nt_selector
                s5 << r9
              end
            end
          end
          if s5.last
            r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
            r5.extend(BracketedSelection0)
          else
            @index = i5
            r5 = nil
          end
          if r5
            s4 << r5
          else
            break
          end
        end
        r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
        s0 << r4
        if r4
          r10 = _nt_S
          s0 << r10
          if r10
            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(BracketedSelection1)
    r0.extend(BracketedSelection2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:bracketed_selection][start_index] = r0

  r0
end

#_nt_child_segment ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 3954

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

  i0 = index
  r1 = _nt_bracketed_selection
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i2, s2 = index, []
    if (match_len = has_terminal?(".", false, index))
      r3 = true
      @index += match_len
    else
      terminal_parse_failure('"."')
      r3 = nil
    end
    s2 << r3
    if r3
      i4 = index
      r5 = _nt_wildcard_selector
      if r5
        r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
        r4 = r5
      else
        r6 = _nt_member_name_shorthand
        if r6
          r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
          r4 = r6
        else
          @index = i4
          r4 = nil
        end
      end
      s2 << r4
    end
    if s2.last
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
      r2.extend(ChildSegment0)
      r2.extend(ChildSegment1)
    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[:child_segment][start_index] = r0

  r0
end

#_nt_comparable ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 2769

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

  i0 = index
  r1 = _nt_literal
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r2 = _nt_singular_query
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      r3 = _nt_function_expr
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
      else
        @index = i0
        r0 = nil
      end
    end
  end

  node_cache[:comparable][start_index] = r0

  r0
end

#_nt_comparison_expr ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 2675

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

  i0, s0 = index, []
  r1 = _nt_comparable
  s0 << r1
  if r1
    r2 = _nt_S
    s0 << r2
    if r2
      r3 = _nt_comparison_op
      s0 << r3
      if r3
        r4 = _nt_S
        s0 << r4
        if r4
          r5 = _nt_comparable
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ComparisonExpr0)
    r0.extend(ComparisonExpr1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:comparison_expr][start_index] = r0

  r0
end

#_nt_comparison_op ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 2807

def _nt_comparison_op
  start_index = index
  if node_cache[:comparison_op].has_key?(index)
    cached = node_cache[:comparison_op][index]
    if cached
      node_cache[:comparison_op][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
      if (match_len = has_terminal?("<=", false, index))
        r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
        @index += match_len
      else
        terminal_parse_failure('"<="')
        r3 = nil
      end
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
      else
        if (match_len = has_terminal?(">=", false, index))
          r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @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
          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
            r0 = r5
          else
            if (match_len = has_terminal?(">", false, index))
              r6 = true
              @index += match_len
            else
              terminal_parse_failure('">"')
              r6 = nil
            end
            if r6
              r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
              r0 = r6
            else
              @index = i0
              r0 = nil
            end
          end
        end
      end
    end
  end

  node_cache[:comparison_op][start_index] = r0

  r0
end

#_nt_current_node_identifier ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 2619

def _nt_current_node_identifier
  start_index = index
  if node_cache[:current_node_identifier].has_key?(index)
    cached = node_cache[:current_node_identifier][index]
    if cached
      node_cache[:current_node_identifier][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[:current_node_identifier][start_index] = r0

  r0
end

#_nt_descendant_segment ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 4381

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

  i0, s0 = index, []
  if (match_len = has_terminal?("..", false, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('".."')
    r1 = nil
  end
  s0 << r1
  if r1
    i2 = index
    r3 = _nt_bracketed_selection
    if r3
      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
      r2 = r3
    else
      r4 = _nt_wildcard_selector
      if r4
        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
        r2 = r4
      else
        r5 = _nt_member_name_shorthand
        if r5
          r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
          r2 = r5
        else
          @index = i2
          r2 = nil
        end
      end
    end
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(DescendantSegment0)
    r0.extend(DescendantSegment1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:descendant_segment][start_index] = r0

  r0
end

#_nt_DIGIT ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 4304

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/parser/jptgrammar.rb', line 1743

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

# File 'lib/parser/jptgrammar.rb', line 510

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

  i0 = index
  r1 = _nt_unescaped
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if (match_len = has_terminal?("'", false, index))
      r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      r2.extend(DoubleQuoted0)
      @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
      i3, s3 = index, []
      r4 = _nt_ESC
      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(DoubleQuoted1)
        r3.extend(DoubleQuoted2)
      else
        @index = i3
        r3 = nil
      end
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
      else
        i6, s6 = index, []
        r7 = _nt_ESC
        s6 << r7
        if r7
          r8 = _nt_escapable
          s6 << r8
        end
        if s6.last
          r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
          r6.extend(DoubleQuoted3)
          r6.extend(DoubleQuoted4)
        else
          @index = i6
          r6 = nil
        end
        if r6
          r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
          r0 = r6
        else
          @index = i0
          r0 = nil
        end
      end
    end
  end

  node_cache[:double_quoted][start_index] = r0

  r0
end

#_nt_ESC ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 709

def _nt_ESC
  start_index = index
  if node_cache[:ESC].has_key?(index)
    cached = node_cache[:ESC][index]
    if cached
      node_cache[:ESC][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[:ESC][start_index] = r0

  r0
end

#_nt_escapable ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 867

def _nt_escapable
  start_index = index
  if node_cache[:escapable].has_key?(index)
    cached = node_cache[:escapable][index]
    if cached
      node_cache[:escapable][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?("b", false, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    r1.extend(Escapable0)
    @index += match_len
  else
    terminal_parse_failure('"b"')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if (match_len = has_terminal?("f", false, index))
      r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      r2.extend(Escapable1)
      @index += match_len
    else
      terminal_parse_failure('"f"')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      if (match_len = has_terminal?("n", false, index))
        r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
        r3.extend(Escapable2)
        @index += match_len
      else
        terminal_parse_failure('"n"')
        r3 = nil
      end
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
      else
        if (match_len = has_terminal?("r", false, index))
          r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          r4.extend(Escapable3)
          @index += match_len
        else
          terminal_parse_failure('"r"')
          r4 = nil
        end
        if r4
          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
          r0 = r4
        else
          if (match_len = has_terminal?("t", false, index))
            r5 = instantiate_node(SyntaxNode,input, index...(index + match_len))
            r5.extend(Escapable4)
            @index += match_len
          else
            terminal_parse_failure('"t"')
            r5 = nil
          end
          if r5
            r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
            r0 = r5
          else
            if (match_len = has_terminal?("/", false, index))
              r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
              r6.extend(Escapable5)
              @index += match_len
            else
              terminal_parse_failure('"/"')
              r6 = nil
            end
            if r6
              r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
              r0 = r6
            else
              if (match_len = has_terminal?("\\", false, index))
                r7 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                r7.extend(Escapable6)
                @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
                i8, s8 = index, []
                if (match_len = has_terminal?("u", false, index))
                  r9 = true
                  @index += match_len
                else
                  terminal_parse_failure('"u"')
                  r9 = nil
                end
                s8 << r9
                if r9
                  r10 = _nt_hexchar
                  s8 << r10
                end
                if s8.last
                  r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
                  r8.extend(Escapable7)
                  r8.extend(Escapable8)
                else
                  @index = i8
                  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
          end
        end
      end
    end
  end

  node_cache[:escapable][start_index] = r0

  r0
end

#_nt_exp ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 3402

def _nt_exp
  start_index = index
  if node_cache[:exp].has_key?(index)
    cached = node_cache[:exp][index]
    if cached
      node_cache[:exp][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?("e", :insens, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('"e"')
    r1 = nil
  end
  s0 << r1
  if r1
    i3 = index
    if (match_len = has_terminal?("-", false, index))
      r4 = true
      @index += match_len
    else
      terminal_parse_failure('"-"')
      r4 = nil
    end
    if r4
      r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
      r3 = r4
    else
      if (match_len = has_terminal?("+", false, index))
        r5 = true
        @index += match_len
      else
        terminal_parse_failure('"+"')
        r5 = nil
      end
      if r5
        r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
        r3 = r5
      else
        @index = i3
        r3 = nil
      end
    end
    if r3
      r2 = r3
    else
      r2 = instantiate_node(SyntaxNode,input, index...index)
    end
    s0 << r2
    if r2
      s6, i6 = [], index
      loop do
        r7 = _nt_DIGIT
        if r7
          s6 << r7
        else
          break
        end
      end
      if s6.empty?
        @index = i6
        r6 = nil
      else
        r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
      end
      s0 << r6
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Exp0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:exp][start_index] = r0

  r0
end

#_nt_false ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 3521

def _nt_false
  start_index = index
  if node_cache[:false].has_key?(index)
    cached = node_cache[:false][index]
    if cached
      node_cache[:false][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", false, index))
    r0 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    r0.extend(False0)
    @index += match_len
  else
    terminal_parse_failure('"false"')
    r0 = nil
  end

  node_cache[:false][start_index] = r0

  r0
end

#_nt_filter_query ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 2539

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

  i0 = index
  r1 = _nt_rel_query
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r2 = _nt_jsonpath_query
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:filter_query][start_index] = r0

  r0
end

#_nt_filter_selector ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 2015

def _nt_filter_selector
  start_index = index
  if node_cache[:filter_selector].has_key?(index)
    cached = node_cache[:filter_selector][index]
    if cached
      node_cache[:filter_selector][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_logical_expr
      s0 << r3
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(FilterSelector0)
    r0.extend(FilterSelector1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:filter_selector][start_index] = r0

  r0
end

#_nt_frac ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 3348

def _nt_frac
  start_index = index
  if node_cache[:frac].has_key?(index)
    cached = node_cache[:frac][index]
    if cached
      node_cache[:frac][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_DIGIT
      if r3
        s2 << r3
      else
        break
      end
    end
    if s2.empty?
      @index = i2
      r2 = nil
    else
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    end
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Frac0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:frac][start_index] = r0

  r0
end

#_nt_function_argument ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 3869

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

  i0 = index
  r1 = _nt_literal
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r2 = _nt_filter_query
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      r3 = _nt_logical_expr
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
      else
        r4 = _nt_function_expr
        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[:function_argument][start_index] = r0

  r0
end

#_nt_function_expr ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 3755

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

  i0, s0 = index, []
  r1 = _nt_function_name
  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_S
      s0 << r3
      if r3
        i5, s5 = index, []
        r6 = _nt_function_argument
        s5 << r6
        if r6
          s7, i7 = [], index
          loop do
            i8, s8 = index, []
            r9 = _nt_S
            s8 << r9
            if r9
              if (match_len = has_terminal?(",", false, index))
                r10 = true
                @index += match_len
              else
                terminal_parse_failure('","')
                r10 = nil
              end
              s8 << r10
              if r10
                r11 = _nt_S
                s8 << r11
                if r11
                  r12 = _nt_function_argument
                  s8 << r12
                end
              end
            end
            if s8.last
              r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
              r8.extend(FunctionExpr0)
            else
              @index = i8
              r8 = nil
            end
            if r8
              s7 << r8
            else
              break
            end
          end
          r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
          s5 << r7
        end
        if s5.last
          r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
          r5.extend(FunctionExpr1)
        else
          @index = i5
          r5 = nil
        end
        if r5
          r4 = r5
        else
          r4 = instantiate_node(SyntaxNode,input, index...index)
        end
        s0 << r4
        if r4
          r13 = _nt_S
          s0 << r13
          if r13
            if (match_len = has_terminal?(")", false, index))
              r14 = true
              @index += match_len
            else
              terminal_parse_failure('")"')
              r14 = nil
            end
            s0 << r14
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(FunctionExpr2)
    r0.extend(FunctionExpr3)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:function_expr][start_index] = r0

  r0
end

#_nt_function_name ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 3582

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

  i0, s0 = index, []
  r1 = _nt_function_name_first
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_function_name_char
      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(FunctionName0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:function_name][start_index] = r0

  r0
end

#_nt_function_name_char ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 3640

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

  i0 = index
  r1 = _nt_function_name_first
  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
      r3 = _nt_DIGIT
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
      else
        @index = i0
        r0 = nil
      end
    end
  end

  node_cache[:function_name_char][start_index] = r0

  r0
end

#_nt_function_name_first ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 3622

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

  r0 = _nt_LCALPHA

  node_cache[:function_name_first][start_index] = r0

  r0
end

#_nt_hexchar ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 1026

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
  r1.extend(Hexchar0)
  r1.extend(Hexchar0)
  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(Hexchar1)
      r2.extend(Hexchar2)
    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_HEXDIG ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 1510

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

# File 'lib/parser/jptgrammar.rb', line 1285

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

# File 'lib/parser/jptgrammar.rb', line 3216

def _nt_index_segment
  start_index = index
  if node_cache[:index_segment].has_key?(index)
    cached = node_cache[:index_segment][index]
    if cached
      node_cache[:index_segment][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_index_selector
    s0 << r2
    if r2
      if (match_len = has_terminal?("]", false, index))
        r3 = true
        @index += match_len
      else
        terminal_parse_failure('"]"')
        r3 = nil
      end
      s0 << r3
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(IndexSegment0)
    r0.extend(IndexSegment1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:index_segment][start_index] = r0

  r0
end

#_nt_index_selector ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 1641

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

  r0 = _nt_int
  r0.extend(IndexSelector0)
  r0.extend(IndexSelector0)

  node_cache[:index_selector][start_index] = r0

  r0
end

#_nt_int ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 1668

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 = 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, []
    if (match_len = has_terminal?("-", false, index))
      r4 = true
      @index += match_len
    else
      terminal_parse_failure('"-"')
      r4 = nil
    end
    if r4
      r3 = r4
    else
      r3 = instantiate_node(SyntaxNode,input, index...index)
    end
    s2 << r3
    if r3
      r5 = _nt_DIGIT1
      s2 << r5
      if r5
        s6, i6 = [], index
        loop do
          r7 = _nt_DIGIT
          if r7
            s6 << r7
          else
            break
          end
        end
        r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
        s2 << r6
      end
    end
    if s2.last
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
      r2.extend(Int0)
    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[:int][start_index] = r0

  r0
end

#_nt_jptgrammar ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 28

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

  i0, s0 = index, []
  r1 = _nt_jsonpath_query
  s0 << r1
  if r1
    r2 = _nt_S
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Jptgrammar0)
    r0.extend(Jptgrammar1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:jptgrammar][start_index] = r0

  r0
end

#_nt_jsonpath_query ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 76

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

  i0, s0 = index, []
  r1 = _nt_root_identifier
  s0 << r1
  if r1
    r2 = _nt_segments
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(JsonpathQuery0)
    r0.extend(JsonpathQuery1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:jsonpath_query][start_index] = r0

  r0
end

#_nt_LCALPHA ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 3684

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

  if has_terminal?(@regexps[gr = '\A[a-z]'] ||= Regexp.new(gr), :regexp, index)
    r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
    @index += 1
  else
    terminal_parse_failure('[a-z]')
    r0 = nil
  end

  node_cache[:LCALPHA][start_index] = r0

  r0
end

#_nt_literal ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 2719

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

  i0 = index
  r1 = _nt_number
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r2 = _nt_string_literal
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      r3 = _nt_true
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
      else
        r4 = _nt_false
        if r4
          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
          r0 = r4
        else
          r5 = _nt_null
          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[:literal][start_index] = r0

  r0
end

#_nt_logical_and_expr ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 2205

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

  i0, s0 = index, []
  r1 = _nt_basic_expr
  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_basic_expr
            s3 << r7
          end
        end
      end
      if s3.last
        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
        r3.extend(LogicalAndExpr0)
      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(LogicalAndExpr1)
    r0.extend(LogicalAndExpr2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:logical_and_expr][start_index] = r0

  r0
end

#_nt_logical_expr ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 2057

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

  r0 = _nt_logical_or_expr

  node_cache[:logical_expr][start_index] = r0

  r0
end

#_nt_logical_not_op ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 2424

def _nt_logical_not_op
  start_index = index
  if node_cache[:logical_not_op].has_key?(index)
    cached = node_cache[:logical_not_op][index]
    if cached
      node_cache[:logical_not_op][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[:logical_not_op][start_index] = r0

  r0
end

#_nt_logical_or_expr ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 2106

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

  i0, s0 = index, []
  r1 = _nt_logical_and_expr
  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_logical_and_expr
            s3 << r7
          end
        end
      end
      if s3.last
        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
        r3.extend(LogicalOrExpr0)
      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(LogicalOrExpr1)
    r0.extend(LogicalOrExpr2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:logical_or_expr][start_index] = r0

  r0
end

#_nt_low_surrogate ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 1399

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

# File 'lib/parser/jptgrammar.rb', line 4169

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

  i0, s0 = index, []
  r1 = _nt_name_first
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_name_char
      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(MemberNameShorthand0)
    r0.extend(MemberNameShorthand1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:member_name_shorthand][start_index] = r0

  r0
end

#_nt_name_char ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 4272

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

  i0 = index
  r1 = _nt_name_first
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r2 = _nt_DIGIT
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:name_char][start_index] = r0

  r0
end

#_nt_name_first ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 4210

def _nt_name_first
  start_index = index
  if node_cache[:name_first].has_key?(index)
    cached = node_cache[:name_first][index]
    if cached
      node_cache[:name_first][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 has_terminal?(@regexps[gr = '\A[-퟿]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[-퟿]')
        r3 = nil
      end
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
      else
        if has_terminal?(@regexps[gr = '\A[-􏿿]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[-􏿿]')
          r4 = nil
        end
        if r4
          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
          r0 = r4
        else
          @index = i0
          r0 = nil
        end
      end
    end
  end

  node_cache[:name_first][start_index] = r0

  r0
end

#_nt_name_segment ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 3121

def _nt_name_segment
  start_index = index
  if node_cache[:name_segment].has_key?(index)
    cached = node_cache[:name_segment][index]
    if cached
      node_cache[:name_segment][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?("[", false, index))
    r2 = true
    @index += match_len
  else
    terminal_parse_failure('"["')
    r2 = nil
  end
  s1 << r2
  if r2
    r3 = _nt_name_selector
    s1 << r3
    if r3
      if (match_len = has_terminal?("]", false, index))
        r4 = true
        @index += match_len
      else
        terminal_parse_failure('"]"')
        r4 = nil
      end
      s1 << r4
    end
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(NameSegment0)
    r1.extend(NameSegment1)
  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?(".", false, index))
      r6 = true
      @index += match_len
    else
      terminal_parse_failure('"."')
      r6 = nil
    end
    s5 << r6
    if r6
      r7 = _nt_member_name_shorthand
      s5 << r7
    end
    if s5.last
      r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
      r5.extend(NameSegment2)
      r5.extend(NameSegment3)
    else
      @index = i5
      r5 = nil
    end
    if r5
      r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
      r0 = r5
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:name_segment][start_index] = r0

  r0
end

#_nt_name_selector ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 335

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

  r0 = _nt_string_literal

  node_cache[:name_selector][start_index] = r0

  r0
end

#_nt_non_surrogate ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 1100

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

# File 'lib/parser/jptgrammar.rb', line 4748

def _nt_normal_escapable
  start_index = index
  if node_cache[:normal_escapable].has_key?(index)
    cached = node_cache[:normal_escapable][index]
    if cached
      node_cache[:normal_escapable][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?("b", false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('"b"')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if (match_len = has_terminal?("f", false, index))
      r2 = true
      @index += match_len
    else
      terminal_parse_failure('"f"')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      if (match_len = has_terminal?("n", false, index))
        r3 = true
        @index += match_len
      else
        terminal_parse_failure('"n"')
        r3 = nil
      end
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
      else
        if (match_len = has_terminal?("r", false, index))
          r4 = true
          @index += match_len
        else
          terminal_parse_failure('"r"')
          r4 = nil
        end
        if r4
          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
          r0 = r4
        else
          if (match_len = has_terminal?("t", false, index))
            r5 = true
            @index += match_len
          else
            terminal_parse_failure('"t"')
            r5 = nil
          end
          if r5
            r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
            r0 = r5
          else
            if (match_len = has_terminal?("'", false, index))
              r6 = true
              @index += match_len
            else
              terminal_parse_failure('"\'"')
              r6 = nil
            end
            if r6
              r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
              r0 = 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
                r0 = r7
              else
                i8, s8 = index, []
                if (match_len = has_terminal?("u", false, index))
                  r9 = true
                  @index += match_len
                else
                  terminal_parse_failure('"u"')
                  r9 = nil
                end
                s8 << r9
                if r9
                  r10 = _nt_normal_hexchar
                  s8 << r10
                end
                if s8.last
                  r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
                  r8.extend(NormalEscapable0)
                else
                  @index = i8
                  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
          end
        end
      end
    end
  end

  node_cache[:normal_escapable][start_index] = r0

  r0
end

#_nt_normal_hexchar ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 4895

def _nt_normal_hexchar
  start_index = index
  if node_cache[:normal_hexchar].has_key?(index)
    cached = node_cache[:normal_hexchar][index]
    if cached
      node_cache[:normal_hexchar][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?("0", false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('"0"')
    r1 = nil
  end
  s0 << r1
  if r1
    if (match_len = has_terminal?("0", false, index))
      r2 = true
      @index += match_len
    else
      terminal_parse_failure('"0"')
      r2 = nil
    end
    s0 << r2
    if r2
      i3 = index
      i4, s4 = index, []
      if (match_len = has_terminal?("0", false, index))
        r5 = true
        @index += match_len
      else
        terminal_parse_failure('"0"')
        r5 = nil
      end
      s4 << r5
      if r5
        if has_terminal?(@regexps[gr = '\A[0-7]'] ||= Regexp.new(gr), :regexp, index)
          r6 = true
          @index += 1
        else
          terminal_parse_failure('[0-7]')
          r6 = nil
        end
        s4 << r6
      end
      if s4.last
        r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
        r4.extend(NormalHexchar0)
      else
        @index = i4
        r4 = nil
      end
      if r4
        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
        r3 = r4
      else
        i7, s7 = index, []
        if (match_len = has_terminal?("0", false, index))
          r8 = true
          @index += match_len
        else
          terminal_parse_failure('"0"')
          r8 = nil
        end
        s7 << r8
        if r8
          if (match_len = has_terminal?("b", false, index))
            r9 = true
            @index += match_len
          else
            terminal_parse_failure('"b"')
            r9 = nil
          end
          s7 << r9
        end
        if s7.last
          r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
          r7.extend(NormalHexchar1)
        else
          @index = i7
          r7 = nil
        end
        if r7
          r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
          r3 = r7
        else
          i10, s10 = index, []
          if (match_len = has_terminal?("0", false, index))
            r11 = true
            @index += match_len
          else
            terminal_parse_failure('"0"')
            r11 = nil
          end
          s10 << r11
          if r11
            if has_terminal?(@regexps[gr = '\A[e-f]'] ||= Regexp.new(gr), :regexp, index)
              r12 = true
              @index += 1
            else
              terminal_parse_failure('[e-f]')
              r12 = nil
            end
            s10 << r12
          end
          if s10.last
            r10 = instantiate_node(SyntaxNode,input, i10...index, s10)
            r10.extend(NormalHexchar2)
          else
            @index = i10
            r10 = nil
          end
          if r10
            r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
            r3 = r10
          else
            i13, s13 = index, []
            if (match_len = has_terminal?("1", false, index))
              r14 = true
              @index += match_len
            else
              terminal_parse_failure('"1"')
              r14 = nil
            end
            s13 << r14
            if r14
              r15 = _nt_normal_HEXDIG
              s13 << r15
            end
            if s13.last
              r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
              r13.extend(NormalHexchar3)
            else
              @index = i13
              r13 = nil
            end
            if r13
              r13 = SyntaxNode.new(input, (index-1)...index) if r13 == true
              r3 = r13
            else
              @index = i3
              r3 = nil
            end
          end
        end
      end
      s0 << r3
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(NormalHexchar4)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:normal_hexchar][start_index] = r0

  r0
end

#_nt_normal_HEXDIG ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 5062

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

  i0 = index
  r1 = _nt_DIGIT
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if has_terminal?(@regexps[gr = '\A[a-f]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[a-f]')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:normal_HEXDIG][start_index] = r0

  r0
end

#_nt_normal_index_segment ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 4493

def _nt_normal_index_segment
  start_index = index
  if node_cache[:normal_index_segment].has_key?(index)
    cached = node_cache[:normal_index_segment][index]
    if cached
      node_cache[:normal_index_segment][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_normal_selector
    s0 << r2
    if r2
      if (match_len = has_terminal?("]", false, index))
        r3 = true
        @index += match_len
      else
        terminal_parse_failure('"]"')
        r3 = nil
      end
      s0 << r3
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(NormalIndexSegment0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:normal_index_segment][start_index] = r0

  r0
end

#_nt_normal_index_selector ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 5107

def _nt_normal_index_selector
  start_index = index
  if node_cache[:normal_index_selector].has_key?(index)
    cached = node_cache[:normal_index_selector][index]
    if cached
      node_cache[:normal_index_selector][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(NormalIndexSelector0)
    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[:normal_index_selector][start_index] = r0

  r0
end

#_nt_normal_name_selector ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 4575

def _nt_normal_name_selector
  start_index = index
  if node_cache[:normal_name_selector].has_key?(index)
    cached = node_cache[:normal_name_selector][index]
    if cached
      node_cache[:normal_name_selector][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_normal_single_quoted
      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(NormalNameSelector0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:normal_name_selector][start_index] = r0

  r0
end

#_nt_normal_selector ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 4540

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

  i0 = index
  r1 = _nt_normal_name_selector
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r2 = _nt_normal_index_selector
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:normal_selector][start_index] = r0

  r0
end

#_nt_normal_single_quoted ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 4641

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

  i0 = index
  r1 = _nt_normal_unescaped
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i2, s2 = index, []
    r3 = _nt_ESC
    s2 << r3
    if r3
      r4 = _nt_normal_escapable
      s2 << r4
    end
    if s2.last
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
      r2.extend(NormalSingleQuoted0)
    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[:normal_single_quoted][start_index] = r0

  r0
end

#_nt_normal_unescaped ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 4686

def _nt_normal_unescaped
  start_index = index
  if node_cache[:normal_unescaped].has_key?(index)
    cached = node_cache[:normal_unescaped][index]
    if cached
      node_cache[:normal_unescaped][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
        @index = i0
        r0 = nil
      end
    end
  end

  node_cache[:normal_unescaped][start_index] = r0

  r0
end

#_nt_normalized_path ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 4446

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

  i0, s0 = index, []
  r1 = _nt_root_identifier
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_normal_index_segment
      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(NormalizedPath0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:normalized_path][start_index] = r0

  r0
end

#_nt_null ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 3550

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

  if (match_len = has_terminal?("null", false, index))
    r0 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    r0.extend(Null0)
    @index += match_len
  else
    terminal_parse_failure('"null"')
    r0 = nil
  end

  node_cache[:null][start_index] = r0

  r0
end

#_nt_number ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 3279

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, s0 = index, []
  i1 = index
  r2 = _nt_int
  if r2
    r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
    r1 = r2
  else
    if (match_len = has_terminal?("-0", false, index))
      r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('"-0"')
      r3 = nil
    end
    if r3
      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
      r1 = r3
    else
      @index = i1
      r1 = nil
    end
  end
  s0 << r1
  if r1
    r5 = _nt_frac
    if r5
      r4 = r5
    else
      r4 = instantiate_node(SyntaxNode,input, index...index)
    end
    s0 << r4
    if r4
      r7 = _nt_exp
      if r7
        r6 = r7
      else
        r6 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r6
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Number0)
    r0.extend(Number1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:number][start_index] = r0

  r0
end

#_nt_paren_expr ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 2346

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

  i0, s0 = index, []
  i2, s2 = index, []
  r3 = _nt_logical_not_op
  s2 << r3
  if r3
    r4 = _nt_S
    s2 << r4
  end
  if s2.last
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    r2.extend(ParenExpr0)
  else
    @index = i2
    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?("(", false, index))
      r5 = true
      @index += match_len
    else
      terminal_parse_failure('"("')
      r5 = nil
    end
    s0 << r5
    if r5
      r6 = _nt_S
      s0 << r6
      if r6
        r7 = _nt_logical_expr
        s0 << r7
        if r7
          r8 = _nt_S
          s0 << r8
          if r8
            if (match_len = has_terminal?(")", false, index))
              r9 = true
              @index += match_len
            else
              terminal_parse_failure('")"')
              r9 = nil
            end
            s0 << r9
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ParenExpr1)
    r0.extend(ParenExpr2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:paren_expr][start_index] = r0

  r0
end

#_nt_r__end ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 1963

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

  r0 = _nt_int

  node_cache[:r__end][start_index] = r0

  r0
end

#_nt_rel_query ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 2587

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

  i0, s0 = index, []
  r1 = _nt_current_node_identifier
  s0 << r1
  if r1
    r2 = _nt_segments
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(RelQuery0)
    r0.extend(RelQuery1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:rel_query][start_index] = r0

  r0
end

#_nt_rel_singular_query ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 2947

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

  i0, s0 = index, []
  r1 = _nt_current_node_identifier
  s0 << r1
  if r1
    r2 = _nt_singular_query_segments
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(RelSingularQuery0)
    r0.extend(RelSingularQuery1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:rel_singular_query][start_index] = r0

  r0
end

#_nt_root_identifier ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 261

def _nt_root_identifier
  start_index = index
  if node_cache[:root_identifier].has_key?(index)
    cached = node_cache[:root_identifier][index]
    if cached
      node_cache[:root_identifier][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[:root_identifier][start_index] = r0

  r0
end

#_nt_S ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 234

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_B
    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_segment ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 3913

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

  i0 = index
  r1 = _nt_child_segment
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r2 = _nt_descendant_segment
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:segment][start_index] = r0

  r0
end

#_nt_segments ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 124

def _nt_segments
  start_index = index
  if node_cache[:segments].has_key?(index)
    cached = node_cache[:segments][index]
    if cached
      node_cache[:segments][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_S
    s1 << r2
    if r2
      r3 = _nt_segment
      s1 << r3
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(Segments0)
    else
      @index = i1
      r1 = nil
    end
    if r1
      s0 << r1
    else
      break
    end
  end
  r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
  r0.extend(Segments1)
  r0.extend(Segments1)

  node_cache[:segments][start_index] = r0

  r0
end

#_nt_selector ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 285

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

  i0 = index
  r1 = _nt_name_selector
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r2 = _nt_wildcard_selector
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      r3 = _nt_slice_selector
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
      else
        r4 = _nt_index_selector
        if r4
          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
          r0 = r4
        else
          r5 = _nt_filter_selector
          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[:selector][start_index] = r0

  r0
end

#_nt_single_quoted ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 624

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

  i0 = index
  r1 = _nt_unescaped
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if (match_len = has_terminal?("\"", false, index))
      r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      r2.extend(SingleQuoted0)
      @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
      i3, s3 = index, []
      r4 = _nt_ESC
      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(SingleQuoted1)
        r3.extend(SingleQuoted2)
      else
        @index = i3
        r3 = nil
      end
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
      else
        i6, s6 = index, []
        r7 = _nt_ESC
        s6 << r7
        if r7
          r8 = _nt_escapable
          s6 << r8
        end
        if s6.last
          r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
          r6.extend(SingleQuoted3)
          r6.extend(SingleQuoted4)
        else
          @index = i6
          r6 = nil
        end
        if r6
          r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
          r0 = r6
        else
          @index = i0
          r0 = nil
        end
      end
    end
  end

  node_cache[:single_quoted][start_index] = r0

  r0
end

#_nt_singular_query ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 2899

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

  i0 = index
  r1 = _nt_rel_singular_query
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r2 = _nt_abs_singular_query
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:singular_query][start_index] = r0

  r0
end

#_nt_singular_query_segments ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 3040

def _nt_singular_query_segments
  start_index = index
  if node_cache[:singular_query_segments].has_key?(index)
    cached = node_cache[:singular_query_segments][index]
    if cached
      node_cache[:singular_query_segments][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_S
    s1 << r2
    if r2
      i3 = index
      r4 = _nt_name_segment
      if r4
        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
        r3 = r4
      else
        r5 = _nt_index_segment
        if r5
          r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
          r3 = r5
        else
          @index = i3
          r3 = nil
        end
      end
      s1 << r3
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(SingularQuerySegments0)
    else
      @index = i1
      r1 = nil
    end
    if r1
      s0 << r1
    else
      break
    end
  end
  r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
  r0.extend(SingularQuerySegments1)
  r0.extend(SingularQuerySegments1)

  node_cache[:singular_query_segments][start_index] = r0

  r0
end

#_nt_slice_selector ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 1817

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

  i0, s0 = index, []
  i2, s2 = index, []
  r3 = _nt_start
  s2 << r3
  if r3
    r4 = _nt_S
    s2 << r4
  end
  if s2.last
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    r2.extend(SliceSelector0)
  else
    @index = i2
    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?(":", false, index))
      r5 = true
      @index += match_len
    else
      terminal_parse_failure('":"')
      r5 = nil
    end
    s0 << r5
    if r5
      r6 = _nt_S
      s0 << r6
      if r6
        i8, s8 = index, []
        r9 = _nt_r__end
        s8 << r9
        if r9
          r10 = _nt_S
          s8 << r10
        end
        if s8.last
          r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
          r8.extend(SliceSelector1)
        else
          @index = i8
          r8 = nil
        end
        if r8
          r7 = r8
        else
          r7 = instantiate_node(SyntaxNode,input, index...index)
        end
        s0 << r7
        if r7
          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
            i15, s15 = index, []
            r16 = _nt_S
            s15 << r16
            if r16
              r17 = _nt_step
              s15 << r17
            end
            if s15.last
              r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
              r15.extend(SliceSelector2)
            else
              @index = i15
              r15 = nil
            end
            if r15
              r14 = r15
            else
              r14 = instantiate_node(SyntaxNode,input, index...index)
            end
            s12 << r14
          end
          if s12.last
            r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
            r12.extend(SliceSelector3)
          else
            @index = i12
            r12 = nil
          end
          if r12
            r11 = r12
          else
            r11 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r11
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(SliceSelector4)
    r0.extend(SliceSelector5)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:slice_selector][start_index] = r0

  r0
end

#_nt_start ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 1945

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

  r0 = _nt_int

  node_cache[:start][start_index] = r0

  r0
end

#_nt_step ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 1981

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

  r0 = _nt_int

  node_cache[:step][start_index] = r0

  r0
end

#_nt_string_literal ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 371

def _nt_string_literal
  start_index = index
  if node_cache[:string_literal].has_key?(index)
    cached = node_cache[:string_literal][index]
    if cached
      node_cache[:string_literal][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?("\"", false, index))
    r2 = true
    @index += match_len
  else
    terminal_parse_failure('"\\""')
    r2 = nil
  end
  s1 << r2
  if r2
    s3, i3 = [], index
    loop do
      r4 = _nt_double_quoted
      if r4
        s3 << r4
      else
        break
      end
    end
    r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
    s1 << r3
    if r3
      if (match_len = has_terminal?("\"", false, index))
        r5 = true
        @index += match_len
      else
        terminal_parse_failure('"\\""')
        r5 = nil
      end
      s1 << r5
    end
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(StringLiteral0)
    r1.extend(StringLiteral1)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  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
      s8, i8 = [], index
      loop do
        r9 = _nt_single_quoted
        if r9
          s8 << r9
        else
          break
        end
      end
      r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
      s6 << r8
      if r8
        if (match_len = has_terminal?("'", false, index))
          r10 = true
          @index += match_len
        else
          terminal_parse_failure('"\'"')
          r10 = nil
        end
        s6 << r10
      end
    end
    if s6.last
      r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
      r6.extend(StringLiteral2)
      r6.extend(StringLiteral3)
    else
      @index = i6
      r6 = nil
    end
    if r6
      r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
      r0 = r6
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:string_literal][start_index] = r0

  r0
end

#_nt_test_expr ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 2475

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

  i0, s0 = index, []
  i2, s2 = index, []
  r3 = _nt_logical_not_op
  s2 << r3
  if r3
    r4 = _nt_S
    s2 << r4
  end
  if s2.last
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    r2.extend(TestExpr0)
  else
    @index = i2
    r2 = nil
  end
  if r2
    r1 = r2
  else
    r1 = instantiate_node(SyntaxNode,input, index...index)
  end
  s0 << r1
  if r1
    i5 = index
    r6 = _nt_filter_query
    if r6
      r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
      r5 = r6
    else
      r7 = _nt_function_expr
      if r7
        r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
        r5 = r7
      else
        @index = i5
        r5 = nil
      end
    end
    s0 << r5
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(TestExpr1)
    r0.extend(TestExpr2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:test_expr][start_index] = r0

  r0
end

#_nt_true ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 3492

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

  if (match_len = has_terminal?("true", false, index))
    r0 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    r0.extend(True0)
    @index += match_len
  else
    terminal_parse_failure('"true"')
    r0 = nil
  end

  node_cache[:true][start_index] = r0

  r0
end

#_nt_unescaped ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 739

def _nt_unescaped
  start_index = index
  if node_cache[:unescaped].has_key?(index)
    cached = node_cache[:unescaped][index]
    if cached
      node_cache[:unescaped][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
    r0.extend(Unescaped0)
    r0.extend(Unescaped0)
  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
      r0.extend(Unescaped0)
      r0.extend(Unescaped0)
    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
        r0.extend(Unescaped0)
        r0.extend(Unescaped0)
      else
        if has_terminal?(@regexps[gr = '\A[\\]-퟿]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[\\]-퟿]')
          r4 = nil
        end
        if r4
          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
          r0 = r4
          r0.extend(Unescaped0)
          r0.extend(Unescaped0)
        else
          if has_terminal?(@regexps[gr = '\A[-􏿿]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[-􏿿]')
            r5 = nil
          end
          if r5
            r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
            r0 = r5
            r0.extend(Unescaped0)
            r0.extend(Unescaped0)
          else
            @index = i0
            r0 = nil
          end
        end
      end
    end
  end

  node_cache[:unescaped][start_index] = r0

  r0
end

#_nt_wildcard_selector ⇒ `Object`

# File 'lib/parser/jptgrammar.rb', line 1612

def _nt_wildcard_selector
  start_index = index
  if node_cache[:wildcard_selector].has_key?(index)
    cached = node_cache[:wildcard_selector][index]
    if cached
      node_cache[:wildcard_selector][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))
    r0.extend(WildcardSelector0)
    @index += match_len
  else
    terminal_parse_failure('"*"')
    r0 = nil
  end

  node_cache[:wildcard_selector][start_index] = r0

  r0
end

#root ⇒ `Object`



8
9
10

# File 'lib/parser/jptgrammar.rb', line 8

def root
  @root ||= :jptgrammar
end

Module: JPTGRAMMAR

Defined Under Namespace

Instance Method Summary collapse

Instance Method Details

#_nt_abs_singular_query ⇒ Object

#_nt_ALPHA ⇒ Object

#_nt_B ⇒ Object

#_nt_basic_expr ⇒ Object

#_nt_bracketed_selection ⇒ Object

#_nt_child_segment ⇒ Object

#_nt_comparable ⇒ Object

#_nt_comparison_expr ⇒ Object

#_nt_comparison_op ⇒ Object

#_nt_current_node_identifier ⇒ Object

#_nt_descendant_segment ⇒ Object

#_nt_DIGIT ⇒ Object

#_nt_DIGIT1 ⇒ Object

#_nt_double_quoted ⇒ Object

#_nt_ESC ⇒ Object

#_nt_escapable ⇒ Object

#_nt_exp ⇒ Object

#_nt_false ⇒ Object

#_nt_filter_query ⇒ Object

#_nt_filter_selector ⇒ Object

#_nt_frac ⇒ Object

#_nt_function_argument ⇒ Object

#_nt_function_expr ⇒ Object

#_nt_function_name ⇒ Object

#_nt_function_name_char ⇒ Object

#_nt_function_name_first ⇒ Object

#_nt_hexchar ⇒ Object

#_nt_HEXDIG ⇒ Object

#_nt_high_surrogate ⇒ Object

#_nt_index_segment ⇒ Object

#_nt_index_selector ⇒ Object

#_nt_int ⇒ Object

#_nt_jptgrammar ⇒ Object

#_nt_jsonpath_query ⇒ Object

#_nt_LCALPHA ⇒ Object

#_nt_literal ⇒ Object

#_nt_logical_and_expr ⇒ Object

#_nt_logical_expr ⇒ Object

#_nt_logical_not_op ⇒ Object

#_nt_logical_or_expr ⇒ Object

#_nt_low_surrogate ⇒ Object

#_nt_member_name_shorthand ⇒ Object

#_nt_name_char ⇒ Object

#_nt_name_first ⇒ Object

#_nt_name_segment ⇒ Object

#_nt_name_selector ⇒ Object

#_nt_non_surrogate ⇒ Object

#_nt_normal_escapable ⇒ Object

#_nt_normal_hexchar ⇒ Object

#_nt_normal_HEXDIG ⇒ Object

#_nt_normal_index_segment ⇒ Object

#_nt_normal_index_selector ⇒ Object

#_nt_normal_name_selector ⇒ Object

#_nt_normal_selector ⇒ Object

#_nt_normal_single_quoted ⇒ Object

#_nt_normal_unescaped ⇒ Object

#_nt_normalized_path ⇒ Object

#_nt_null ⇒ Object

#_nt_number ⇒ Object

#_nt_paren_expr ⇒ Object

#_nt_r__end ⇒ Object

#_nt_rel_query ⇒ Object

#_nt_rel_singular_query ⇒ Object

#_nt_root_identifier ⇒ Object

#_nt_S ⇒ Object

#_nt_segment ⇒ Object

#_nt_segments ⇒ Object

#_nt_selector ⇒ Object

#_nt_single_quoted ⇒ Object

#_nt_singular_query ⇒ Object

#_nt_singular_query_segments ⇒ Object

#_nt_slice_selector ⇒ Object

#_nt_start ⇒ Object

#_nt_step ⇒ Object

#_nt_string_literal ⇒ Object

#_nt_test_expr ⇒ Object

#_nt_abs_singular_query ⇒ `Object`

#_nt_ALPHA ⇒ `Object`

#_nt_B ⇒ `Object`

#_nt_basic_expr ⇒ `Object`

#_nt_bracketed_selection ⇒ `Object`

#_nt_child_segment ⇒ `Object`

#_nt_comparable ⇒ `Object`

#_nt_comparison_expr ⇒ `Object`

#_nt_comparison_op ⇒ `Object`

#_nt_current_node_identifier ⇒ `Object`

#_nt_descendant_segment ⇒ `Object`

#_nt_DIGIT ⇒ `Object`

#_nt_DIGIT1 ⇒ `Object`

#_nt_double_quoted ⇒ `Object`

#_nt_ESC ⇒ `Object`

#_nt_escapable ⇒ `Object`

#_nt_exp ⇒ `Object`

#_nt_false ⇒ `Object`

#_nt_filter_query ⇒ `Object`

#_nt_filter_selector ⇒ `Object`

#_nt_frac ⇒ `Object`

#_nt_function_argument ⇒ `Object`

#_nt_function_expr ⇒ `Object`

#_nt_function_name ⇒ `Object`

#_nt_function_name_char ⇒ `Object`

#_nt_function_name_first ⇒ `Object`

#_nt_hexchar ⇒ `Object`

#_nt_HEXDIG ⇒ `Object`

#_nt_high_surrogate ⇒ `Object`

#_nt_index_segment ⇒ `Object`

#_nt_index_selector ⇒ `Object`

#_nt_int ⇒ `Object`

#_nt_jptgrammar ⇒ `Object`

#_nt_jsonpath_query ⇒ `Object`

#_nt_LCALPHA ⇒ `Object`

#_nt_literal ⇒ `Object`

#_nt_logical_and_expr ⇒ `Object`

#_nt_logical_expr ⇒ `Object`

#_nt_logical_not_op ⇒ `Object`

#_nt_logical_or_expr ⇒ `Object`

#_nt_low_surrogate ⇒ `Object`

#_nt_member_name_shorthand ⇒ `Object`

#_nt_name_char ⇒ `Object`

#_nt_name_first ⇒ `Object`

#_nt_name_segment ⇒ `Object`

#_nt_name_selector ⇒ `Object`

#_nt_non_surrogate ⇒ `Object`

#_nt_normal_escapable ⇒ `Object`

#_nt_normal_hexchar ⇒ `Object`

#_nt_normal_HEXDIG ⇒ `Object`

#_nt_normal_index_segment ⇒ `Object`

#_nt_normal_index_selector ⇒ `Object`

#_nt_normal_name_selector ⇒ `Object`

#_nt_normal_selector ⇒ `Object`

#_nt_normal_single_quoted ⇒ `Object`

#_nt_normal_unescaped ⇒ `Object`

#_nt_normalized_path ⇒ `Object`

#_nt_null ⇒ `Object`

#_nt_number ⇒ `Object`

#_nt_paren_expr ⇒ `Object`

#_nt_r__end ⇒ `Object`

#_nt_rel_query ⇒ `Object`

#_nt_rel_singular_query ⇒ `Object`

#_nt_root_identifier ⇒ `Object`

#_nt_S ⇒ `Object`

#_nt_segment ⇒ `Object`

#_nt_segments ⇒ `Object`

#_nt_selector ⇒ `Object`

#_nt_single_quoted ⇒ `Object`

#_nt_singular_query ⇒ `Object`

#_nt_singular_query_segments ⇒ `Object`

#_nt_slice_selector ⇒ `Object`

#_nt_start ⇒ `Object`

#_nt_step ⇒ `Object`

#_nt_string_literal ⇒ `Object`

#_nt_test_expr ⇒ `Object`

#_nt_true ⇒ `Object`

#_nt_unescaped ⇒ `Object`

#_nt_wildcard_selector ⇒ `Object`

#root ⇒ `Object`