module OracleSqlParser::Grammar::ReservedWord

Public Instance Methods

_nt_access_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 109
def _nt_access_keyword
  start_index = index
  if node_cache[:access_keyword].has_key?(index)
    cached = node_cache[:access_keyword][index]
    if cached
      node_cache[:access_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[aA]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[cC]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[cC]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[sS]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[sS]')
              r6 = nil
            end
            s0 << r6
            if r6
              i7 = index
              if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                r8 = true
                @index += 1
              else
                terminal_parse_failure('[A-Za-z0-9]')
                r8 = nil
              end
              if r8
                @index = i7
                r7 = nil
                terminal_parse_failure('[A-Za-z0-9]', true)
              else
                @terminal_failures.pop
                @index = i7
                r7 = instantiate_node(SyntaxNode,input, index...index)
              end
              s0 << r7
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(AccessKeyword0)
    r0.extend(AccessKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:access_keyword][start_index] = r0

  r0
end
_nt_add_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 222
def _nt_add_keyword
  start_index = index
  if node_cache[:add_keyword].has_key?(index)
    cached = node_cache[:add_keyword][index]
    if cached
      node_cache[:add_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[aA]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[dD]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[dD]')
        r3 = nil
      end
      s0 << r3
      if r3
        i4 = index
        if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
          r5 = true
          @index += 1
        else
          terminal_parse_failure('[A-Za-z0-9]')
          r5 = nil
        end
        if r5
          @index = i4
          r4 = nil
          terminal_parse_failure('[A-Za-z0-9]', true)
        else
          @terminal_failures.pop
          @index = i4
          r4 = instantiate_node(SyntaxNode,input, index...index)
        end
        s0 << r4
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(AddKeyword0)
    r0.extend(AddKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:add_keyword][start_index] = r0

  r0
end
_nt_all_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 305
def _nt_all_keyword
  start_index = index
  if node_cache[:all_keyword].has_key?(index)
    cached = node_cache[:all_keyword][index]
    if cached
      node_cache[:all_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[aA]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[lL]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[lL]')
        r3 = nil
      end
      s0 << r3
      if r3
        i4 = index
        if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
          r5 = true
          @index += 1
        else
          terminal_parse_failure('[A-Za-z0-9]')
          r5 = nil
        end
        if r5
          @index = i4
          r4 = nil
          terminal_parse_failure('[A-Za-z0-9]', true)
        else
          @terminal_failures.pop
          @index = i4
          r4 = instantiate_node(SyntaxNode,input, index...index)
        end
        s0 << r4
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(AllKeyword0)
    r0.extend(AllKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:all_keyword][start_index] = r0

  r0
end
_nt_alter_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 388
def _nt_alter_keyword
  start_index = index
  if node_cache[:alter_keyword].has_key?(index)
    cached = node_cache[:alter_keyword][index]
    if cached
      node_cache[:alter_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[aA]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[lL]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[tT]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[rR]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(AlterKeyword0)
    r0.extend(AlterKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:alter_keyword][start_index] = r0

  r0
end
_nt_and_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 491
def _nt_and_keyword
  start_index = index
  if node_cache[:and_keyword].has_key?(index)
    cached = node_cache[:and_keyword][index]
    if cached
      node_cache[:and_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[aA]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[nN]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[dD]')
        r3 = nil
      end
      s0 << r3
      if r3
        i4 = index
        if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
          r5 = true
          @index += 1
        else
          terminal_parse_failure('[A-Za-z0-9]')
          r5 = nil
        end
        if r5
          @index = i4
          r4 = nil
          terminal_parse_failure('[A-Za-z0-9]', true)
        else
          @terminal_failures.pop
          @index = i4
          r4 = instantiate_node(SyntaxNode,input, index...index)
        end
        s0 << r4
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(AndKeyword0)
    r0.extend(AndKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:and_keyword][start_index] = r0

  r0
end
_nt_any_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 574
def _nt_any_keyword
  start_index = index
  if node_cache[:any_keyword].has_key?(index)
    cached = node_cache[:any_keyword][index]
    if cached
      node_cache[:any_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[aA]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[nN]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[yY]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[yY]')
        r3 = nil
      end
      s0 << r3
      if r3
        i4 = index
        if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
          r5 = true
          @index += 1
        else
          terminal_parse_failure('[A-Za-z0-9]')
          r5 = nil
        end
        if r5
          @index = i4
          r4 = nil
          terminal_parse_failure('[A-Za-z0-9]', true)
        else
          @terminal_failures.pop
          @index = i4
          r4 = instantiate_node(SyntaxNode,input, index...index)
        end
        s0 << r4
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(AnyKeyword0)
    r0.extend(AnyKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:any_keyword][start_index] = r0

  r0
end
_nt_as_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 657
def _nt_as_keyword
  start_index = index
  if node_cache[:as_keyword].has_key?(index)
    cached = node_cache[:as_keyword][index]
    if cached
      node_cache[:as_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[aA]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[sS]')
      r2 = nil
    end
    s0 << r2
    if r2
      i3 = index
      if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
        r4 = true
        @index += 1
      else
        terminal_parse_failure('[A-Za-z0-9]')
        r4 = nil
      end
      if r4
        @index = i3
        r3 = nil
        terminal_parse_failure('[A-Za-z0-9]', true)
      else
        @terminal_failures.pop
        @index = i3
        r3 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r3
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(AsKeyword0)
    r0.extend(AsKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:as_keyword][start_index] = r0

  r0
end
_nt_asc_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 730
def _nt_asc_keyword
  start_index = index
  if node_cache[:asc_keyword].has_key?(index)
    cached = node_cache[:asc_keyword][index]
    if cached
      node_cache[:asc_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[aA]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[sS]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[cC]')
        r3 = nil
      end
      s0 << r3
      if r3
        i4 = index
        if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
          r5 = true
          @index += 1
        else
          terminal_parse_failure('[A-Za-z0-9]')
          r5 = nil
        end
        if r5
          @index = i4
          r4 = nil
          terminal_parse_failure('[A-Za-z0-9]', true)
        else
          @terminal_failures.pop
          @index = i4
          r4 = instantiate_node(SyntaxNode,input, index...index)
        end
        s0 << r4
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(AscKeyword0)
    r0.extend(AscKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:asc_keyword][start_index] = r0

  r0
end
_nt_at_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 813
def _nt_at_keyword
  start_index = index
  if node_cache[:at_keyword].has_key?(index)
    cached = node_cache[:at_keyword][index]
    if cached
      node_cache[:at_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[aA]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[tT]')
      r2 = nil
    end
    s0 << r2
    if r2
      i3 = index
      if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
        r4 = true
        @index += 1
      else
        terminal_parse_failure('[A-Za-z0-9]')
        r4 = nil
      end
      if r4
        @index = i3
        r3 = nil
        terminal_parse_failure('[A-Za-z0-9]', true)
      else
        @terminal_failures.pop
        @index = i3
        r3 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r3
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(AtKeyword0)
    r0.extend(AtKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:at_keyword][start_index] = r0

  r0
end
_nt_audit_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 886
def _nt_audit_keyword
  start_index = index
  if node_cache[:audit_keyword].has_key?(index)
    cached = node_cache[:audit_keyword][index]
    if cached
      node_cache[:audit_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[aA]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[uU]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[dD]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[iI]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[tT]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(AuditKeyword0)
    r0.extend(AuditKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:audit_keyword][start_index] = r0

  r0
end
_nt_between_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 989
def _nt_between_keyword
  start_index = index
  if node_cache[:between_keyword].has_key?(index)
    cached = node_cache[:between_keyword][index]
    if cached
      node_cache[:between_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[bB]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[bB]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[eE]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[tT]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[wW]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[wW]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[eE]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[eE]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[nN]')
                r7 = nil
              end
              s0 << r7
              if r7
                i8 = index
                if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                  r9 = true
                  @index += 1
                else
                  terminal_parse_failure('[A-Za-z0-9]')
                  r9 = nil
                end
                if r9
                  @index = i8
                  r8 = nil
                  terminal_parse_failure('[A-Za-z0-9]', true)
                else
                  @terminal_failures.pop
                  @index = i8
                  r8 = instantiate_node(SyntaxNode,input, index...index)
                end
                s0 << r8
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(BetweenKeyword0)
    r0.extend(BetweenKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:between_keyword][start_index] = r0

  r0
end
_nt_by_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 1112
def _nt_by_keyword
  start_index = index
  if node_cache[:by_keyword].has_key?(index)
    cached = node_cache[:by_keyword][index]
    if cached
      node_cache[:by_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[bB]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[bB]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[yY]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[yY]')
      r2 = nil
    end
    s0 << r2
    if r2
      i3 = index
      if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
        r4 = true
        @index += 1
      else
        terminal_parse_failure('[A-Za-z0-9]')
        r4 = nil
      end
      if r4
        @index = i3
        r3 = nil
        terminal_parse_failure('[A-Za-z0-9]', true)
      else
        @terminal_failures.pop
        @index = i3
        r3 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r3
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ByKeyword0)
    r0.extend(ByKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:by_keyword][start_index] = r0

  r0
end
_nt_case_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 1185
def _nt_case_keyword
  start_index = index
  if node_cache[:case_keyword].has_key?(index)
    cached = node_cache[:case_keyword][index]
    if cached
      node_cache[:case_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[cC]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[aA]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[sS]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(CaseKeyword0)
    r0.extend(CaseKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:case_keyword][start_index] = r0

  r0
end
_nt_cast_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 1278
def _nt_cast_keyword
  start_index = index
  if node_cache[:cast_keyword].has_key?(index)
    cached = node_cache[:cast_keyword][index]
    if cached
      node_cache[:cast_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[cC]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[aA]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[sS]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[tT]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(CastKeyword0)
    r0.extend(CastKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:cast_keyword][start_index] = r0

  r0
end
_nt_char_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 1371
def _nt_char_keyword
  start_index = index
  if node_cache[:char_keyword].has_key?(index)
    cached = node_cache[:char_keyword][index]
    if cached
      node_cache[:char_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[cC]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[hH]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[hH]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[aA]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[rR]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(CharKeyword0)
    r0.extend(CharKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:char_keyword][start_index] = r0

  r0
end
_nt_check_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 1464
def _nt_check_keyword
  start_index = index
  if node_cache[:check_keyword].has_key?(index)
    cached = node_cache[:check_keyword][index]
    if cached
      node_cache[:check_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[cC]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[hH]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[hH]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[eE]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[cC]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[kK]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[kK]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(CheckKeyword0)
    r0.extend(CheckKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:check_keyword][start_index] = r0

  r0
end
_nt_cluster_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 1567
def _nt_cluster_keyword
  start_index = index
  if node_cache[:cluster_keyword].has_key?(index)
    cached = node_cache[:cluster_keyword][index]
    if cached
      node_cache[:cluster_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[cC]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[lL]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[uU]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[sS]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[tT]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[eE]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[rR]')
                r7 = nil
              end
              s0 << r7
              if r7
                i8 = index
                if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                  r9 = true
                  @index += 1
                else
                  terminal_parse_failure('[A-Za-z0-9]')
                  r9 = nil
                end
                if r9
                  @index = i8
                  r8 = nil
                  terminal_parse_failure('[A-Za-z0-9]', true)
                else
                  @terminal_failures.pop
                  @index = i8
                  r8 = instantiate_node(SyntaxNode,input, index...index)
                end
                s0 << r8
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ClusterKeyword0)
    r0.extend(ClusterKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:cluster_keyword][start_index] = r0

  r0
end
_nt_column_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 1690
def _nt_column_keyword
  start_index = index
  if node_cache[:column_keyword].has_key?(index)
    cached = node_cache[:column_keyword][index]
    if cached
      node_cache[:column_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[cC]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[oO]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[lL]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[uU]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[mM]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[nN]')
              r6 = nil
            end
            s0 << r6
            if r6
              i7 = index
              if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                r8 = true
                @index += 1
              else
                terminal_parse_failure('[A-Za-z0-9]')
                r8 = nil
              end
              if r8
                @index = i7
                r7 = nil
                terminal_parse_failure('[A-Za-z0-9]', true)
              else
                @terminal_failures.pop
                @index = i7
                r7 = instantiate_node(SyntaxNode,input, index...index)
              end
              s0 << r7
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ColumnKeyword0)
    r0.extend(ColumnKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:column_keyword][start_index] = r0

  r0
end
_nt_column_value_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 1803
def _nt_column_value_keyword
  start_index = index
  if node_cache[:column_value_keyword].has_key?(index)
    cached = node_cache[:column_value_keyword][index]
    if cached
      node_cache[:column_value_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[cC]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[oO]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[lL]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[uU]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[mM]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[nN]')
              r6 = nil
            end
            s0 << r6
            if r6
              if (match_len = has_terminal?('_', false, index))
                r7 = true
                @index += match_len
              else
                terminal_parse_failure('\'_\'')
                r7 = nil
              end
              s0 << r7
              if r7
                if has_terminal?(@regexps[gr = '\A[vV]'] ||= Regexp.new(gr), :regexp, index)
                  r8 = true
                  @index += 1
                else
                  terminal_parse_failure('[vV]')
                  r8 = nil
                end
                s0 << r8
                if r8
                  if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
                    r9 = true
                    @index += 1
                  else
                    terminal_parse_failure('[aA]')
                    r9 = nil
                  end
                  s0 << r9
                  if r9
                    if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
                      r10 = true
                      @index += 1
                    else
                      terminal_parse_failure('[lL]')
                      r10 = nil
                    end
                    s0 << r10
                    if r10
                      if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
                        r11 = true
                        @index += 1
                      else
                        terminal_parse_failure('[uU]')
                        r11 = nil
                      end
                      s0 << r11
                      if r11
                        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
                          r12 = true
                          @index += 1
                        else
                          terminal_parse_failure('[eE]')
                          r12 = nil
                        end
                        s0 << r12
                        if r12
                          i13 = index
                          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                            r14 = true
                            @index += 1
                          else
                            terminal_parse_failure('[A-Za-z0-9]')
                            r14 = nil
                          end
                          if r14
                            @index = i13
                            r13 = nil
                            terminal_parse_failure('[A-Za-z0-9]', true)
                          else
                            @terminal_failures.pop
                            @index = i13
                            r13 = instantiate_node(SyntaxNode,input, index...index)
                          end
                          s0 << r13
                        end
                      end
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ColumnValueKeyword0)
    r0.extend(ColumnValueKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:column_value_keyword][start_index] = r0

  r0
end
_nt_comment_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 1976
def _nt_comment_keyword
  start_index = index
  if node_cache[:comment_keyword].has_key?(index)
    cached = node_cache[:comment_keyword][index]
    if cached
      node_cache[:comment_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[cC]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[oO]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[mM]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[mM]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[eE]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[nN]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[tT]')
                r7 = nil
              end
              s0 << r7
              if r7
                i8 = index
                if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                  r9 = true
                  @index += 1
                else
                  terminal_parse_failure('[A-Za-z0-9]')
                  r9 = nil
                end
                if r9
                  @index = i8
                  r8 = nil
                  terminal_parse_failure('[A-Za-z0-9]', true)
                else
                  @terminal_failures.pop
                  @index = i8
                  r8 = instantiate_node(SyntaxNode,input, index...index)
                end
                s0 << r8
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(CommentKeyword0)
    r0.extend(CommentKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:comment_keyword][start_index] = r0

  r0
end
_nt_compress_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 2099
def _nt_compress_keyword
  start_index = index
  if node_cache[:compress_keyword].has_key?(index)
    cached = node_cache[:compress_keyword][index]
    if cached
      node_cache[:compress_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[cC]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[oO]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[mM]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[pP]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[pP]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[rR]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[eE]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[sS]')
                r7 = nil
              end
              s0 << r7
              if r7
                if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
                  r8 = true
                  @index += 1
                else
                  terminal_parse_failure('[sS]')
                  r8 = nil
                end
                s0 << r8
                if r8
                  i9 = index
                  if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                    r10 = true
                    @index += 1
                  else
                    terminal_parse_failure('[A-Za-z0-9]')
                    r10 = nil
                  end
                  if r10
                    @index = i9
                    r9 = nil
                    terminal_parse_failure('[A-Za-z0-9]', true)
                  else
                    @terminal_failures.pop
                    @index = i9
                    r9 = instantiate_node(SyntaxNode,input, index...index)
                  end
                  s0 << r9
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(CompressKeyword0)
    r0.extend(CompressKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:compress_keyword][start_index] = r0

  r0
end
_nt_connect_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 2232
def _nt_connect_keyword
  start_index = index
  if node_cache[:connect_keyword].has_key?(index)
    cached = node_cache[:connect_keyword][index]
    if cached
      node_cache[:connect_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[cC]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[oO]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[nN]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[nN]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[eE]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[cC]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[tT]')
                r7 = nil
              end
              s0 << r7
              if r7
                i8 = index
                if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                  r9 = true
                  @index += 1
                else
                  terminal_parse_failure('[A-Za-z0-9]')
                  r9 = nil
                end
                if r9
                  @index = i8
                  r8 = nil
                  terminal_parse_failure('[A-Za-z0-9]', true)
                else
                  @terminal_failures.pop
                  @index = i8
                  r8 = instantiate_node(SyntaxNode,input, index...index)
                end
                s0 << r8
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ConnectKeyword0)
    r0.extend(ConnectKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:connect_keyword][start_index] = r0

  r0
end
_nt_create_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 2355
def _nt_create_keyword
  start_index = index
  if node_cache[:create_keyword].has_key?(index)
    cached = node_cache[:create_keyword][index]
    if cached
      node_cache[:create_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[cC]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[rR]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[eE]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[aA]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[tT]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[eE]')
              r6 = nil
            end
            s0 << r6
            if r6
              i7 = index
              if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                r8 = true
                @index += 1
              else
                terminal_parse_failure('[A-Za-z0-9]')
                r8 = nil
              end
              if r8
                @index = i7
                r7 = nil
                terminal_parse_failure('[A-Za-z0-9]', true)
              else
                @terminal_failures.pop
                @index = i7
                r7 = instantiate_node(SyntaxNode,input, index...index)
              end
              s0 << r7
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(CreateKeyword0)
    r0.extend(CreateKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:create_keyword][start_index] = r0

  r0
end
_nt_cross_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 2468
def _nt_cross_keyword
  start_index = index
  if node_cache[:cross_keyword].has_key?(index)
    cached = node_cache[:cross_keyword][index]
    if cached
      node_cache[:cross_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[cC]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[rR]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[oO]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[sS]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[sS]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(CrossKeyword0)
    r0.extend(CrossKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:cross_keyword][start_index] = r0

  r0
end
_nt_cube_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 2571
def _nt_cube_keyword
  start_index = index
  if node_cache[:cube_keyword].has_key?(index)
    cached = node_cache[:cube_keyword][index]
    if cached
      node_cache[:cube_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[cC]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[uU]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[bB]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[bB]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(CubeKeyword0)
    r0.extend(CubeKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:cube_keyword][start_index] = r0

  r0
end
_nt_current_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 2664
def _nt_current_keyword
  start_index = index
  if node_cache[:current_keyword].has_key?(index)
    cached = node_cache[:current_keyword][index]
    if cached
      node_cache[:current_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[cC]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[uU]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[rR]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[rR]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[eE]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[nN]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[tT]')
                r7 = nil
              end
              s0 << r7
              if r7
                i8 = index
                if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                  r9 = true
                  @index += 1
                else
                  terminal_parse_failure('[A-Za-z0-9]')
                  r9 = nil
                end
                if r9
                  @index = i8
                  r8 = nil
                  terminal_parse_failure('[A-Za-z0-9]', true)
                else
                  @terminal_failures.pop
                  @index = i8
                  r8 = instantiate_node(SyntaxNode,input, index...index)
                end
                s0 << r8
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(CurrentKeyword0)
    r0.extend(CurrentKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:current_keyword][start_index] = r0

  r0
end
_nt_current_of_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 2787
def _nt_current_of_keyword
  start_index = index
  if node_cache[:current_of_keyword].has_key?(index)
    cached = node_cache[:current_of_keyword][index]
    if cached
      node_cache[:current_of_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[cC]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[uU]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[rR]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[rR]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[eE]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[nN]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[tT]')
                r7 = nil
              end
              s0 << r7
              if r7
                if (match_len = has_terminal?('_', false, index))
                  r8 = true
                  @index += match_len
                else
                  terminal_parse_failure('\'_\'')
                  r8 = nil
                end
                s0 << r8
                if r8
                  if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
                    r9 = true
                    @index += 1
                  else
                    terminal_parse_failure('[oO]')
                    r9 = nil
                  end
                  s0 << r9
                  if r9
                    if has_terminal?(@regexps[gr = '\A[fF]'] ||= Regexp.new(gr), :regexp, index)
                      r10 = true
                      @index += 1
                    else
                      terminal_parse_failure('[fF]')
                      r10 = nil
                    end
                    s0 << r10
                    if r10
                      i11 = index
                      if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                        r12 = true
                        @index += 1
                      else
                        terminal_parse_failure('[A-Za-z0-9]')
                        r12 = nil
                      end
                      if r12
                        @index = i11
                        r11 = nil
                        terminal_parse_failure('[A-Za-z0-9]', true)
                      else
                        @terminal_failures.pop
                        @index = i11
                        r11 = instantiate_node(SyntaxNode,input, index...index)
                      end
                      s0 << r11
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(CurrentOfKeyword0)
    r0.extend(CurrentOfKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:current_of_keyword][start_index] = r0

  r0
end
_nt_currval_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 2940
def _nt_currval_keyword
  start_index = index
  if node_cache[:currval_keyword].has_key?(index)
    cached = node_cache[:currval_keyword][index]
    if cached
      node_cache[:currval_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[cC]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[uU]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[rR]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[rR]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[vV]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[vV]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[aA]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[lL]')
                r7 = nil
              end
              s0 << r7
              if r7
                i8 = index
                if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                  r9 = true
                  @index += 1
                else
                  terminal_parse_failure('[A-Za-z0-9]')
                  r9 = nil
                end
                if r9
                  @index = i8
                  r8 = nil
                  terminal_parse_failure('[A-Za-z0-9]', true)
                else
                  @terminal_failures.pop
                  @index = i8
                  r8 = instantiate_node(SyntaxNode,input, index...index)
                end
                s0 << r8
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(CurrvalKeyword0)
    r0.extend(CurrvalKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:currval_keyword][start_index] = r0

  r0
end
_nt_cursor_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 3063
def _nt_cursor_keyword
  start_index = index
  if node_cache[:cursor_keyword].has_key?(index)
    cached = node_cache[:cursor_keyword][index]
    if cached
      node_cache[:cursor_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[cC]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[uU]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[rR]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[sS]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[oO]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[rR]')
              r6 = nil
            end
            s0 << r6
            if r6
              i7 = index
              if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                r8 = true
                @index += 1
              else
                terminal_parse_failure('[A-Za-z0-9]')
                r8 = nil
              end
              if r8
                @index = i7
                r7 = nil
                terminal_parse_failure('[A-Za-z0-9]', true)
              else
                @terminal_failures.pop
                @index = i7
                r7 = instantiate_node(SyntaxNode,input, index...index)
              end
              s0 << r7
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(CursorKeyword0)
    r0.extend(CursorKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:cursor_keyword][start_index] = r0

  r0
end
_nt_date_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 3176
def _nt_date_keyword
  start_index = index
  if node_cache[:date_keyword].has_key?(index)
    cached = node_cache[:date_keyword][index]
    if cached
      node_cache[:date_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[dD]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[aA]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[tT]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(DateKeyword0)
    r0.extend(DateKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:date_keyword][start_index] = r0

  r0
end
_nt_day_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 3269
def _nt_day_keyword
  start_index = index
  if node_cache[:day_keyword].has_key?(index)
    cached = node_cache[:day_keyword][index]
    if cached
      node_cache[:day_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[dD]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[aA]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[yY]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[yY]')
        r3 = nil
      end
      s0 << r3
      if r3
        i4 = index
        if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
          r5 = true
          @index += 1
        else
          terminal_parse_failure('[A-Za-z0-9]')
          r5 = nil
        end
        if r5
          @index = i4
          r4 = nil
          terminal_parse_failure('[A-Za-z0-9]', true)
        else
          @terminal_failures.pop
          @index = i4
          r4 = instantiate_node(SyntaxNode,input, index...index)
        end
        s0 << r4
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(DayKeyword0)
    r0.extend(DayKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:day_keyword][start_index] = r0

  r0
end
_nt_dbtimezone_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 3352
def _nt_dbtimezone_keyword
  start_index = index
  if node_cache[:dbtimezone_keyword].has_key?(index)
    cached = node_cache[:dbtimezone_keyword][index]
    if cached
      node_cache[:dbtimezone_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[dD]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[bB]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[bB]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[tT]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[iI]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[mM]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[eE]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[zZ]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[zZ]')
                r7 = nil
              end
              s0 << r7
              if r7
                if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
                  r8 = true
                  @index += 1
                else
                  terminal_parse_failure('[oO]')
                  r8 = nil
                end
                s0 << r8
                if r8
                  if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
                    r9 = true
                    @index += 1
                  else
                    terminal_parse_failure('[nN]')
                    r9 = nil
                  end
                  s0 << r9
                  if r9
                    if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
                      r10 = true
                      @index += 1
                    else
                      terminal_parse_failure('[eE]')
                      r10 = nil
                    end
                    s0 << r10
                    if r10
                      i11 = index
                      if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                        r12 = true
                        @index += 1
                      else
                        terminal_parse_failure('[A-Za-z0-9]')
                        r12 = nil
                      end
                      if r12
                        @index = i11
                        r11 = nil
                        terminal_parse_failure('[A-Za-z0-9]', true)
                      else
                        @terminal_failures.pop
                        @index = i11
                        r11 = instantiate_node(SyntaxNode,input, index...index)
                      end
                      s0 << r11
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(DbtimezoneKeyword0)
    r0.extend(DbtimezoneKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:dbtimezone_keyword][start_index] = r0

  r0
end
_nt_decimal_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 3505
def _nt_decimal_keyword
  start_index = index
  if node_cache[:decimal_keyword].has_key?(index)
    cached = node_cache[:decimal_keyword][index]
    if cached
      node_cache[:decimal_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[dD]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[eE]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[cC]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[iI]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[mM]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[aA]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[lL]')
                r7 = nil
              end
              s0 << r7
              if r7
                i8 = index
                if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                  r9 = true
                  @index += 1
                else
                  terminal_parse_failure('[A-Za-z0-9]')
                  r9 = nil
                end
                if r9
                  @index = i8
                  r8 = nil
                  terminal_parse_failure('[A-Za-z0-9]', true)
                else
                  @terminal_failures.pop
                  @index = i8
                  r8 = instantiate_node(SyntaxNode,input, index...index)
                end
                s0 << r8
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(DecimalKeyword0)
    r0.extend(DecimalKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:decimal_keyword][start_index] = r0

  r0
end
_nt_default_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 3628
def _nt_default_keyword
  start_index = index
  if node_cache[:default_keyword].has_key?(index)
    cached = node_cache[:default_keyword][index]
    if cached
      node_cache[:default_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[dD]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[eE]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[fF]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[fF]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[aA]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[uU]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[lL]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[tT]')
                r7 = nil
              end
              s0 << r7
              if r7
                i8 = index
                if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                  r9 = true
                  @index += 1
                else
                  terminal_parse_failure('[A-Za-z0-9]')
                  r9 = nil
                end
                if r9
                  @index = i8
                  r8 = nil
                  terminal_parse_failure('[A-Za-z0-9]', true)
                else
                  @terminal_failures.pop
                  @index = i8
                  r8 = instantiate_node(SyntaxNode,input, index...index)
                end
                s0 << r8
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(DefaultKeyword0)
    r0.extend(DefaultKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:default_keyword][start_index] = r0

  r0
end
_nt_delete_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 3751
def _nt_delete_keyword
  start_index = index
  if node_cache[:delete_keyword].has_key?(index)
    cached = node_cache[:delete_keyword][index]
    if cached
      node_cache[:delete_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[dD]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[eE]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[lL]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[tT]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[eE]')
              r6 = nil
            end
            s0 << r6
            if r6
              i7 = index
              if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                r8 = true
                @index += 1
              else
                terminal_parse_failure('[A-Za-z0-9]')
                r8 = nil
              end
              if r8
                @index = i7
                r7 = nil
                terminal_parse_failure('[A-Za-z0-9]', true)
              else
                @terminal_failures.pop
                @index = i7
                r7 = instantiate_node(SyntaxNode,input, index...index)
              end
              s0 << r7
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(DeleteKeyword0)
    r0.extend(DeleteKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:delete_keyword][start_index] = r0

  r0
end
_nt_desc_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 3864
def _nt_desc_keyword
  start_index = index
  if node_cache[:desc_keyword].has_key?(index)
    cached = node_cache[:desc_keyword][index]
    if cached
      node_cache[:desc_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[dD]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[eE]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[sS]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[cC]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(DescKeyword0)
    r0.extend(DescKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:desc_keyword][start_index] = r0

  r0
end
_nt_distinct_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 3957
def _nt_distinct_keyword
  start_index = index
  if node_cache[:distinct_keyword].has_key?(index)
    cached = node_cache[:distinct_keyword][index]
    if cached
      node_cache[:distinct_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[dD]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[iI]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[sS]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[tT]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[iI]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[nN]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[cC]')
                r7 = nil
              end
              s0 << r7
              if r7
                if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
                  r8 = true
                  @index += 1
                else
                  terminal_parse_failure('[tT]')
                  r8 = nil
                end
                s0 << r8
                if r8
                  i9 = index
                  if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                    r10 = true
                    @index += 1
                  else
                    terminal_parse_failure('[A-Za-z0-9]')
                    r10 = nil
                  end
                  if r10
                    @index = i9
                    r9 = nil
                    terminal_parse_failure('[A-Za-z0-9]', true)
                  else
                    @terminal_failures.pop
                    @index = i9
                    r9 = instantiate_node(SyntaxNode,input, index...index)
                  end
                  s0 << r9
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(DistinctKeyword0)
    r0.extend(DistinctKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:distinct_keyword][start_index] = r0

  r0
end
_nt_drop_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 4090
def _nt_drop_keyword
  start_index = index
  if node_cache[:drop_keyword].has_key?(index)
    cached = node_cache[:drop_keyword][index]
    if cached
      node_cache[:drop_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[dD]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[rR]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[oO]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[pP]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[pP]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(DropKeyword0)
    r0.extend(DropKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:drop_keyword][start_index] = r0

  r0
end
_nt_else_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 4183
def _nt_else_keyword
  start_index = index
  if node_cache[:else_keyword].has_key?(index)
    cached = node_cache[:else_keyword][index]
    if cached
      node_cache[:else_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[eE]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[lL]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[sS]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ElseKeyword0)
    r0.extend(ElseKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:else_keyword][start_index] = r0

  r0
end
_nt_empty_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 4276
def _nt_empty_keyword
  start_index = index
  if node_cache[:empty_keyword].has_key?(index)
    cached = node_cache[:empty_keyword][index]
    if cached
      node_cache[:empty_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[eE]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[mM]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[pP]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[pP]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[tT]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[yY]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[yY]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(EmptyKeyword0)
    r0.extend(EmptyKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:empty_keyword][start_index] = r0

  r0
end
_nt_end_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 4379
def _nt_end_keyword
  start_index = index
  if node_cache[:end_keyword].has_key?(index)
    cached = node_cache[:end_keyword][index]
    if cached
      node_cache[:end_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[eE]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[nN]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[dD]')
        r3 = nil
      end
      s0 << r3
      if r3
        i4 = index
        if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
          r5 = true
          @index += 1
        else
          terminal_parse_failure('[A-Za-z0-9]')
          r5 = nil
        end
        if r5
          @index = i4
          r4 = nil
          terminal_parse_failure('[A-Za-z0-9]', true)
        else
          @terminal_failures.pop
          @index = i4
          r4 = instantiate_node(SyntaxNode,input, index...index)
        end
        s0 << r4
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(EndKeyword0)
    r0.extend(EndKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:end_keyword][start_index] = r0

  r0
end
_nt_escape_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 4462
def _nt_escape_keyword
  start_index = index
  if node_cache[:escape_keyword].has_key?(index)
    cached = node_cache[:escape_keyword][index]
    if cached
      node_cache[:escape_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[eE]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[sS]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[cC]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[aA]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[pP]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[pP]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[eE]')
              r6 = nil
            end
            s0 << r6
            if r6
              i7 = index
              if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                r8 = true
                @index += 1
              else
                terminal_parse_failure('[A-Za-z0-9]')
                r8 = nil
              end
              if r8
                @index = i7
                r7 = nil
                terminal_parse_failure('[A-Za-z0-9]', true)
              else
                @terminal_failures.pop
                @index = i7
                r7 = instantiate_node(SyntaxNode,input, index...index)
              end
              s0 << r7
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(EscapeKeyword0)
    r0.extend(EscapeKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:escape_keyword][start_index] = r0

  r0
end
_nt_exclusive_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 4575
def _nt_exclusive_keyword
  start_index = index
  if node_cache[:exclusive_keyword].has_key?(index)
    cached = node_cache[:exclusive_keyword][index]
    if cached
      node_cache[:exclusive_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[eE]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[xX]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[xX]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[cC]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[lL]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[uU]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[sS]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[iI]')
                r7 = nil
              end
              s0 << r7
              if r7
                if has_terminal?(@regexps[gr = '\A[vV]'] ||= Regexp.new(gr), :regexp, index)
                  r8 = true
                  @index += 1
                else
                  terminal_parse_failure('[vV]')
                  r8 = nil
                end
                s0 << r8
                if r8
                  if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
                    r9 = true
                    @index += 1
                  else
                    terminal_parse_failure('[eE]')
                    r9 = nil
                  end
                  s0 << r9
                  if r9
                    i10 = index
                    if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                      r11 = true
                      @index += 1
                    else
                      terminal_parse_failure('[A-Za-z0-9]')
                      r11 = nil
                    end
                    if r11
                      @index = i10
                      r10 = nil
                      terminal_parse_failure('[A-Za-z0-9]', true)
                    else
                      @terminal_failures.pop
                      @index = i10
                      r10 = instantiate_node(SyntaxNode,input, index...index)
                    end
                    s0 << r10
                  end
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ExclusiveKeyword0)
    r0.extend(ExclusiveKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:exclusive_keyword][start_index] = r0

  r0
end
_nt_exists_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 4718
def _nt_exists_keyword
  start_index = index
  if node_cache[:exists_keyword].has_key?(index)
    cached = node_cache[:exists_keyword][index]
    if cached
      node_cache[:exists_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[eE]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[xX]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[xX]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[iI]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[sS]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[tT]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[sS]')
              r6 = nil
            end
            s0 << r6
            if r6
              i7 = index
              if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                r8 = true
                @index += 1
              else
                terminal_parse_failure('[A-Za-z0-9]')
                r8 = nil
              end
              if r8
                @index = i7
                r7 = nil
                terminal_parse_failure('[A-Za-z0-9]', true)
              else
                @terminal_failures.pop
                @index = i7
                r7 = instantiate_node(SyntaxNode,input, index...index)
              end
              s0 << r7
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ExistsKeyword0)
    r0.extend(ExistsKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:exists_keyword][start_index] = r0

  r0
end
_nt_fetch_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 4831
def _nt_fetch_keyword
  start_index = index
  if node_cache[:fetch_keyword].has_key?(index)
    cached = node_cache[:fetch_keyword][index]
    if cached
      node_cache[:fetch_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[fF]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[fF]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[eE]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[tT]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[cC]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[hH]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[hH]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(FetchKeyword0)
    r0.extend(FetchKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:fetch_keyword][start_index] = r0

  r0
end
_nt_file_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 4934
def _nt_file_keyword
  start_index = index
  if node_cache[:file_keyword].has_key?(index)
    cached = node_cache[:file_keyword][index]
    if cached
      node_cache[:file_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[fF]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[fF]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[iI]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[lL]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(FileKeyword0)
    r0.extend(FileKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:file_keyword][start_index] = r0

  r0
end
_nt_first_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 5027
def _nt_first_keyword
  start_index = index
  if node_cache[:first_keyword].has_key?(index)
    cached = node_cache[:first_keyword][index]
    if cached
      node_cache[:first_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[fF]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[fF]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[iI]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[rR]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[sS]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[tT]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(FirstKeyword0)
    r0.extend(FirstKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:first_keyword][start_index] = r0

  r0
end
_nt_float_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 5130
def _nt_float_keyword
  start_index = index
  if node_cache[:float_keyword].has_key?(index)
    cached = node_cache[:float_keyword][index]
    if cached
      node_cache[:float_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[fF]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[fF]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[lL]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[oO]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[aA]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[tT]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(FloatKeyword0)
    r0.extend(FloatKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:float_keyword][start_index] = r0

  r0
end
_nt_for_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 5233
def _nt_for_keyword
  start_index = index
  if node_cache[:for_keyword].has_key?(index)
    cached = node_cache[:for_keyword][index]
    if cached
      node_cache[:for_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[fF]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[fF]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[oO]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[rR]')
        r3 = nil
      end
      s0 << r3
      if r3
        i4 = index
        if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
          r5 = true
          @index += 1
        else
          terminal_parse_failure('[A-Za-z0-9]')
          r5 = nil
        end
        if r5
          @index = i4
          r4 = nil
          terminal_parse_failure('[A-Za-z0-9]', true)
        else
          @terminal_failures.pop
          @index = i4
          r4 = instantiate_node(SyntaxNode,input, index...index)
        end
        s0 << r4
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ForKeyword0)
    r0.extend(ForKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:for_keyword][start_index] = r0

  r0
end
_nt_from_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 5316
def _nt_from_keyword
  start_index = index
  if node_cache[:from_keyword].has_key?(index)
    cached = node_cache[:from_keyword][index]
    if cached
      node_cache[:from_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[fF]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[fF]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[rR]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[oO]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[mM]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(FromKeyword0)
    r0.extend(FromKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:from_keyword][start_index] = r0

  r0
end
_nt_full_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 5409
def _nt_full_keyword
  start_index = index
  if node_cache[:full_keyword].has_key?(index)
    cached = node_cache[:full_keyword][index]
    if cached
      node_cache[:full_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[fF]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[fF]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[uU]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[lL]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[lL]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(FullKeyword0)
    r0.extend(FullKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:full_keyword][start_index] = r0

  r0
end
_nt_grant_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 5502
def _nt_grant_keyword
  start_index = index
  if node_cache[:grant_keyword].has_key?(index)
    cached = node_cache[:grant_keyword][index]
    if cached
      node_cache[:grant_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[gG]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[gG]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[rR]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[aA]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[nN]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[tT]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(GrantKeyword0)
    r0.extend(GrantKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:grant_keyword][start_index] = r0

  r0
end
_nt_group_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 5605
def _nt_group_keyword
  start_index = index
  if node_cache[:group_keyword].has_key?(index)
    cached = node_cache[:group_keyword][index]
    if cached
      node_cache[:group_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[gG]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[gG]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[rR]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[oO]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[uU]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[pP]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[pP]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(GroupKeyword0)
    r0.extend(GroupKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:group_keyword][start_index] = r0

  r0
end
_nt_having_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 5708
def _nt_having_keyword
  start_index = index
  if node_cache[:having_keyword].has_key?(index)
    cached = node_cache[:having_keyword][index]
    if cached
      node_cache[:having_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[hH]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[hH]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[aA]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[vV]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[vV]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[iI]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[nN]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[gG]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[gG]')
              r6 = nil
            end
            s0 << r6
            if r6
              i7 = index
              if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                r8 = true
                @index += 1
              else
                terminal_parse_failure('[A-Za-z0-9]')
                r8 = nil
              end
              if r8
                @index = i7
                r7 = nil
                terminal_parse_failure('[A-Za-z0-9]', true)
              else
                @terminal_failures.pop
                @index = i7
                r7 = instantiate_node(SyntaxNode,input, index...index)
              end
              s0 << r7
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(HavingKeyword0)
    r0.extend(HavingKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:having_keyword][start_index] = r0

  r0
end
_nt_identified_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 5821
def _nt_identified_keyword
  start_index = index
  if node_cache[:identified_keyword].has_key?(index)
    cached = node_cache[:identified_keyword][index]
    if cached
      node_cache[:identified_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[iI]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[dD]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[eE]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[nN]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[tT]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[iI]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[fF]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[fF]')
                r7 = nil
              end
              s0 << r7
              if r7
                if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
                  r8 = true
                  @index += 1
                else
                  terminal_parse_failure('[iI]')
                  r8 = nil
                end
                s0 << r8
                if r8
                  if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
                    r9 = true
                    @index += 1
                  else
                    terminal_parse_failure('[eE]')
                    r9 = nil
                  end
                  s0 << r9
                  if r9
                    if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
                      r10 = true
                      @index += 1
                    else
                      terminal_parse_failure('[dD]')
                      r10 = nil
                    end
                    s0 << r10
                    if r10
                      i11 = index
                      if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                        r12 = true
                        @index += 1
                      else
                        terminal_parse_failure('[A-Za-z0-9]')
                        r12 = nil
                      end
                      if r12
                        @index = i11
                        r11 = nil
                        terminal_parse_failure('[A-Za-z0-9]', true)
                      else
                        @terminal_failures.pop
                        @index = i11
                        r11 = instantiate_node(SyntaxNode,input, index...index)
                      end
                      s0 << r11
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(IdentifiedKeyword0)
    r0.extend(IdentifiedKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:identified_keyword][start_index] = r0

  r0
end
_nt_immediate_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 5974
def _nt_immediate_keyword
  start_index = index
  if node_cache[:immediate_keyword].has_key?(index)
    cached = node_cache[:immediate_keyword][index]
    if cached
      node_cache[:immediate_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[iI]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[mM]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[mM]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[dD]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[iI]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[aA]')
                r7 = nil
              end
              s0 << r7
              if r7
                if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
                  r8 = true
                  @index += 1
                else
                  terminal_parse_failure('[tT]')
                  r8 = nil
                end
                s0 << r8
                if r8
                  if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
                    r9 = true
                    @index += 1
                  else
                    terminal_parse_failure('[eE]')
                    r9 = nil
                  end
                  s0 << r9
                  if r9
                    i10 = index
                    if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                      r11 = true
                      @index += 1
                    else
                      terminal_parse_failure('[A-Za-z0-9]')
                      r11 = nil
                    end
                    if r11
                      @index = i10
                      r10 = nil
                      terminal_parse_failure('[A-Za-z0-9]', true)
                    else
                      @terminal_failures.pop
                      @index = i10
                      r10 = instantiate_node(SyntaxNode,input, index...index)
                    end
                    s0 << r10
                  end
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ImmediateKeyword0)
    r0.extend(ImmediateKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:immediate_keyword][start_index] = r0

  r0
end
_nt_in_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 6117
def _nt_in_keyword
  start_index = index
  if node_cache[:in_keyword].has_key?(index)
    cached = node_cache[:in_keyword][index]
    if cached
      node_cache[:in_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[iI]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[nN]')
      r2 = nil
    end
    s0 << r2
    if r2
      i3 = index
      if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
        r4 = true
        @index += 1
      else
        terminal_parse_failure('[A-Za-z0-9]')
        r4 = nil
      end
      if r4
        @index = i3
        r3 = nil
        terminal_parse_failure('[A-Za-z0-9]', true)
      else
        @terminal_failures.pop
        @index = i3
        r3 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r3
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(InKeyword0)
    r0.extend(InKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:in_keyword][start_index] = r0

  r0
end
_nt_increment_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 6190
def _nt_increment_keyword
  start_index = index
  if node_cache[:increment_keyword].has_key?(index)
    cached = node_cache[:increment_keyword][index]
    if cached
      node_cache[:increment_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[iI]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[nN]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[cC]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[rR]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[eE]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[mM]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[eE]')
                r7 = nil
              end
              s0 << r7
              if r7
                if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
                  r8 = true
                  @index += 1
                else
                  terminal_parse_failure('[nN]')
                  r8 = nil
                end
                s0 << r8
                if r8
                  if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
                    r9 = true
                    @index += 1
                  else
                    terminal_parse_failure('[tT]')
                    r9 = nil
                  end
                  s0 << r9
                  if r9
                    i10 = index
                    if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                      r11 = true
                      @index += 1
                    else
                      terminal_parse_failure('[A-Za-z0-9]')
                      r11 = nil
                    end
                    if r11
                      @index = i10
                      r10 = nil
                      terminal_parse_failure('[A-Za-z0-9]', true)
                    else
                      @terminal_failures.pop
                      @index = i10
                      r10 = instantiate_node(SyntaxNode,input, index...index)
                    end
                    s0 << r10
                  end
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(IncrementKeyword0)
    r0.extend(IncrementKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:increment_keyword][start_index] = r0

  r0
end
_nt_index_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 6333
def _nt_index_keyword
  start_index = index
  if node_cache[:index_keyword].has_key?(index)
    cached = node_cache[:index_keyword][index]
    if cached
      node_cache[:index_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[iI]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[nN]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[dD]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[xX]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[xX]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(IndexKeyword0)
    r0.extend(IndexKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:index_keyword][start_index] = r0

  r0
end
_nt_infinite_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 6436
def _nt_infinite_keyword
  start_index = index
  if node_cache[:infinite_keyword].has_key?(index)
    cached = node_cache[:infinite_keyword][index]
    if cached
      node_cache[:infinite_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[iI]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[nN]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[fF]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[fF]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[iI]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[nN]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[iI]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[tT]')
                r7 = nil
              end
              s0 << r7
              if r7
                if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
                  r8 = true
                  @index += 1
                else
                  terminal_parse_failure('[eE]')
                  r8 = nil
                end
                s0 << r8
                if r8
                  i9 = index
                  if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                    r10 = true
                    @index += 1
                  else
                    terminal_parse_failure('[A-Za-z0-9]')
                    r10 = nil
                  end
                  if r10
                    @index = i9
                    r9 = nil
                    terminal_parse_failure('[A-Za-z0-9]', true)
                  else
                    @terminal_failures.pop
                    @index = i9
                    r9 = instantiate_node(SyntaxNode,input, index...index)
                  end
                  s0 << r9
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(InfiniteKeyword0)
    r0.extend(InfiniteKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:infinite_keyword][start_index] = r0

  r0
end
_nt_initial_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 6569
def _nt_initial_keyword
  start_index = index
  if node_cache[:initial_keyword].has_key?(index)
    cached = node_cache[:initial_keyword][index]
    if cached
      node_cache[:initial_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[iI]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[nN]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[iI]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[tT]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[iI]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[aA]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[lL]')
                r7 = nil
              end
              s0 << r7
              if r7
                i8 = index
                if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                  r9 = true
                  @index += 1
                else
                  terminal_parse_failure('[A-Za-z0-9]')
                  r9 = nil
                end
                if r9
                  @index = i8
                  r8 = nil
                  terminal_parse_failure('[A-Za-z0-9]', true)
                else
                  @terminal_failures.pop
                  @index = i8
                  r8 = instantiate_node(SyntaxNode,input, index...index)
                end
                s0 << r8
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(InitialKeyword0)
    r0.extend(InitialKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:initial_keyword][start_index] = r0

  r0
end
_nt_inner_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 6692
def _nt_inner_keyword
  start_index = index
  if node_cache[:inner_keyword].has_key?(index)
    cached = node_cache[:inner_keyword][index]
    if cached
      node_cache[:inner_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[iI]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[nN]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[nN]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[rR]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(InnerKeyword0)
    r0.extend(InnerKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:inner_keyword][start_index] = r0

  r0
end
_nt_insert_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 6795
def _nt_insert_keyword
  start_index = index
  if node_cache[:insert_keyword].has_key?(index)
    cached = node_cache[:insert_keyword][index]
    if cached
      node_cache[:insert_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[iI]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[nN]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[sS]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[rR]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[tT]')
              r6 = nil
            end
            s0 << r6
            if r6
              i7 = index
              if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                r8 = true
                @index += 1
              else
                terminal_parse_failure('[A-Za-z0-9]')
                r8 = nil
              end
              if r8
                @index = i7
                r7 = nil
                terminal_parse_failure('[A-Za-z0-9]', true)
              else
                @terminal_failures.pop
                @index = i7
                r7 = instantiate_node(SyntaxNode,input, index...index)
              end
              s0 << r7
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(InsertKeyword0)
    r0.extend(InsertKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:insert_keyword][start_index] = r0

  r0
end
_nt_integer_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 6908
def _nt_integer_keyword
  start_index = index
  if node_cache[:integer_keyword].has_key?(index)
    cached = node_cache[:integer_keyword][index]
    if cached
      node_cache[:integer_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[iI]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[nN]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[tT]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[gG]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[gG]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[eE]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[rR]')
                r7 = nil
              end
              s0 << r7
              if r7
                i8 = index
                if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                  r9 = true
                  @index += 1
                else
                  terminal_parse_failure('[A-Za-z0-9]')
                  r9 = nil
                end
                if r9
                  @index = i8
                  r8 = nil
                  terminal_parse_failure('[A-Za-z0-9]', true)
                else
                  @terminal_failures.pop
                  @index = i8
                  r8 = instantiate_node(SyntaxNode,input, index...index)
                end
                s0 << r8
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(IntegerKeyword0)
    r0.extend(IntegerKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:integer_keyword][start_index] = r0

  r0
end
_nt_intersect_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 7031
def _nt_intersect_keyword
  start_index = index
  if node_cache[:intersect_keyword].has_key?(index)
    cached = node_cache[:intersect_keyword][index]
    if cached
      node_cache[:intersect_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[iI]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[nN]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[tT]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[rR]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[sS]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[eE]')
                r7 = nil
              end
              s0 << r7
              if r7
                if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
                  r8 = true
                  @index += 1
                else
                  terminal_parse_failure('[cC]')
                  r8 = nil
                end
                s0 << r8
                if r8
                  if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
                    r9 = true
                    @index += 1
                  else
                    terminal_parse_failure('[tT]')
                    r9 = nil
                  end
                  s0 << r9
                  if r9
                    i10 = index
                    if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                      r11 = true
                      @index += 1
                    else
                      terminal_parse_failure('[A-Za-z0-9]')
                      r11 = nil
                    end
                    if r11
                      @index = i10
                      r10 = nil
                      terminal_parse_failure('[A-Za-z0-9]', true)
                    else
                      @terminal_failures.pop
                      @index = i10
                      r10 = instantiate_node(SyntaxNode,input, index...index)
                    end
                    s0 << r10
                  end
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(IntersectKeyword0)
    r0.extend(IntersectKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:intersect_keyword][start_index] = r0

  r0
end
_nt_into_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 7174
def _nt_into_keyword
  start_index = index
  if node_cache[:into_keyword].has_key?(index)
    cached = node_cache[:into_keyword][index]
    if cached
      node_cache[:into_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[iI]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[nN]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[tT]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[oO]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(IntoKeyword0)
    r0.extend(IntoKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:into_keyword][start_index] = r0

  r0
end
_nt_is_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 7267
def _nt_is_keyword
  start_index = index
  if node_cache[:is_keyword].has_key?(index)
    cached = node_cache[:is_keyword][index]
    if cached
      node_cache[:is_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[iI]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[sS]')
      r2 = nil
    end
    s0 << r2
    if r2
      i3 = index
      if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
        r4 = true
        @index += 1
      else
        terminal_parse_failure('[A-Za-z0-9]')
        r4 = nil
      end
      if r4
        @index = i3
        r3 = nil
        terminal_parse_failure('[A-Za-z0-9]', true)
      else
        @terminal_failures.pop
        @index = i3
        r3 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r3
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(IsKeyword0)
    r0.extend(IsKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:is_keyword][start_index] = r0

  r0
end
_nt_join_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 7340
def _nt_join_keyword
  start_index = index
  if node_cache[:join_keyword].has_key?(index)
    cached = node_cache[:join_keyword][index]
    if cached
      node_cache[:join_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[jJ]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[jJ]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[oO]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[iI]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[nN]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(JoinKeyword0)
    r0.extend(JoinKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:join_keyword][start_index] = r0

  r0
end
_nt_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 18
def _nt_keyword
  start_index = index
  if node_cache[:keyword].has_key?(index)
    cached = node_cache[:keyword][index]
    if cached
      node_cache[:keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  s1, i1 = [], index
  loop do
    if has_terminal?(@regexps[gr = '\A[a-zA-Z0-9_]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[a-zA-Z0-9_]')
      r2 = nil
    end
    if r2
      s1 << r2
    else
      break
    end
  end
  if s1.empty?
    @index = i1
    r1 = nil
  else
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
  end
  s0 << r1
  if r1
    i3 = index
    if has_terminal?(@regexps[gr = '\A[a-zA-Z0-9]'] ||= Regexp.new(gr), :regexp, index)
      r4 = true
      @index += 1
    else
      terminal_parse_failure('[a-zA-Z0-9]')
      r4 = nil
    end
    if r4
      @index = i3
      r3 = nil
      terminal_parse_failure('[a-zA-Z0-9]', true)
    else
      @terminal_failures.pop
      @index = i3
      r3 = instantiate_node(SyntaxNode,input, index...index)
    end
    s0 << r3
    if r3
      i5 = index
      r6 = lambda {|w| ["ACCESS", "ADD", "ALL", "ALTER", "AND", "ANY", "AS", "ASC", "AT", "AUDIT", "BETWEEN", "BY", "CASE", "CAST", "CHAR", "CHECK", "CLUSTER", "COLUMN", "COLUMN_VALUE", "COMMENT", "COMPRESS", "CONNECT", "CREATE", "CROSS", "CUBE", "CURRENT", "CURRENT_OF", "CURRVAL", "CURSOR", "DATE", "DAY", "DBTIMEZONE", "DECIMAL", "DEFAULT", "DELETE", "DESC", "DISTINCT", "DROP", "ELSE", "EMPTY", "END", "ESCAPE", "EXCLUSIVE", "EXISTS", "FETCH", "FILE", "FIRST", "FLOAT", "FOR", "FROM", "FULL", "GRANT", "GROUP", "HAVING", "IDENTIFIED", "IMMEDIATE", "IN", "INCREMENT", "INDEX", "INFINITE", "INITIAL", "INNER", "INSERT", "INTEGER", "INTERSECT", "INTO", "IS", "JOIN", "LAST", "LEFT", "LEVEL", "LIKE", "LIKE2", "LIKE4", "LIKEC", "LOCAL", "LOCK", "LONG", "MAXEXTENTS", "MEMBER", "MINUS", "MLSLABEL", "MODE", "MODIFY", "MONTH", "NAN", "NATURAL", "NESTED_TABLE_ID", "NEXT", "NEXTVAL", "NOAUDIT", "NOCOMPRESS", "NOT", "NOWAIT", "NULL", "NULLS", "NUMBER", "OF", "OFFLINE", "OFFSET", "ON", "ONLINE", "ONLY", "OPTION", "OR", "ORDER", "OUTER", "PCTFREE", "PERCENT", "PRIOR", "PRIVILEGES", "PUBLIC", "RAW", "REGEXP_LIKE", "RENAME", "RESOURCE", "REVOKE", "RIGHT", "ROLLUP", "ROW", "ROWID", "ROWNUM", "ROWS", "SECOND", "SELECT", "SESSION", "SESSIONTIMEZONE", "SET", "SHARE", "SIBLINGS", "SIZE", "SMALLINT", "START", "SUBMULTISET", "SUCCESSFUL", "SYNONYM", "SYSDATE", "SYSTIMESTAMP", "TABLE", "THEN", "TIES", "TIME", "TO", "TRIGGER", "TYPE", "UID", "UNION", "UNIQUE", "UPDATE", "USER", "USING", "VALIDATE", "VALUES", "VARCHAR", "VARCHAR2", "VIEW", "WAIT", "WHEN", "WHENEVER", "WHERE", "WITH", "YEAR", "ZONE"].include? w.first.text_value.upcase}.call(s0)
      if !r6
        terminal_parse_failure("<semantic predicate>")
      end
      if r6
        @index = i5
        r5 = instantiate_node(SyntaxNode,input, index...index)
      else
        @index = i5
        r5 = nil
      end
      s0 << r5
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Keyword0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:keyword][start_index] = r0

  r0
end
_nt_last_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 7433
def _nt_last_keyword
  start_index = index
  if node_cache[:last_keyword].has_key?(index)
    cached = node_cache[:last_keyword][index]
    if cached
      node_cache[:last_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[lL]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[aA]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[sS]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[tT]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(LastKeyword0)
    r0.extend(LastKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:last_keyword][start_index] = r0

  r0
end
_nt_left_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 7526
def _nt_left_keyword
  start_index = index
  if node_cache[:left_keyword].has_key?(index)
    cached = node_cache[:left_keyword][index]
    if cached
      node_cache[:left_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[lL]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[eE]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[fF]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[fF]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[tT]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(LeftKeyword0)
    r0.extend(LeftKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:left_keyword][start_index] = r0

  r0
end
_nt_level_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 7619
def _nt_level_keyword
  start_index = index
  if node_cache[:level_keyword].has_key?(index)
    cached = node_cache[:level_keyword][index]
    if cached
      node_cache[:level_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[lL]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[eE]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[vV]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[vV]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[lL]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(LevelKeyword0)
    r0.extend(LevelKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:level_keyword][start_index] = r0

  r0
end
_nt_like2_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 7815
def _nt_like2_keyword
  start_index = index
  if node_cache[:like2_keyword].has_key?(index)
    cached = node_cache[:like2_keyword][index]
    if cached
      node_cache[:like2_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[lL]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[iI]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[kK]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[kK]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          if (match_len = has_terminal?('2', false, index))
            r5 = true
            @index += match_len
          else
            terminal_parse_failure('\'2\'')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Like2Keyword0)
    r0.extend(Like2Keyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:like2_keyword][start_index] = r0

  r0
end
_nt_like4_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 7918
def _nt_like4_keyword
  start_index = index
  if node_cache[:like4_keyword].has_key?(index)
    cached = node_cache[:like4_keyword][index]
    if cached
      node_cache[:like4_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[lL]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[iI]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[kK]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[kK]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          if (match_len = has_terminal?('4', false, index))
            r5 = true
            @index += match_len
          else
            terminal_parse_failure('\'4\'')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Like4Keyword0)
    r0.extend(Like4Keyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:like4_keyword][start_index] = r0

  r0
end
_nt_like_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 7722
def _nt_like_keyword
  start_index = index
  if node_cache[:like_keyword].has_key?(index)
    cached = node_cache[:like_keyword][index]
    if cached
      node_cache[:like_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[lL]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[iI]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[kK]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[kK]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(LikeKeyword0)
    r0.extend(LikeKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:like_keyword][start_index] = r0

  r0
end
_nt_likec_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 8021
def _nt_likec_keyword
  start_index = index
  if node_cache[:likec_keyword].has_key?(index)
    cached = node_cache[:likec_keyword][index]
    if cached
      node_cache[:likec_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[lL]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[iI]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[kK]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[kK]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[cC]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(LikecKeyword0)
    r0.extend(LikecKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:likec_keyword][start_index] = r0

  r0
end
_nt_local_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 8124
def _nt_local_keyword
  start_index = index
  if node_cache[:local_keyword].has_key?(index)
    cached = node_cache[:local_keyword][index]
    if cached
      node_cache[:local_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[lL]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[oO]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[cC]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[aA]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[lL]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(LocalKeyword0)
    r0.extend(LocalKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:local_keyword][start_index] = r0

  r0
end
_nt_lock_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 8227
def _nt_lock_keyword
  start_index = index
  if node_cache[:lock_keyword].has_key?(index)
    cached = node_cache[:lock_keyword][index]
    if cached
      node_cache[:lock_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[lL]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[oO]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[cC]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[kK]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[kK]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(LockKeyword0)
    r0.extend(LockKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:lock_keyword][start_index] = r0

  r0
end
_nt_long_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 8320
def _nt_long_keyword
  start_index = index
  if node_cache[:long_keyword].has_key?(index)
    cached = node_cache[:long_keyword][index]
    if cached
      node_cache[:long_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[lL]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[oO]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[nN]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[gG]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[gG]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(LongKeyword0)
    r0.extend(LongKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:long_keyword][start_index] = r0

  r0
end
_nt_maxextents_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 8413
def _nt_maxextents_keyword
  start_index = index
  if node_cache[:maxextents_keyword].has_key?(index)
    cached = node_cache[:maxextents_keyword][index]
    if cached
      node_cache[:maxextents_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[mM]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[aA]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[xX]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[xX]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[xX]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[xX]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[tT]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[eE]')
                r7 = nil
              end
              s0 << r7
              if r7
                if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
                  r8 = true
                  @index += 1
                else
                  terminal_parse_failure('[nN]')
                  r8 = nil
                end
                s0 << r8
                if r8
                  if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
                    r9 = true
                    @index += 1
                  else
                    terminal_parse_failure('[tT]')
                    r9 = nil
                  end
                  s0 << r9
                  if r9
                    if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
                      r10 = true
                      @index += 1
                    else
                      terminal_parse_failure('[sS]')
                      r10 = nil
                    end
                    s0 << r10
                    if r10
                      i11 = index
                      if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                        r12 = true
                        @index += 1
                      else
                        terminal_parse_failure('[A-Za-z0-9]')
                        r12 = nil
                      end
                      if r12
                        @index = i11
                        r11 = nil
                        terminal_parse_failure('[A-Za-z0-9]', true)
                      else
                        @terminal_failures.pop
                        @index = i11
                        r11 = instantiate_node(SyntaxNode,input, index...index)
                      end
                      s0 << r11
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(MaxextentsKeyword0)
    r0.extend(MaxextentsKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:maxextents_keyword][start_index] = r0

  r0
end
_nt_member_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 8566
def _nt_member_keyword
  start_index = index
  if node_cache[:member_keyword].has_key?(index)
    cached = node_cache[:member_keyword][index]
    if cached
      node_cache[:member_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[mM]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[eE]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[mM]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[bB]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[bB]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[eE]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[rR]')
              r6 = nil
            end
            s0 << r6
            if r6
              i7 = index
              if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                r8 = true
                @index += 1
              else
                terminal_parse_failure('[A-Za-z0-9]')
                r8 = nil
              end
              if r8
                @index = i7
                r7 = nil
                terminal_parse_failure('[A-Za-z0-9]', true)
              else
                @terminal_failures.pop
                @index = i7
                r7 = instantiate_node(SyntaxNode,input, index...index)
              end
              s0 << r7
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(MemberKeyword0)
    r0.extend(MemberKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:member_keyword][start_index] = r0

  r0
end
_nt_minus_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 8679
def _nt_minus_keyword
  start_index = index
  if node_cache[:minus_keyword].has_key?(index)
    cached = node_cache[:minus_keyword][index]
    if cached
      node_cache[:minus_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[mM]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[iI]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[nN]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[uU]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[sS]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(MinusKeyword0)
    r0.extend(MinusKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:minus_keyword][start_index] = r0

  r0
end
_nt_mlslabel_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 8782
def _nt_mlslabel_keyword
  start_index = index
  if node_cache[:mlslabel_keyword].has_key?(index)
    cached = node_cache[:mlslabel_keyword][index]
    if cached
      node_cache[:mlslabel_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[mM]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[lL]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[sS]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[lL]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[aA]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[bB]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[bB]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[eE]')
                r7 = nil
              end
              s0 << r7
              if r7
                if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
                  r8 = true
                  @index += 1
                else
                  terminal_parse_failure('[lL]')
                  r8 = nil
                end
                s0 << r8
                if r8
                  i9 = index
                  if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                    r10 = true
                    @index += 1
                  else
                    terminal_parse_failure('[A-Za-z0-9]')
                    r10 = nil
                  end
                  if r10
                    @index = i9
                    r9 = nil
                    terminal_parse_failure('[A-Za-z0-9]', true)
                  else
                    @terminal_failures.pop
                    @index = i9
                    r9 = instantiate_node(SyntaxNode,input, index...index)
                  end
                  s0 << r9
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(MlslabelKeyword0)
    r0.extend(MlslabelKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:mlslabel_keyword][start_index] = r0

  r0
end
_nt_mode_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 8915
def _nt_mode_keyword
  start_index = index
  if node_cache[:mode_keyword].has_key?(index)
    cached = node_cache[:mode_keyword][index]
    if cached
      node_cache[:mode_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[mM]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[oO]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[dD]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ModeKeyword0)
    r0.extend(ModeKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:mode_keyword][start_index] = r0

  r0
end
_nt_modify_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 9008
def _nt_modify_keyword
  start_index = index
  if node_cache[:modify_keyword].has_key?(index)
    cached = node_cache[:modify_keyword][index]
    if cached
      node_cache[:modify_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[mM]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[oO]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[dD]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[iI]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[fF]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[fF]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[yY]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[yY]')
              r6 = nil
            end
            s0 << r6
            if r6
              i7 = index
              if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                r8 = true
                @index += 1
              else
                terminal_parse_failure('[A-Za-z0-9]')
                r8 = nil
              end
              if r8
                @index = i7
                r7 = nil
                terminal_parse_failure('[A-Za-z0-9]', true)
              else
                @terminal_failures.pop
                @index = i7
                r7 = instantiate_node(SyntaxNode,input, index...index)
              end
              s0 << r7
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ModifyKeyword0)
    r0.extend(ModifyKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:modify_keyword][start_index] = r0

  r0
end
_nt_month_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 9121
def _nt_month_keyword
  start_index = index
  if node_cache[:month_keyword].has_key?(index)
    cached = node_cache[:month_keyword][index]
    if cached
      node_cache[:month_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[mM]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[oO]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[nN]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[tT]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[hH]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[hH]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(MonthKeyword0)
    r0.extend(MonthKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:month_keyword][start_index] = r0

  r0
end
_nt_nan_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 9224
def _nt_nan_keyword
  start_index = index
  if node_cache[:nan_keyword].has_key?(index)
    cached = node_cache[:nan_keyword][index]
    if cached
      node_cache[:nan_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[nN]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[aA]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[nN]')
        r3 = nil
      end
      s0 << r3
      if r3
        i4 = index
        if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
          r5 = true
          @index += 1
        else
          terminal_parse_failure('[A-Za-z0-9]')
          r5 = nil
        end
        if r5
          @index = i4
          r4 = nil
          terminal_parse_failure('[A-Za-z0-9]', true)
        else
          @terminal_failures.pop
          @index = i4
          r4 = instantiate_node(SyntaxNode,input, index...index)
        end
        s0 << r4
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(NanKeyword0)
    r0.extend(NanKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:nan_keyword][start_index] = r0

  r0
end
_nt_natural_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 9307
def _nt_natural_keyword
  start_index = index
  if node_cache[:natural_keyword].has_key?(index)
    cached = node_cache[:natural_keyword][index]
    if cached
      node_cache[:natural_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[nN]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[aA]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[tT]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[uU]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[rR]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[aA]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[lL]')
                r7 = nil
              end
              s0 << r7
              if r7
                i8 = index
                if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                  r9 = true
                  @index += 1
                else
                  terminal_parse_failure('[A-Za-z0-9]')
                  r9 = nil
                end
                if r9
                  @index = i8
                  r8 = nil
                  terminal_parse_failure('[A-Za-z0-9]', true)
                else
                  @terminal_failures.pop
                  @index = i8
                  r8 = instantiate_node(SyntaxNode,input, index...index)
                end
                s0 << r8
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(NaturalKeyword0)
    r0.extend(NaturalKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:natural_keyword][start_index] = r0

  r0
end
_nt_nested_table_id_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 9430
def _nt_nested_table_id_keyword
  start_index = index
  if node_cache[:nested_table_id_keyword].has_key?(index)
    cached = node_cache[:nested_table_id_keyword][index]
    if cached
      node_cache[:nested_table_id_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[nN]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[eE]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[sS]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[tT]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[eE]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[dD]')
              r6 = nil
            end
            s0 << r6
            if r6
              if (match_len = has_terminal?('_', false, index))
                r7 = true
                @index += match_len
              else
                terminal_parse_failure('\'_\'')
                r7 = nil
              end
              s0 << r7
              if r7
                if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
                  r8 = true
                  @index += 1
                else
                  terminal_parse_failure('[tT]')
                  r8 = nil
                end
                s0 << r8
                if r8
                  if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
                    r9 = true
                    @index += 1
                  else
                    terminal_parse_failure('[aA]')
                    r9 = nil
                  end
                  s0 << r9
                  if r9
                    if has_terminal?(@regexps[gr = '\A[bB]'] ||= Regexp.new(gr), :regexp, index)
                      r10 = true
                      @index += 1
                    else
                      terminal_parse_failure('[bB]')
                      r10 = nil
                    end
                    s0 << r10
                    if r10
                      if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
                        r11 = true
                        @index += 1
                      else
                        terminal_parse_failure('[lL]')
                        r11 = nil
                      end
                      s0 << r11
                      if r11
                        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
                          r12 = true
                          @index += 1
                        else
                          terminal_parse_failure('[eE]')
                          r12 = nil
                        end
                        s0 << r12
                        if r12
                          if (match_len = has_terminal?('_', false, index))
                            r13 = true
                            @index += match_len
                          else
                            terminal_parse_failure('\'_\'')
                            r13 = nil
                          end
                          s0 << r13
                          if r13
                            if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
                              r14 = true
                              @index += 1
                            else
                              terminal_parse_failure('[iI]')
                              r14 = nil
                            end
                            s0 << r14
                            if r14
                              if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
                                r15 = true
                                @index += 1
                              else
                                terminal_parse_failure('[dD]')
                                r15 = nil
                              end
                              s0 << r15
                              if r15
                                i16 = index
                                if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                                  r17 = true
                                  @index += 1
                                else
                                  terminal_parse_failure('[A-Za-z0-9]')
                                  r17 = nil
                                end
                                if r17
                                  @index = i16
                                  r16 = nil
                                  terminal_parse_failure('[A-Za-z0-9]', true)
                                else
                                  @terminal_failures.pop
                                  @index = i16
                                  r16 = instantiate_node(SyntaxNode,input, index...index)
                                end
                                s0 << r16
                              end
                            end
                          end
                        end
                      end
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(NestedTableIdKeyword0)
    r0.extend(NestedTableIdKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:nested_table_id_keyword][start_index] = r0

  r0
end
_nt_next_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 9633
def _nt_next_keyword
  start_index = index
  if node_cache[:next_keyword].has_key?(index)
    cached = node_cache[:next_keyword][index]
    if cached
      node_cache[:next_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[nN]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[eE]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[xX]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[xX]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[tT]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(NextKeyword0)
    r0.extend(NextKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:next_keyword][start_index] = r0

  r0
end
_nt_nextval_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 9726
def _nt_nextval_keyword
  start_index = index
  if node_cache[:nextval_keyword].has_key?(index)
    cached = node_cache[:nextval_keyword][index]
    if cached
      node_cache[:nextval_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[nN]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[eE]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[xX]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[xX]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[tT]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[vV]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[vV]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[aA]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[lL]')
                r7 = nil
              end
              s0 << r7
              if r7
                i8 = index
                if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                  r9 = true
                  @index += 1
                else
                  terminal_parse_failure('[A-Za-z0-9]')
                  r9 = nil
                end
                if r9
                  @index = i8
                  r8 = nil
                  terminal_parse_failure('[A-Za-z0-9]', true)
                else
                  @terminal_failures.pop
                  @index = i8
                  r8 = instantiate_node(SyntaxNode,input, index...index)
                end
                s0 << r8
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(NextvalKeyword0)
    r0.extend(NextvalKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:nextval_keyword][start_index] = r0

  r0
end
_nt_noaudit_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 9849
def _nt_noaudit_keyword
  start_index = index
  if node_cache[:noaudit_keyword].has_key?(index)
    cached = node_cache[:noaudit_keyword][index]
    if cached
      node_cache[:noaudit_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[nN]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[oO]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[aA]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[uU]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[dD]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[iI]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[tT]')
                r7 = nil
              end
              s0 << r7
              if r7
                i8 = index
                if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                  r9 = true
                  @index += 1
                else
                  terminal_parse_failure('[A-Za-z0-9]')
                  r9 = nil
                end
                if r9
                  @index = i8
                  r8 = nil
                  terminal_parse_failure('[A-Za-z0-9]', true)
                else
                  @terminal_failures.pop
                  @index = i8
                  r8 = instantiate_node(SyntaxNode,input, index...index)
                end
                s0 << r8
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(NoauditKeyword0)
    r0.extend(NoauditKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:noaudit_keyword][start_index] = r0

  r0
end
_nt_nocompress_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 9972
def _nt_nocompress_keyword
  start_index = index
  if node_cache[:nocompress_keyword].has_key?(index)
    cached = node_cache[:nocompress_keyword][index]
    if cached
      node_cache[:nocompress_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[nN]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[oO]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[cC]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[oO]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[mM]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[pP]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[pP]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[rR]')
                r7 = nil
              end
              s0 << r7
              if r7
                if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
                  r8 = true
                  @index += 1
                else
                  terminal_parse_failure('[eE]')
                  r8 = nil
                end
                s0 << r8
                if r8
                  if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
                    r9 = true
                    @index += 1
                  else
                    terminal_parse_failure('[sS]')
                    r9 = nil
                  end
                  s0 << r9
                  if r9
                    if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
                      r10 = true
                      @index += 1
                    else
                      terminal_parse_failure('[sS]')
                      r10 = nil
                    end
                    s0 << r10
                    if r10
                      i11 = index
                      if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                        r12 = true
                        @index += 1
                      else
                        terminal_parse_failure('[A-Za-z0-9]')
                        r12 = nil
                      end
                      if r12
                        @index = i11
                        r11 = nil
                        terminal_parse_failure('[A-Za-z0-9]', true)
                      else
                        @terminal_failures.pop
                        @index = i11
                        r11 = instantiate_node(SyntaxNode,input, index...index)
                      end
                      s0 << r11
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(NocompressKeyword0)
    r0.extend(NocompressKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:nocompress_keyword][start_index] = r0

  r0
end
_nt_not_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 10125
def _nt_not_keyword
  start_index = index
  if node_cache[:not_keyword].has_key?(index)
    cached = node_cache[:not_keyword][index]
    if cached
      node_cache[:not_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[nN]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[oO]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[tT]')
        r3 = nil
      end
      s0 << r3
      if r3
        i4 = index
        if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
          r5 = true
          @index += 1
        else
          terminal_parse_failure('[A-Za-z0-9]')
          r5 = nil
        end
        if r5
          @index = i4
          r4 = nil
          terminal_parse_failure('[A-Za-z0-9]', true)
        else
          @terminal_failures.pop
          @index = i4
          r4 = instantiate_node(SyntaxNode,input, index...index)
        end
        s0 << r4
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(NotKeyword0)
    r0.extend(NotKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:not_keyword][start_index] = r0

  r0
end
_nt_nowait_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 10208
def _nt_nowait_keyword
  start_index = index
  if node_cache[:nowait_keyword].has_key?(index)
    cached = node_cache[:nowait_keyword][index]
    if cached
      node_cache[:nowait_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[nN]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[oO]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[wW]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[wW]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[aA]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[iI]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[tT]')
              r6 = nil
            end
            s0 << r6
            if r6
              i7 = index
              if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                r8 = true
                @index += 1
              else
                terminal_parse_failure('[A-Za-z0-9]')
                r8 = nil
              end
              if r8
                @index = i7
                r7 = nil
                terminal_parse_failure('[A-Za-z0-9]', true)
              else
                @terminal_failures.pop
                @index = i7
                r7 = instantiate_node(SyntaxNode,input, index...index)
              end
              s0 << r7
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(NowaitKeyword0)
    r0.extend(NowaitKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:nowait_keyword][start_index] = r0

  r0
end
_nt_null_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 10321
def _nt_null_keyword
  start_index = index
  if node_cache[:null_keyword].has_key?(index)
    cached = node_cache[:null_keyword][index]
    if cached
      node_cache[:null_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[nN]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[uU]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[lL]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[lL]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(NullKeyword0)
    r0.extend(NullKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:null_keyword][start_index] = r0

  r0
end
_nt_nulls_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 10414
def _nt_nulls_keyword
  start_index = index
  if node_cache[:nulls_keyword].has_key?(index)
    cached = node_cache[:nulls_keyword][index]
    if cached
      node_cache[:nulls_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[nN]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[uU]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[lL]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[lL]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[sS]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(NullsKeyword0)
    r0.extend(NullsKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:nulls_keyword][start_index] = r0

  r0
end
_nt_number_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 10517
def _nt_number_keyword
  start_index = index
  if node_cache[:number_keyword].has_key?(index)
    cached = node_cache[:number_keyword][index]
    if cached
      node_cache[:number_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[nN]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[uU]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[mM]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[bB]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[bB]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[eE]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[rR]')
              r6 = nil
            end
            s0 << r6
            if r6
              i7 = index
              if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                r8 = true
                @index += 1
              else
                terminal_parse_failure('[A-Za-z0-9]')
                r8 = nil
              end
              if r8
                @index = i7
                r7 = nil
                terminal_parse_failure('[A-Za-z0-9]', true)
              else
                @terminal_failures.pop
                @index = i7
                r7 = instantiate_node(SyntaxNode,input, index...index)
              end
              s0 << r7
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(NumberKeyword0)
    r0.extend(NumberKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:number_keyword][start_index] = r0

  r0
end
_nt_of_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 10630
def _nt_of_keyword
  start_index = index
  if node_cache[:of_keyword].has_key?(index)
    cached = node_cache[:of_keyword][index]
    if cached
      node_cache[:of_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[oO]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[fF]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[fF]')
      r2 = nil
    end
    s0 << r2
    if r2
      i3 = index
      if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
        r4 = true
        @index += 1
      else
        terminal_parse_failure('[A-Za-z0-9]')
        r4 = nil
      end
      if r4
        @index = i3
        r3 = nil
        terminal_parse_failure('[A-Za-z0-9]', true)
      else
        @terminal_failures.pop
        @index = i3
        r3 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r3
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(OfKeyword0)
    r0.extend(OfKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:of_keyword][start_index] = r0

  r0
end
_nt_offline_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 10703
def _nt_offline_keyword
  start_index = index
  if node_cache[:offline_keyword].has_key?(index)
    cached = node_cache[:offline_keyword][index]
    if cached
      node_cache[:offline_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[oO]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[fF]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[fF]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[fF]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[fF]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[lL]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[iI]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[nN]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[eE]')
                r7 = nil
              end
              s0 << r7
              if r7
                i8 = index
                if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                  r9 = true
                  @index += 1
                else
                  terminal_parse_failure('[A-Za-z0-9]')
                  r9 = nil
                end
                if r9
                  @index = i8
                  r8 = nil
                  terminal_parse_failure('[A-Za-z0-9]', true)
                else
                  @terminal_failures.pop
                  @index = i8
                  r8 = instantiate_node(SyntaxNode,input, index...index)
                end
                s0 << r8
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(OfflineKeyword0)
    r0.extend(OfflineKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:offline_keyword][start_index] = r0

  r0
end
_nt_offset_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 10826
def _nt_offset_keyword
  start_index = index
  if node_cache[:offset_keyword].has_key?(index)
    cached = node_cache[:offset_keyword][index]
    if cached
      node_cache[:offset_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[oO]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[fF]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[fF]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[fF]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[fF]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[sS]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[eE]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[tT]')
              r6 = nil
            end
            s0 << r6
            if r6
              i7 = index
              if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                r8 = true
                @index += 1
              else
                terminal_parse_failure('[A-Za-z0-9]')
                r8 = nil
              end
              if r8
                @index = i7
                r7 = nil
                terminal_parse_failure('[A-Za-z0-9]', true)
              else
                @terminal_failures.pop
                @index = i7
                r7 = instantiate_node(SyntaxNode,input, index...index)
              end
              s0 << r7
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(OffsetKeyword0)
    r0.extend(OffsetKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:offset_keyword][start_index] = r0

  r0
end
_nt_on_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 10939
def _nt_on_keyword
  start_index = index
  if node_cache[:on_keyword].has_key?(index)
    cached = node_cache[:on_keyword][index]
    if cached
      node_cache[:on_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[oO]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[nN]')
      r2 = nil
    end
    s0 << r2
    if r2
      i3 = index
      if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
        r4 = true
        @index += 1
      else
        terminal_parse_failure('[A-Za-z0-9]')
        r4 = nil
      end
      if r4
        @index = i3
        r3 = nil
        terminal_parse_failure('[A-Za-z0-9]', true)
      else
        @terminal_failures.pop
        @index = i3
        r3 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r3
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(OnKeyword0)
    r0.extend(OnKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:on_keyword][start_index] = r0

  r0
end
_nt_online_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 11012
def _nt_online_keyword
  start_index = index
  if node_cache[:online_keyword].has_key?(index)
    cached = node_cache[:online_keyword][index]
    if cached
      node_cache[:online_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[oO]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[nN]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[lL]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[iI]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[nN]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[eE]')
              r6 = nil
            end
            s0 << r6
            if r6
              i7 = index
              if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                r8 = true
                @index += 1
              else
                terminal_parse_failure('[A-Za-z0-9]')
                r8 = nil
              end
              if r8
                @index = i7
                r7 = nil
                terminal_parse_failure('[A-Za-z0-9]', true)
              else
                @terminal_failures.pop
                @index = i7
                r7 = instantiate_node(SyntaxNode,input, index...index)
              end
              s0 << r7
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(OnlineKeyword0)
    r0.extend(OnlineKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:online_keyword][start_index] = r0

  r0
end
_nt_only_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 11125
def _nt_only_keyword
  start_index = index
  if node_cache[:only_keyword].has_key?(index)
    cached = node_cache[:only_keyword][index]
    if cached
      node_cache[:only_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[oO]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[nN]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[lL]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[yY]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[yY]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(OnlyKeyword0)
    r0.extend(OnlyKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:only_keyword][start_index] = r0

  r0
end
_nt_option_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 11218
def _nt_option_keyword
  start_index = index
  if node_cache[:option_keyword].has_key?(index)
    cached = node_cache[:option_keyword][index]
    if cached
      node_cache[:option_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[oO]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[pP]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[pP]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[tT]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[iI]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[oO]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[nN]')
              r6 = nil
            end
            s0 << r6
            if r6
              i7 = index
              if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                r8 = true
                @index += 1
              else
                terminal_parse_failure('[A-Za-z0-9]')
                r8 = nil
              end
              if r8
                @index = i7
                r7 = nil
                terminal_parse_failure('[A-Za-z0-9]', true)
              else
                @terminal_failures.pop
                @index = i7
                r7 = instantiate_node(SyntaxNode,input, index...index)
              end
              s0 << r7
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(OptionKeyword0)
    r0.extend(OptionKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:option_keyword][start_index] = r0

  r0
end
_nt_or_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 11331
def _nt_or_keyword
  start_index = index
  if node_cache[:or_keyword].has_key?(index)
    cached = node_cache[:or_keyword][index]
    if cached
      node_cache[:or_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[oO]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[rR]')
      r2 = nil
    end
    s0 << r2
    if r2
      i3 = index
      if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
        r4 = true
        @index += 1
      else
        terminal_parse_failure('[A-Za-z0-9]')
        r4 = nil
      end
      if r4
        @index = i3
        r3 = nil
        terminal_parse_failure('[A-Za-z0-9]', true)
      else
        @terminal_failures.pop
        @index = i3
        r3 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r3
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(OrKeyword0)
    r0.extend(OrKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:or_keyword][start_index] = r0

  r0
end
_nt_order_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 11404
def _nt_order_keyword
  start_index = index
  if node_cache[:order_keyword].has_key?(index)
    cached = node_cache[:order_keyword][index]
    if cached
      node_cache[:order_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[oO]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[rR]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[dD]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[rR]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(OrderKeyword0)
    r0.extend(OrderKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:order_keyword][start_index] = r0

  r0
end
_nt_outer_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 11507
def _nt_outer_keyword
  start_index = index
  if node_cache[:outer_keyword].has_key?(index)
    cached = node_cache[:outer_keyword][index]
    if cached
      node_cache[:outer_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[oO]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[uU]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[tT]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[rR]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(OuterKeyword0)
    r0.extend(OuterKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:outer_keyword][start_index] = r0

  r0
end
_nt_pctfree_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 11610
def _nt_pctfree_keyword
  start_index = index
  if node_cache[:pctfree_keyword].has_key?(index)
    cached = node_cache[:pctfree_keyword][index]
    if cached
      node_cache[:pctfree_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[pP]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[pP]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[cC]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[tT]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[fF]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[fF]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[rR]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[eE]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[eE]')
                r7 = nil
              end
              s0 << r7
              if r7
                i8 = index
                if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                  r9 = true
                  @index += 1
                else
                  terminal_parse_failure('[A-Za-z0-9]')
                  r9 = nil
                end
                if r9
                  @index = i8
                  r8 = nil
                  terminal_parse_failure('[A-Za-z0-9]', true)
                else
                  @terminal_failures.pop
                  @index = i8
                  r8 = instantiate_node(SyntaxNode,input, index...index)
                end
                s0 << r8
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(PctfreeKeyword0)
    r0.extend(PctfreeKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:pctfree_keyword][start_index] = r0

  r0
end
_nt_percent_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 11733
def _nt_percent_keyword
  start_index = index
  if node_cache[:percent_keyword].has_key?(index)
    cached = node_cache[:percent_keyword][index]
    if cached
      node_cache[:percent_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[pP]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[pP]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[eE]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[rR]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[cC]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[eE]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[nN]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[tT]')
                r7 = nil
              end
              s0 << r7
              if r7
                i8 = index
                if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                  r9 = true
                  @index += 1
                else
                  terminal_parse_failure('[A-Za-z0-9]')
                  r9 = nil
                end
                if r9
                  @index = i8
                  r8 = nil
                  terminal_parse_failure('[A-Za-z0-9]', true)
                else
                  @terminal_failures.pop
                  @index = i8
                  r8 = instantiate_node(SyntaxNode,input, index...index)
                end
                s0 << r8
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(PercentKeyword0)
    r0.extend(PercentKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:percent_keyword][start_index] = r0

  r0
end
_nt_prior_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 11856
def _nt_prior_keyword
  start_index = index
  if node_cache[:prior_keyword].has_key?(index)
    cached = node_cache[:prior_keyword][index]
    if cached
      node_cache[:prior_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[pP]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[pP]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[rR]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[iI]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[oO]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[rR]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(PriorKeyword0)
    r0.extend(PriorKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:prior_keyword][start_index] = r0

  r0
end
_nt_privileges_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 11959
def _nt_privileges_keyword
  start_index = index
  if node_cache[:privileges_keyword].has_key?(index)
    cached = node_cache[:privileges_keyword][index]
    if cached
      node_cache[:privileges_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[pP]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[pP]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[rR]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[iI]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[vV]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[vV]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[iI]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[lL]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[eE]')
                r7 = nil
              end
              s0 << r7
              if r7
                if has_terminal?(@regexps[gr = '\A[gG]'] ||= Regexp.new(gr), :regexp, index)
                  r8 = true
                  @index += 1
                else
                  terminal_parse_failure('[gG]')
                  r8 = nil
                end
                s0 << r8
                if r8
                  if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
                    r9 = true
                    @index += 1
                  else
                    terminal_parse_failure('[eE]')
                    r9 = nil
                  end
                  s0 << r9
                  if r9
                    if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
                      r10 = true
                      @index += 1
                    else
                      terminal_parse_failure('[sS]')
                      r10 = nil
                    end
                    s0 << r10
                    if r10
                      i11 = index
                      if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                        r12 = true
                        @index += 1
                      else
                        terminal_parse_failure('[A-Za-z0-9]')
                        r12 = nil
                      end
                      if r12
                        @index = i11
                        r11 = nil
                        terminal_parse_failure('[A-Za-z0-9]', true)
                      else
                        @terminal_failures.pop
                        @index = i11
                        r11 = instantiate_node(SyntaxNode,input, index...index)
                      end
                      s0 << r11
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(PrivilegesKeyword0)
    r0.extend(PrivilegesKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:privileges_keyword][start_index] = r0

  r0
end
_nt_public_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 12112
def _nt_public_keyword
  start_index = index
  if node_cache[:public_keyword].has_key?(index)
    cached = node_cache[:public_keyword][index]
    if cached
      node_cache[:public_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[pP]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[pP]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[uU]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[bB]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[bB]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[lL]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[iI]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[cC]')
              r6 = nil
            end
            s0 << r6
            if r6
              i7 = index
              if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                r8 = true
                @index += 1
              else
                terminal_parse_failure('[A-Za-z0-9]')
                r8 = nil
              end
              if r8
                @index = i7
                r7 = nil
                terminal_parse_failure('[A-Za-z0-9]', true)
              else
                @terminal_failures.pop
                @index = i7
                r7 = instantiate_node(SyntaxNode,input, index...index)
              end
              s0 << r7
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(PublicKeyword0)
    r0.extend(PublicKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:public_keyword][start_index] = r0

  r0
end
_nt_raw_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 12225
def _nt_raw_keyword
  start_index = index
  if node_cache[:raw_keyword].has_key?(index)
    cached = node_cache[:raw_keyword][index]
    if cached
      node_cache[:raw_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[rR]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[aA]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[wW]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[wW]')
        r3 = nil
      end
      s0 << r3
      if r3
        i4 = index
        if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
          r5 = true
          @index += 1
        else
          terminal_parse_failure('[A-Za-z0-9]')
          r5 = nil
        end
        if r5
          @index = i4
          r4 = nil
          terminal_parse_failure('[A-Za-z0-9]', true)
        else
          @terminal_failures.pop
          @index = i4
          r4 = instantiate_node(SyntaxNode,input, index...index)
        end
        s0 << r4
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(RawKeyword0)
    r0.extend(RawKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:raw_keyword][start_index] = r0

  r0
end
_nt_regexp_like_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 12308
def _nt_regexp_like_keyword
  start_index = index
  if node_cache[:regexp_like_keyword].has_key?(index)
    cached = node_cache[:regexp_like_keyword][index]
    if cached
      node_cache[:regexp_like_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[rR]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[eE]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[gG]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[gG]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[xX]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[xX]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[pP]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[pP]')
              r6 = nil
            end
            s0 << r6
            if r6
              if (match_len = has_terminal?('_', false, index))
                r7 = true
                @index += match_len
              else
                terminal_parse_failure('\'_\'')
                r7 = nil
              end
              s0 << r7
              if r7
                if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
                  r8 = true
                  @index += 1
                else
                  terminal_parse_failure('[lL]')
                  r8 = nil
                end
                s0 << r8
                if r8
                  if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
                    r9 = true
                    @index += 1
                  else
                    terminal_parse_failure('[iI]')
                    r9 = nil
                  end
                  s0 << r9
                  if r9
                    if has_terminal?(@regexps[gr = '\A[kK]'] ||= Regexp.new(gr), :regexp, index)
                      r10 = true
                      @index += 1
                    else
                      terminal_parse_failure('[kK]')
                      r10 = nil
                    end
                    s0 << r10
                    if r10
                      if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
                        r11 = true
                        @index += 1
                      else
                        terminal_parse_failure('[eE]')
                        r11 = nil
                      end
                      s0 << r11
                      if r11
                        i12 = index
                        if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                          r13 = true
                          @index += 1
                        else
                          terminal_parse_failure('[A-Za-z0-9]')
                          r13 = nil
                        end
                        if r13
                          @index = i12
                          r12 = nil
                          terminal_parse_failure('[A-Za-z0-9]', true)
                        else
                          @terminal_failures.pop
                          @index = i12
                          r12 = instantiate_node(SyntaxNode,input, index...index)
                        end
                        s0 << r12
                      end
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(RegexpLikeKeyword0)
    r0.extend(RegexpLikeKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:regexp_like_keyword][start_index] = r0

  r0
end
_nt_rename_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 12471
def _nt_rename_keyword
  start_index = index
  if node_cache[:rename_keyword].has_key?(index)
    cached = node_cache[:rename_keyword][index]
    if cached
      node_cache[:rename_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[rR]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[eE]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[nN]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[aA]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[mM]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[eE]')
              r6 = nil
            end
            s0 << r6
            if r6
              i7 = index
              if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                r8 = true
                @index += 1
              else
                terminal_parse_failure('[A-Za-z0-9]')
                r8 = nil
              end
              if r8
                @index = i7
                r7 = nil
                terminal_parse_failure('[A-Za-z0-9]', true)
              else
                @terminal_failures.pop
                @index = i7
                r7 = instantiate_node(SyntaxNode,input, index...index)
              end
              s0 << r7
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(RenameKeyword0)
    r0.extend(RenameKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:rename_keyword][start_index] = r0

  r0
end
_nt_resource_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 12584
def _nt_resource_keyword
  start_index = index
  if node_cache[:resource_keyword].has_key?(index)
    cached = node_cache[:resource_keyword][index]
    if cached
      node_cache[:resource_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[rR]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[eE]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[sS]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[oO]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[uU]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[rR]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[cC]')
                r7 = nil
              end
              s0 << r7
              if r7
                if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
                  r8 = true
                  @index += 1
                else
                  terminal_parse_failure('[eE]')
                  r8 = nil
                end
                s0 << r8
                if r8
                  i9 = index
                  if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                    r10 = true
                    @index += 1
                  else
                    terminal_parse_failure('[A-Za-z0-9]')
                    r10 = nil
                  end
                  if r10
                    @index = i9
                    r9 = nil
                    terminal_parse_failure('[A-Za-z0-9]', true)
                  else
                    @terminal_failures.pop
                    @index = i9
                    r9 = instantiate_node(SyntaxNode,input, index...index)
                  end
                  s0 << r9
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ResourceKeyword0)
    r0.extend(ResourceKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:resource_keyword][start_index] = r0

  r0
end
_nt_revoke_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 12717
def _nt_revoke_keyword
  start_index = index
  if node_cache[:revoke_keyword].has_key?(index)
    cached = node_cache[:revoke_keyword][index]
    if cached
      node_cache[:revoke_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[rR]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[eE]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[vV]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[vV]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[oO]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[kK]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[kK]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[eE]')
              r6 = nil
            end
            s0 << r6
            if r6
              i7 = index
              if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                r8 = true
                @index += 1
              else
                terminal_parse_failure('[A-Za-z0-9]')
                r8 = nil
              end
              if r8
                @index = i7
                r7 = nil
                terminal_parse_failure('[A-Za-z0-9]', true)
              else
                @terminal_failures.pop
                @index = i7
                r7 = instantiate_node(SyntaxNode,input, index...index)
              end
              s0 << r7
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(RevokeKeyword0)
    r0.extend(RevokeKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:revoke_keyword][start_index] = r0

  r0
end
_nt_right_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 12830
def _nt_right_keyword
  start_index = index
  if node_cache[:right_keyword].has_key?(index)
    cached = node_cache[:right_keyword][index]
    if cached
      node_cache[:right_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[rR]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[iI]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[gG]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[gG]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[hH]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[hH]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[tT]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(RightKeyword0)
    r0.extend(RightKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:right_keyword][start_index] = r0

  r0
end
_nt_rollup_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 12933
def _nt_rollup_keyword
  start_index = index
  if node_cache[:rollup_keyword].has_key?(index)
    cached = node_cache[:rollup_keyword][index]
    if cached
      node_cache[:rollup_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[rR]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[oO]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[lL]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[lL]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[uU]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[pP]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[pP]')
              r6 = nil
            end
            s0 << r6
            if r6
              i7 = index
              if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                r8 = true
                @index += 1
              else
                terminal_parse_failure('[A-Za-z0-9]')
                r8 = nil
              end
              if r8
                @index = i7
                r7 = nil
                terminal_parse_failure('[A-Za-z0-9]', true)
              else
                @terminal_failures.pop
                @index = i7
                r7 = instantiate_node(SyntaxNode,input, index...index)
              end
              s0 << r7
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(RollupKeyword0)
    r0.extend(RollupKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:rollup_keyword][start_index] = r0

  r0
end
_nt_row_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 13046
def _nt_row_keyword
  start_index = index
  if node_cache[:row_keyword].has_key?(index)
    cached = node_cache[:row_keyword][index]
    if cached
      node_cache[:row_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[rR]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[oO]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[wW]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[wW]')
        r3 = nil
      end
      s0 << r3
      if r3
        i4 = index
        if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
          r5 = true
          @index += 1
        else
          terminal_parse_failure('[A-Za-z0-9]')
          r5 = nil
        end
        if r5
          @index = i4
          r4 = nil
          terminal_parse_failure('[A-Za-z0-9]', true)
        else
          @terminal_failures.pop
          @index = i4
          r4 = instantiate_node(SyntaxNode,input, index...index)
        end
        s0 << r4
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(RowKeyword0)
    r0.extend(RowKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:row_keyword][start_index] = r0

  r0
end
_nt_rowid_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 13129
def _nt_rowid_keyword
  start_index = index
  if node_cache[:rowid_keyword].has_key?(index)
    cached = node_cache[:rowid_keyword][index]
    if cached
      node_cache[:rowid_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[rR]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[oO]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[wW]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[wW]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[iI]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[dD]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(RowidKeyword0)
    r0.extend(RowidKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:rowid_keyword][start_index] = r0

  r0
end
_nt_rownum_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 13232
def _nt_rownum_keyword
  start_index = index
  if node_cache[:rownum_keyword].has_key?(index)
    cached = node_cache[:rownum_keyword][index]
    if cached
      node_cache[:rownum_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[rR]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[oO]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[wW]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[wW]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[nN]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[uU]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[mM]')
              r6 = nil
            end
            s0 << r6
            if r6
              i7 = index
              if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                r8 = true
                @index += 1
              else
                terminal_parse_failure('[A-Za-z0-9]')
                r8 = nil
              end
              if r8
                @index = i7
                r7 = nil
                terminal_parse_failure('[A-Za-z0-9]', true)
              else
                @terminal_failures.pop
                @index = i7
                r7 = instantiate_node(SyntaxNode,input, index...index)
              end
              s0 << r7
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(RownumKeyword0)
    r0.extend(RownumKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:rownum_keyword][start_index] = r0

  r0
end
_nt_rows_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 13345
def _nt_rows_keyword
  start_index = index
  if node_cache[:rows_keyword].has_key?(index)
    cached = node_cache[:rows_keyword][index]
    if cached
      node_cache[:rows_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[rR]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[oO]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[wW]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[wW]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[sS]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(RowsKeyword0)
    r0.extend(RowsKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:rows_keyword][start_index] = r0

  r0
end
_nt_second_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 13438
def _nt_second_keyword
  start_index = index
  if node_cache[:second_keyword].has_key?(index)
    cached = node_cache[:second_keyword][index]
    if cached
      node_cache[:second_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[sS]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[eE]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[cC]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[oO]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[nN]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[dD]')
              r6 = nil
            end
            s0 << r6
            if r6
              i7 = index
              if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                r8 = true
                @index += 1
              else
                terminal_parse_failure('[A-Za-z0-9]')
                r8 = nil
              end
              if r8
                @index = i7
                r7 = nil
                terminal_parse_failure('[A-Za-z0-9]', true)
              else
                @terminal_failures.pop
                @index = i7
                r7 = instantiate_node(SyntaxNode,input, index...index)
              end
              s0 << r7
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(SecondKeyword0)
    r0.extend(SecondKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:second_keyword][start_index] = r0

  r0
end
_nt_select_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 13551
def _nt_select_keyword
  start_index = index
  if node_cache[:select_keyword].has_key?(index)
    cached = node_cache[:select_keyword][index]
    if cached
      node_cache[:select_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[sS]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[eE]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[lL]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[cC]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[tT]')
              r6 = nil
            end
            s0 << r6
            if r6
              i7 = index
              if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                r8 = true
                @index += 1
              else
                terminal_parse_failure('[A-Za-z0-9]')
                r8 = nil
              end
              if r8
                @index = i7
                r7 = nil
                terminal_parse_failure('[A-Za-z0-9]', true)
              else
                @terminal_failures.pop
                @index = i7
                r7 = instantiate_node(SyntaxNode,input, index...index)
              end
              s0 << r7
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(SelectKeyword0)
    r0.extend(SelectKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:select_keyword][start_index] = r0

  r0
end
_nt_session_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 13664
def _nt_session_keyword
  start_index = index
  if node_cache[:session_keyword].has_key?(index)
    cached = node_cache[:session_keyword][index]
    if cached
      node_cache[:session_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[sS]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[eE]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[sS]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[sS]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[iI]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[oO]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[nN]')
                r7 = nil
              end
              s0 << r7
              if r7
                i8 = index
                if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                  r9 = true
                  @index += 1
                else
                  terminal_parse_failure('[A-Za-z0-9]')
                  r9 = nil
                end
                if r9
                  @index = i8
                  r8 = nil
                  terminal_parse_failure('[A-Za-z0-9]', true)
                else
                  @terminal_failures.pop
                  @index = i8
                  r8 = instantiate_node(SyntaxNode,input, index...index)
                end
                s0 << r8
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(SessionKeyword0)
    r0.extend(SessionKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:session_keyword][start_index] = r0

  r0
end
_nt_sessiontimezone_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 13787
def _nt_sessiontimezone_keyword
  start_index = index
  if node_cache[:sessiontimezone_keyword].has_key?(index)
    cached = node_cache[:sessiontimezone_keyword][index]
    if cached
      node_cache[:sessiontimezone_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[sS]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[eE]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[sS]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[sS]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[iI]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[oO]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[nN]')
                r7 = nil
              end
              s0 << r7
              if r7
                if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
                  r8 = true
                  @index += 1
                else
                  terminal_parse_failure('[tT]')
                  r8 = nil
                end
                s0 << r8
                if r8
                  if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
                    r9 = true
                    @index += 1
                  else
                    terminal_parse_failure('[iI]')
                    r9 = nil
                  end
                  s0 << r9
                  if r9
                    if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
                      r10 = true
                      @index += 1
                    else
                      terminal_parse_failure('[mM]')
                      r10 = nil
                    end
                    s0 << r10
                    if r10
                      if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
                        r11 = true
                        @index += 1
                      else
                        terminal_parse_failure('[eE]')
                        r11 = nil
                      end
                      s0 << r11
                      if r11
                        if has_terminal?(@regexps[gr = '\A[zZ]'] ||= Regexp.new(gr), :regexp, index)
                          r12 = true
                          @index += 1
                        else
                          terminal_parse_failure('[zZ]')
                          r12 = nil
                        end
                        s0 << r12
                        if r12
                          if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
                            r13 = true
                            @index += 1
                          else
                            terminal_parse_failure('[oO]')
                            r13 = nil
                          end
                          s0 << r13
                          if r13
                            if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
                              r14 = true
                              @index += 1
                            else
                              terminal_parse_failure('[nN]')
                              r14 = nil
                            end
                            s0 << r14
                            if r14
                              if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
                                r15 = true
                                @index += 1
                              else
                                terminal_parse_failure('[eE]')
                                r15 = nil
                              end
                              s0 << r15
                              if r15
                                i16 = index
                                if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                                  r17 = true
                                  @index += 1
                                else
                                  terminal_parse_failure('[A-Za-z0-9]')
                                  r17 = nil
                                end
                                if r17
                                  @index = i16
                                  r16 = nil
                                  terminal_parse_failure('[A-Za-z0-9]', true)
                                else
                                  @terminal_failures.pop
                                  @index = i16
                                  r16 = instantiate_node(SyntaxNode,input, index...index)
                                end
                                s0 << r16
                              end
                            end
                          end
                        end
                      end
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(SessiontimezoneKeyword0)
    r0.extend(SessiontimezoneKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:sessiontimezone_keyword][start_index] = r0

  r0
end
_nt_set_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 13990
def _nt_set_keyword
  start_index = index
  if node_cache[:set_keyword].has_key?(index)
    cached = node_cache[:set_keyword][index]
    if cached
      node_cache[:set_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[sS]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[eE]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[tT]')
        r3 = nil
      end
      s0 << r3
      if r3
        i4 = index
        if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
          r5 = true
          @index += 1
        else
          terminal_parse_failure('[A-Za-z0-9]')
          r5 = nil
        end
        if r5
          @index = i4
          r4 = nil
          terminal_parse_failure('[A-Za-z0-9]', true)
        else
          @terminal_failures.pop
          @index = i4
          r4 = instantiate_node(SyntaxNode,input, index...index)
        end
        s0 << r4
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(SetKeyword0)
    r0.extend(SetKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:set_keyword][start_index] = r0

  r0
end
_nt_share_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 14073
def _nt_share_keyword
  start_index = index
  if node_cache[:share_keyword].has_key?(index)
    cached = node_cache[:share_keyword][index]
    if cached
      node_cache[:share_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[sS]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[hH]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[hH]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[aA]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[rR]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[eE]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ShareKeyword0)
    r0.extend(ShareKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:share_keyword][start_index] = r0

  r0
end
_nt_siblings_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 14176
def _nt_siblings_keyword
  start_index = index
  if node_cache[:siblings_keyword].has_key?(index)
    cached = node_cache[:siblings_keyword][index]
    if cached
      node_cache[:siblings_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[sS]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[iI]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[bB]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[bB]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[lL]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[iI]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[nN]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[gG]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[gG]')
                r7 = nil
              end
              s0 << r7
              if r7
                if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
                  r8 = true
                  @index += 1
                else
                  terminal_parse_failure('[sS]')
                  r8 = nil
                end
                s0 << r8
                if r8
                  i9 = index
                  if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                    r10 = true
                    @index += 1
                  else
                    terminal_parse_failure('[A-Za-z0-9]')
                    r10 = nil
                  end
                  if r10
                    @index = i9
                    r9 = nil
                    terminal_parse_failure('[A-Za-z0-9]', true)
                  else
                    @terminal_failures.pop
                    @index = i9
                    r9 = instantiate_node(SyntaxNode,input, index...index)
                  end
                  s0 << r9
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(SiblingsKeyword0)
    r0.extend(SiblingsKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:siblings_keyword][start_index] = r0

  r0
end
_nt_size_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 14309
def _nt_size_keyword
  start_index = index
  if node_cache[:size_keyword].has_key?(index)
    cached = node_cache[:size_keyword][index]
    if cached
      node_cache[:size_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[sS]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[iI]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[zZ]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[zZ]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(SizeKeyword0)
    r0.extend(SizeKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:size_keyword][start_index] = r0

  r0
end
_nt_smallint_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 14402
def _nt_smallint_keyword
  start_index = index
  if node_cache[:smallint_keyword].has_key?(index)
    cached = node_cache[:smallint_keyword][index]
    if cached
      node_cache[:smallint_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[sS]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[mM]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[aA]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[lL]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[lL]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[iI]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[nN]')
                r7 = nil
              end
              s0 << r7
              if r7
                if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
                  r8 = true
                  @index += 1
                else
                  terminal_parse_failure('[tT]')
                  r8 = nil
                end
                s0 << r8
                if r8
                  i9 = index
                  if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                    r10 = true
                    @index += 1
                  else
                    terminal_parse_failure('[A-Za-z0-9]')
                    r10 = nil
                  end
                  if r10
                    @index = i9
                    r9 = nil
                    terminal_parse_failure('[A-Za-z0-9]', true)
                  else
                    @terminal_failures.pop
                    @index = i9
                    r9 = instantiate_node(SyntaxNode,input, index...index)
                  end
                  s0 << r9
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(SmallintKeyword0)
    r0.extend(SmallintKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:smallint_keyword][start_index] = r0

  r0
end
_nt_start_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 14535
def _nt_start_keyword
  start_index = index
  if node_cache[:start_keyword].has_key?(index)
    cached = node_cache[:start_keyword][index]
    if cached
      node_cache[:start_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[sS]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[tT]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[aA]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[rR]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[tT]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(StartKeyword0)
    r0.extend(StartKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:start_keyword][start_index] = r0

  r0
end
_nt_submultiset_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 14638
def _nt_submultiset_keyword
  start_index = index
  if node_cache[:submultiset_keyword].has_key?(index)
    cached = node_cache[:submultiset_keyword][index]
    if cached
      node_cache[:submultiset_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[sS]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[uU]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[bB]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[bB]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[mM]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[uU]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[lL]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[tT]')
                r7 = nil
              end
              s0 << r7
              if r7
                if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
                  r8 = true
                  @index += 1
                else
                  terminal_parse_failure('[iI]')
                  r8 = nil
                end
                s0 << r8
                if r8
                  if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
                    r9 = true
                    @index += 1
                  else
                    terminal_parse_failure('[sS]')
                    r9 = nil
                  end
                  s0 << r9
                  if r9
                    if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
                      r10 = true
                      @index += 1
                    else
                      terminal_parse_failure('[eE]')
                      r10 = nil
                    end
                    s0 << r10
                    if r10
                      if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
                        r11 = true
                        @index += 1
                      else
                        terminal_parse_failure('[tT]')
                        r11 = nil
                      end
                      s0 << r11
                      if r11
                        i12 = index
                        if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                          r13 = true
                          @index += 1
                        else
                          terminal_parse_failure('[A-Za-z0-9]')
                          r13 = nil
                        end
                        if r13
                          @index = i12
                          r12 = nil
                          terminal_parse_failure('[A-Za-z0-9]', true)
                        else
                          @terminal_failures.pop
                          @index = i12
                          r12 = instantiate_node(SyntaxNode,input, index...index)
                        end
                        s0 << r12
                      end
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(SubmultisetKeyword0)
    r0.extend(SubmultisetKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:submultiset_keyword][start_index] = r0

  r0
end
_nt_successful_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 14801
def _nt_successful_keyword
  start_index = index
  if node_cache[:successful_keyword].has_key?(index)
    cached = node_cache[:successful_keyword][index]
    if cached
      node_cache[:successful_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[sS]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[uU]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[cC]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[cC]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[eE]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[sS]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[sS]')
                r7 = nil
              end
              s0 << r7
              if r7
                if has_terminal?(@regexps[gr = '\A[fF]'] ||= Regexp.new(gr), :regexp, index)
                  r8 = true
                  @index += 1
                else
                  terminal_parse_failure('[fF]')
                  r8 = nil
                end
                s0 << r8
                if r8
                  if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
                    r9 = true
                    @index += 1
                  else
                    terminal_parse_failure('[uU]')
                    r9 = nil
                  end
                  s0 << r9
                  if r9
                    if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
                      r10 = true
                      @index += 1
                    else
                      terminal_parse_failure('[lL]')
                      r10 = nil
                    end
                    s0 << r10
                    if r10
                      i11 = index
                      if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                        r12 = true
                        @index += 1
                      else
                        terminal_parse_failure('[A-Za-z0-9]')
                        r12 = nil
                      end
                      if r12
                        @index = i11
                        r11 = nil
                        terminal_parse_failure('[A-Za-z0-9]', true)
                      else
                        @terminal_failures.pop
                        @index = i11
                        r11 = instantiate_node(SyntaxNode,input, index...index)
                      end
                      s0 << r11
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(SuccessfulKeyword0)
    r0.extend(SuccessfulKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:successful_keyword][start_index] = r0

  r0
end
_nt_synonym_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 14954
def _nt_synonym_keyword
  start_index = index
  if node_cache[:synonym_keyword].has_key?(index)
    cached = node_cache[:synonym_keyword][index]
    if cached
      node_cache[:synonym_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[sS]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[yY]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[yY]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[nN]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[oO]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[nN]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[yY]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[yY]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[mM]')
                r7 = nil
              end
              s0 << r7
              if r7
                i8 = index
                if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                  r9 = true
                  @index += 1
                else
                  terminal_parse_failure('[A-Za-z0-9]')
                  r9 = nil
                end
                if r9
                  @index = i8
                  r8 = nil
                  terminal_parse_failure('[A-Za-z0-9]', true)
                else
                  @terminal_failures.pop
                  @index = i8
                  r8 = instantiate_node(SyntaxNode,input, index...index)
                end
                s0 << r8
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(SynonymKeyword0)
    r0.extend(SynonymKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:synonym_keyword][start_index] = r0

  r0
end
_nt_sysdate_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 15077
def _nt_sysdate_keyword
  start_index = index
  if node_cache[:sysdate_keyword].has_key?(index)
    cached = node_cache[:sysdate_keyword][index]
    if cached
      node_cache[:sysdate_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[sS]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[yY]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[yY]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[sS]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[dD]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[aA]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[tT]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[eE]')
                r7 = nil
              end
              s0 << r7
              if r7
                i8 = index
                if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                  r9 = true
                  @index += 1
                else
                  terminal_parse_failure('[A-Za-z0-9]')
                  r9 = nil
                end
                if r9
                  @index = i8
                  r8 = nil
                  terminal_parse_failure('[A-Za-z0-9]', true)
                else
                  @terminal_failures.pop
                  @index = i8
                  r8 = instantiate_node(SyntaxNode,input, index...index)
                end
                s0 << r8
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(SysdateKeyword0)
    r0.extend(SysdateKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:sysdate_keyword][start_index] = r0

  r0
end
_nt_systimestamp_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 15200
def _nt_systimestamp_keyword
  start_index = index
  if node_cache[:systimestamp_keyword].has_key?(index)
    cached = node_cache[:systimestamp_keyword][index]
    if cached
      node_cache[:systimestamp_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[sS]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[yY]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[yY]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[sS]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[tT]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[iI]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[mM]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[eE]')
                r7 = nil
              end
              s0 << r7
              if r7
                if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
                  r8 = true
                  @index += 1
                else
                  terminal_parse_failure('[sS]')
                  r8 = nil
                end
                s0 << r8
                if r8
                  if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
                    r9 = true
                    @index += 1
                  else
                    terminal_parse_failure('[tT]')
                    r9 = nil
                  end
                  s0 << r9
                  if r9
                    if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
                      r10 = true
                      @index += 1
                    else
                      terminal_parse_failure('[aA]')
                      r10 = nil
                    end
                    s0 << r10
                    if r10
                      if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
                        r11 = true
                        @index += 1
                      else
                        terminal_parse_failure('[mM]')
                        r11 = nil
                      end
                      s0 << r11
                      if r11
                        if has_terminal?(@regexps[gr = '\A[pP]'] ||= Regexp.new(gr), :regexp, index)
                          r12 = true
                          @index += 1
                        else
                          terminal_parse_failure('[pP]')
                          r12 = nil
                        end
                        s0 << r12
                        if r12
                          i13 = index
                          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                            r14 = true
                            @index += 1
                          else
                            terminal_parse_failure('[A-Za-z0-9]')
                            r14 = nil
                          end
                          if r14
                            @index = i13
                            r13 = nil
                            terminal_parse_failure('[A-Za-z0-9]', true)
                          else
                            @terminal_failures.pop
                            @index = i13
                            r13 = instantiate_node(SyntaxNode,input, index...index)
                          end
                          s0 << r13
                        end
                      end
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(SystimestampKeyword0)
    r0.extend(SystimestampKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:systimestamp_keyword][start_index] = r0

  r0
end
_nt_table_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 15373
def _nt_table_keyword
  start_index = index
  if node_cache[:table_keyword].has_key?(index)
    cached = node_cache[:table_keyword][index]
    if cached
      node_cache[:table_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[tT]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[aA]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[bB]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[bB]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[lL]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[eE]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(TableKeyword0)
    r0.extend(TableKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:table_keyword][start_index] = r0

  r0
end
_nt_then_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 15476
def _nt_then_keyword
  start_index = index
  if node_cache[:then_keyword].has_key?(index)
    cached = node_cache[:then_keyword][index]
    if cached
      node_cache[:then_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[tT]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[hH]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[hH]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[eE]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[nN]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ThenKeyword0)
    r0.extend(ThenKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:then_keyword][start_index] = r0

  r0
end
_nt_ties_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 15569
def _nt_ties_keyword
  start_index = index
  if node_cache[:ties_keyword].has_key?(index)
    cached = node_cache[:ties_keyword][index]
    if cached
      node_cache[:ties_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[tT]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[iI]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[eE]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[sS]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(TiesKeyword0)
    r0.extend(TiesKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:ties_keyword][start_index] = r0

  r0
end
_nt_time_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 15662
def _nt_time_keyword
  start_index = index
  if node_cache[:time_keyword].has_key?(index)
    cached = node_cache[:time_keyword][index]
    if cached
      node_cache[:time_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[tT]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[iI]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[mM]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[mM]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(TimeKeyword0)
    r0.extend(TimeKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:time_keyword][start_index] = r0

  r0
end
_nt_to_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 15755
def _nt_to_keyword
  start_index = index
  if node_cache[:to_keyword].has_key?(index)
    cached = node_cache[:to_keyword][index]
    if cached
      node_cache[:to_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[tT]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[oO]')
      r2 = nil
    end
    s0 << r2
    if r2
      i3 = index
      if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
        r4 = true
        @index += 1
      else
        terminal_parse_failure('[A-Za-z0-9]')
        r4 = nil
      end
      if r4
        @index = i3
        r3 = nil
        terminal_parse_failure('[A-Za-z0-9]', true)
      else
        @terminal_failures.pop
        @index = i3
        r3 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r3
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ToKeyword0)
    r0.extend(ToKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:to_keyword][start_index] = r0

  r0
end
_nt_trigger_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 15828
def _nt_trigger_keyword
  start_index = index
  if node_cache[:trigger_keyword].has_key?(index)
    cached = node_cache[:trigger_keyword][index]
    if cached
      node_cache[:trigger_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[tT]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[rR]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[iI]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[gG]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[gG]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[gG]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[gG]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[eE]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[rR]')
                r7 = nil
              end
              s0 << r7
              if r7
                i8 = index
                if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                  r9 = true
                  @index += 1
                else
                  terminal_parse_failure('[A-Za-z0-9]')
                  r9 = nil
                end
                if r9
                  @index = i8
                  r8 = nil
                  terminal_parse_failure('[A-Za-z0-9]', true)
                else
                  @terminal_failures.pop
                  @index = i8
                  r8 = instantiate_node(SyntaxNode,input, index...index)
                end
                s0 << r8
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(TriggerKeyword0)
    r0.extend(TriggerKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:trigger_keyword][start_index] = r0

  r0
end
_nt_type_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 15951
def _nt_type_keyword
  start_index = index
  if node_cache[:type_keyword].has_key?(index)
    cached = node_cache[:type_keyword][index]
    if cached
      node_cache[:type_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[tT]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[yY]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[yY]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[pP]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[pP]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(TypeKeyword0)
    r0.extend(TypeKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:type_keyword][start_index] = r0

  r0
end
_nt_uid_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 16044
def _nt_uid_keyword
  start_index = index
  if node_cache[:uid_keyword].has_key?(index)
    cached = node_cache[:uid_keyword][index]
    if cached
      node_cache[:uid_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[uU]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[iI]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[dD]')
        r3 = nil
      end
      s0 << r3
      if r3
        i4 = index
        if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
          r5 = true
          @index += 1
        else
          terminal_parse_failure('[A-Za-z0-9]')
          r5 = nil
        end
        if r5
          @index = i4
          r4 = nil
          terminal_parse_failure('[A-Za-z0-9]', true)
        else
          @terminal_failures.pop
          @index = i4
          r4 = instantiate_node(SyntaxNode,input, index...index)
        end
        s0 << r4
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(UidKeyword0)
    r0.extend(UidKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:uid_keyword][start_index] = r0

  r0
end
_nt_union_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 16127
def _nt_union_keyword
  start_index = index
  if node_cache[:union_keyword].has_key?(index)
    cached = node_cache[:union_keyword][index]
    if cached
      node_cache[:union_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[uU]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[nN]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[iI]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[oO]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[nN]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(UnionKeyword0)
    r0.extend(UnionKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:union_keyword][start_index] = r0

  r0
end
_nt_unique_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 16230
def _nt_unique_keyword
  start_index = index
  if node_cache[:unique_keyword].has_key?(index)
    cached = node_cache[:unique_keyword][index]
    if cached
      node_cache[:unique_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[uU]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[nN]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[iI]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[qQ]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[qQ]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[uU]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[eE]')
              r6 = nil
            end
            s0 << r6
            if r6
              i7 = index
              if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                r8 = true
                @index += 1
              else
                terminal_parse_failure('[A-Za-z0-9]')
                r8 = nil
              end
              if r8
                @index = i7
                r7 = nil
                terminal_parse_failure('[A-Za-z0-9]', true)
              else
                @terminal_failures.pop
                @index = i7
                r7 = instantiate_node(SyntaxNode,input, index...index)
              end
              s0 << r7
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(UniqueKeyword0)
    r0.extend(UniqueKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:unique_keyword][start_index] = r0

  r0
end
_nt_update_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 16343
def _nt_update_keyword
  start_index = index
  if node_cache[:update_keyword].has_key?(index)
    cached = node_cache[:update_keyword][index]
    if cached
      node_cache[:update_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[uU]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[pP]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[pP]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[dD]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[aA]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[tT]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[eE]')
              r6 = nil
            end
            s0 << r6
            if r6
              i7 = index
              if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                r8 = true
                @index += 1
              else
                terminal_parse_failure('[A-Za-z0-9]')
                r8 = nil
              end
              if r8
                @index = i7
                r7 = nil
                terminal_parse_failure('[A-Za-z0-9]', true)
              else
                @terminal_failures.pop
                @index = i7
                r7 = instantiate_node(SyntaxNode,input, index...index)
              end
              s0 << r7
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(UpdateKeyword0)
    r0.extend(UpdateKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:update_keyword][start_index] = r0

  r0
end
_nt_user_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 16456
def _nt_user_keyword
  start_index = index
  if node_cache[:user_keyword].has_key?(index)
    cached = node_cache[:user_keyword][index]
    if cached
      node_cache[:user_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[uU]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[sS]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[eE]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[rR]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(UserKeyword0)
    r0.extend(UserKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:user_keyword][start_index] = r0

  r0
end
_nt_using_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 16549
def _nt_using_keyword
  start_index = index
  if node_cache[:using_keyword].has_key?(index)
    cached = node_cache[:using_keyword][index]
    if cached
      node_cache[:using_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[uU]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[sS]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[iI]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[nN]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[gG]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[gG]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(UsingKeyword0)
    r0.extend(UsingKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:using_keyword][start_index] = r0

  r0
end
_nt_validate_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 16652
def _nt_validate_keyword
  start_index = index
  if node_cache[:validate_keyword].has_key?(index)
    cached = node_cache[:validate_keyword][index]
    if cached
      node_cache[:validate_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[vV]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[vV]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[aA]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[lL]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[iI]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[dD]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[dD]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[aA]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[tT]')
                r7 = nil
              end
              s0 << r7
              if r7
                if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
                  r8 = true
                  @index += 1
                else
                  terminal_parse_failure('[eE]')
                  r8 = nil
                end
                s0 << r8
                if r8
                  i9 = index
                  if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                    r10 = true
                    @index += 1
                  else
                    terminal_parse_failure('[A-Za-z0-9]')
                    r10 = nil
                  end
                  if r10
                    @index = i9
                    r9 = nil
                    terminal_parse_failure('[A-Za-z0-9]', true)
                  else
                    @terminal_failures.pop
                    @index = i9
                    r9 = instantiate_node(SyntaxNode,input, index...index)
                  end
                  s0 << r9
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ValidateKeyword0)
    r0.extend(ValidateKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:validate_keyword][start_index] = r0

  r0
end
_nt_values_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 16785
def _nt_values_keyword
  start_index = index
  if node_cache[:values_keyword].has_key?(index)
    cached = node_cache[:values_keyword][index]
    if cached
      node_cache[:values_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[vV]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[vV]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[aA]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[lL]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[lL]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[uU]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[uU]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[eE]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[sS]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[sS]')
              r6 = nil
            end
            s0 << r6
            if r6
              i7 = index
              if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                r8 = true
                @index += 1
              else
                terminal_parse_failure('[A-Za-z0-9]')
                r8 = nil
              end
              if r8
                @index = i7
                r7 = nil
                terminal_parse_failure('[A-Za-z0-9]', true)
              else
                @terminal_failures.pop
                @index = i7
                r7 = instantiate_node(SyntaxNode,input, index...index)
              end
              s0 << r7
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ValuesKeyword0)
    r0.extend(ValuesKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:values_keyword][start_index] = r0

  r0
end
_nt_varchar2_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 17021
def _nt_varchar2_keyword
  start_index = index
  if node_cache[:varchar2_keyword].has_key?(index)
    cached = node_cache[:varchar2_keyword][index]
    if cached
      node_cache[:varchar2_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[vV]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[vV]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[aA]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[rR]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[cC]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[hH]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[hH]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[aA]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[rR]')
                r7 = nil
              end
              s0 << r7
              if r7
                if (match_len = has_terminal?('2', false, index))
                  r8 = true
                  @index += match_len
                else
                  terminal_parse_failure('\'2\'')
                  r8 = nil
                end
                s0 << r8
                if r8
                  i9 = index
                  if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                    r10 = true
                    @index += 1
                  else
                    terminal_parse_failure('[A-Za-z0-9]')
                    r10 = nil
                  end
                  if r10
                    @index = i9
                    r9 = nil
                    terminal_parse_failure('[A-Za-z0-9]', true)
                  else
                    @terminal_failures.pop
                    @index = i9
                    r9 = instantiate_node(SyntaxNode,input, index...index)
                  end
                  s0 << r9
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Varchar2Keyword0)
    r0.extend(Varchar2Keyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:varchar2_keyword][start_index] = r0

  r0
end
_nt_varchar_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 16898
def _nt_varchar_keyword
  start_index = index
  if node_cache[:varchar_keyword].has_key?(index)
    cached = node_cache[:varchar_keyword][index]
    if cached
      node_cache[:varchar_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[vV]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[vV]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[aA]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[rR]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[cC]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[cC]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[hH]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[hH]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[aA]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[rR]')
                r7 = nil
              end
              s0 << r7
              if r7
                i8 = index
                if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                  r9 = true
                  @index += 1
                else
                  terminal_parse_failure('[A-Za-z0-9]')
                  r9 = nil
                end
                if r9
                  @index = i8
                  r8 = nil
                  terminal_parse_failure('[A-Za-z0-9]', true)
                else
                  @terminal_failures.pop
                  @index = i8
                  r8 = instantiate_node(SyntaxNode,input, index...index)
                end
                s0 << r8
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(VarcharKeyword0)
    r0.extend(VarcharKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:varchar_keyword][start_index] = r0

  r0
end
_nt_view_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 17154
def _nt_view_keyword
  start_index = index
  if node_cache[:view_keyword].has_key?(index)
    cached = node_cache[:view_keyword][index]
    if cached
      node_cache[:view_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[vV]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[vV]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[iI]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[eE]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[wW]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[wW]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ViewKeyword0)
    r0.extend(ViewKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:view_keyword][start_index] = r0

  r0
end
_nt_wait_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 17247
def _nt_wait_keyword
  start_index = index
  if node_cache[:wait_keyword].has_key?(index)
    cached = node_cache[:wait_keyword][index]
    if cached
      node_cache[:wait_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[wW]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[wW]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[aA]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[iI]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[tT]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(WaitKeyword0)
    r0.extend(WaitKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:wait_keyword][start_index] = r0

  r0
end
_nt_when_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 17340
def _nt_when_keyword
  start_index = index
  if node_cache[:when_keyword].has_key?(index)
    cached = node_cache[:when_keyword][index]
    if cached
      node_cache[:when_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[wW]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[wW]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[hH]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[hH]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[eE]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[nN]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(WhenKeyword0)
    r0.extend(WhenKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:when_keyword][start_index] = r0

  r0
end
_nt_whenever_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 17433
def _nt_whenever_keyword
  start_index = index
  if node_cache[:whenever_keyword].has_key?(index)
    cached = node_cache[:whenever_keyword][index]
    if cached
      node_cache[:whenever_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[wW]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[wW]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[hH]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[hH]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[eE]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[nN]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[eE]')
            r5 = nil
          end
          s0 << r5
          if r5
            if has_terminal?(@regexps[gr = '\A[vV]'] ||= Regexp.new(gr), :regexp, index)
              r6 = true
              @index += 1
            else
              terminal_parse_failure('[vV]')
              r6 = nil
            end
            s0 << r6
            if r6
              if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
                r7 = true
                @index += 1
              else
                terminal_parse_failure('[eE]')
                r7 = nil
              end
              s0 << r7
              if r7
                if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
                  r8 = true
                  @index += 1
                else
                  terminal_parse_failure('[rR]')
                  r8 = nil
                end
                s0 << r8
                if r8
                  i9 = index
                  if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
                    r10 = true
                    @index += 1
                  else
                    terminal_parse_failure('[A-Za-z0-9]')
                    r10 = nil
                  end
                  if r10
                    @index = i9
                    r9 = nil
                    terminal_parse_failure('[A-Za-z0-9]', true)
                  else
                    @terminal_failures.pop
                    @index = i9
                    r9 = instantiate_node(SyntaxNode,input, index...index)
                  end
                  s0 << r9
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(WheneverKeyword0)
    r0.extend(WheneverKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:whenever_keyword][start_index] = r0

  r0
end
_nt_where_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 17566
def _nt_where_keyword
  start_index = index
  if node_cache[:where_keyword].has_key?(index)
    cached = node_cache[:where_keyword][index]
    if cached
      node_cache[:where_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[wW]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[wW]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[hH]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[hH]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[eE]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[rR]')
          r4 = nil
        end
        s0 << r4
        if r4
          if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
            r5 = true
            @index += 1
          else
            terminal_parse_failure('[eE]')
            r5 = nil
          end
          s0 << r5
          if r5
            i6 = index
            if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r7 = true
              @index += 1
            else
              terminal_parse_failure('[A-Za-z0-9]')
              r7 = nil
            end
            if r7
              @index = i6
              r6 = nil
              terminal_parse_failure('[A-Za-z0-9]', true)
            else
              @terminal_failures.pop
              @index = i6
              r6 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r6
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(WhereKeyword0)
    r0.extend(WhereKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:where_keyword][start_index] = r0

  r0
end
_nt_with_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 17669
def _nt_with_keyword
  start_index = index
  if node_cache[:with_keyword].has_key?(index)
    cached = node_cache[:with_keyword][index]
    if cached
      node_cache[:with_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[wW]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[wW]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[iI]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[iI]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[tT]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[tT]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[hH]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[hH]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(WithKeyword0)
    r0.extend(WithKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:with_keyword][start_index] = r0

  r0
end
_nt_year_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 17762
def _nt_year_keyword
  start_index = index
  if node_cache[:year_keyword].has_key?(index)
    cached = node_cache[:year_keyword][index]
    if cached
      node_cache[:year_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[yY]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[yY]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[eE]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[aA]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[aA]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[rR]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[rR]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(YearKeyword0)
    r0.extend(YearKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:year_keyword][start_index] = r0

  r0
end
_nt_zone_keyword() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 17855
def _nt_zone_keyword
  start_index = index
  if node_cache[:zone_keyword].has_key?(index)
    cached = node_cache[:zone_keyword][index]
    if cached
      node_cache[:zone_keyword][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(@regexps[gr = '\A[zZ]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[zZ]')
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?(@regexps[gr = '\A[oO]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[oO]')
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(@regexps[gr = '\A[nN]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[nN]')
        r3 = nil
      end
      s0 << r3
      if r3
        if has_terminal?(@regexps[gr = '\A[eE]'] ||= Regexp.new(gr), :regexp, index)
          r4 = true
          @index += 1
        else
          terminal_parse_failure('[eE]')
          r4 = nil
        end
        s0 << r4
        if r4
          i5 = index
          if has_terminal?(@regexps[gr = '\A[A-Za-z0-9]'] ||= Regexp.new(gr), :regexp, index)
            r6 = true
            @index += 1
          else
            terminal_parse_failure('[A-Za-z0-9]')
            r6 = nil
          end
          if r6
            @index = i5
            r5 = nil
            terminal_parse_failure('[A-Za-z0-9]', true)
          else
            @terminal_failures.pop
            @index = i5
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ZoneKeyword0)
    r0.extend(ZoneKeyword1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:zone_keyword][start_index] = r0

  r0
end
root() click to toggle source
# File lib/oracle-sql-parser/grammar/reserved_word.rb, line 11
def root
  @root ||= :keyword
end