module OracleSqlParser::Grammar::Grammar

Public Instance Methods

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

  r0 = _nt_ident
  r0.extend(CAlias0)
  r0.extend(CAlias0)

  node_cache[:c_alias][start_index] = r0

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

  r0 = _nt_ident
  r0.extend(ColumnName0)
  r0.extend(ColumnName0)

  node_cache[:column_name][start_index] = r0

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

  i0, s0 = index, []
  r1 = _nt_current_of_keyword
  s0 << r1
  if r1
    r3 = _nt_space
    if r3
      r2 = r3
    else
      r2 = instantiate_node(SyntaxNode,input, index...index)
    end
    s0 << r2
    if r2
      r4 = _nt_cursor_name
      s0 << r4
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(CurrentOf0)
    r0.extend(CurrentOf1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:current_of][start_index] = r0

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

  r0 = _nt_ident
  r0.extend(CursorName0)
  r0.extend(CursorName0)

  node_cache[:cursor_name][start_index] = r0

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

  i0, s0 = index, []
  if (match_len = has_terminal?('/*+', false, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('\'/*+\'')
    r1 = nil
  end
  s0 << r1
  if r1
    if (match_len = has_terminal?('*/', false, index))
      r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('\'*/\'')
      r2 = nil
    end
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Hint0)
    r0.extend(Hint1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:hint][start_index] = r0

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

  i0, s0 = index, []
  i1 = index
  r2 = _nt_keyword
  if r2
    @index = i1
    r1 = nil
  else
    @index = i1
    r1 = instantiate_node(SyntaxNode,input, index...index)
  end
  s0 << r1
  if r1
    i3 = index
    i4, s4 = index, []
    r5 = _nt_ident_content_with_double_quote
    s4 << r5
    if s4.last
      r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
      r4.extend(Ident0)
    else
      @index = i4
      r4 = nil
    end
    if r4
      r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
      r3 = r4
    else
      i6, s6 = index, []
      r7 = _nt_ident_content
      s6 << r7
      if s6.last
        r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
        r6.extend(Ident1)
      else
        @index = i6
        r6 = nil
      end
      if r6
        r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
        r3 = r6
      else
        @index = i3
        r3 = nil
      end
    end
    s0 << r3
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Ident2)
    r0.extend(Ident3)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:ident][start_index] = r0

  r0
end
_nt_ident_content() click to toggle source
# File lib/oracle-sql-parser/grammar/grammar.rb, line 197
def _nt_ident_content
  start_index = index
  if node_cache[:ident_content].has_key?(index)
    cached = node_cache[:ident_content][index]
    if cached
      node_cache[:ident_content][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[a-zA-Z]'] ||= Regexp.new(gr), :regexp, index)
    r1 = true
    @index += 1
  else
    terminal_parse_failure('[a-zA-Z]')
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      if has_terminal?(@regexps[gr = '\A[a-zA-Z0-9_]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[a-zA-Z0-9_]')
        r3 = nil
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(IdentContent0)
    r0.extend(IdentContent1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:ident_content][start_index] = r0

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

  i0, s0 = index, []
  if (match_len = has_terminal?('"', false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('\'"\'')
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      if has_terminal?(@regexps[gr = '\A[^"]'] ||= Regexp.new(gr), :regexp, index)
        r3 = true
        @index += 1
      else
        terminal_parse_failure('[^"]')
        r3 = nil
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
    if r2
      if (match_len = has_terminal?('"', false, index))
        r4 = true
        @index += match_len
      else
        terminal_parse_failure('\'"\'')
        r4 = nil
      end
      s0 << r4
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(IdentContentWithDoubleQuote0)
    r0.extend(IdentContentWithDoubleQuote1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:ident_content_with_double_quote][start_index] = r0

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

  i0, s0 = index, []
  if (match_len = has_terminal?('-', false, index))
    r2 = true
    @index += match_len
  else
    terminal_parse_failure('\'-\'')
    r2 = nil
  end
  if r2
    r1 = r2
  else
    r1 = instantiate_node(SyntaxNode,input, index...index)
  end
  s0 << r1
  if r1
    s3, i3 = [], index
    loop do
      if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
        r4 = true
        @index += 1
      else
        terminal_parse_failure('[0-9]')
        r4 = nil
      end
      if r4
        s3 << r4
      else
        break
      end
    end
    if s3.empty?
      @index = i3
      r3 = nil
    else
      r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
    end
    s0 << r3
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Integer0)
    r0.extend(Integer1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:integer][start_index] = r0

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

  i0, s0 = index, []
  if (match_len = has_terminal?('-', false, index))
    r2 = true
    @index += match_len
  else
    terminal_parse_failure('\'-\'')
    r2 = nil
  end
  if r2
    r1 = r2
  else
    r1 = instantiate_node(SyntaxNode,input, index...index)
  end
  s0 << r1
  if r1
    s3, i3 = [], index
    loop do
      if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
        r4 = true
        @index += 1
      else
        terminal_parse_failure('[0-9]')
        r4 = nil
      end
      if r4
        s3 << r4
      else
        break
      end
    end
    if s3.empty?
      @index = i3
      r3 = nil
    else
      r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
    end
    s0 << r3
    if r3
      i6, s6 = index, []
      if has_terminal?(@regexps[gr = '\A[.]'] ||= Regexp.new(gr), :regexp, index)
        r7 = true
        @index += 1
      else
        terminal_parse_failure('[.]')
        r7 = nil
      end
      s6 << r7
      if r7
        s8, i8 = [], index
        loop do
          if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
            r9 = true
            @index += 1
          else
            terminal_parse_failure('[0-9]')
            r9 = nil
          end
          if r9
            s8 << r9
          else
            break
          end
        end
        if s8.empty?
          @index = i8
          r8 = nil
        else
          r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
        end
        s6 << r8
      end
      if s6.last
        r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
        r6.extend(NumberLiteral0)
      else
        @index = i6
        r6 = nil
      end
      if r6
        r5 = r6
      else
        r5 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r5
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(NumberLiteral1)
    r0.extend(NumberLiteral2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:number_literal][start_index] = r0

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

  r0 = _nt_ident
  r0.extend(PackageName0)
  r0.extend(PackageName0)

  node_cache[:package_name][start_index] = r0

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

  r0 = _nt_integer
  r0.extend(Position0)
  r0.extend(Position0)

  node_cache[:position][start_index] = r0

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

  r0 = _nt_ident
  r0.extend(ProcedureName0)
  r0.extend(ProcedureName0)

  node_cache[:procedure_name][start_index] = r0

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

  r0 = _nt_ident
  r0.extend(SchemaName0)
  r0.extend(SchemaName0)

  node_cache[:schema_name][start_index] = r0

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

  i0, s0 = index, []
  r1 = _nt_ident
  s0 << r1
  if r1
    r3 = _nt_space
    if r3
      r2 = r3
    else
      r2 = instantiate_node(SyntaxNode,input, index...index)
    end
    s0 << r2
    if r2
      if (match_len = has_terminal?('.', false, index))
        r4 = true
        @index += match_len
      else
        terminal_parse_failure('\'.\'')
        r4 = nil
      end
      s0 << r4
      if r4
        r6 = _nt_space
        if r6
          r5 = r6
        else
          r5 = instantiate_node(SyntaxNode,input, index...index)
        end
        s0 << r5
        if r5
          i7 = index
          r8 = _nt_currval_keyword
          if r8
            r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
            r7 = r8
          else
            r9 = _nt_nextval_keyword
            if r9
              r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
              r7 = r9
            else
              @index = i7
              r7 = nil
            end
          end
          s0 << r7
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Sequence0)
    r0.extend(Sequence1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:sequence][start_index] = r0

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

  s0, i0 = [], index
  loop do
    if has_terminal?(@regexps[gr = '\A[ \\n]'] ||= Regexp.new(gr), :regexp, index)
      r1 = true
      @index += 1
    else
      terminal_parse_failure('[ \\n]')
      r1 = nil
    end
    if r1
      s0 << r1
    else
      break
    end
  end
  if s0.empty?
    @index = i0
    r0 = nil
  else
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
  end

  node_cache[:space][start_index] = r0

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

  i0, s0 = index, []
  i1 = index
  r2 = _nt_select_statement
  if r2
    r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
    r1 = r2
  else
    r3 = _nt_update_statement
    if r3
      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
      r1 = r3
    else
      r4 = _nt_insert_statement
      if r4
        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
        r1 = r4
      else
        r5 = _nt_delete_statement
        if r5
          r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
          r1 = r5
        else
          @index = i1
          r1 = nil
        end
      end
    end
  end
  s0 << r1
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Sql0)
    r0.extend(Sql1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:sql][start_index] = r0

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

  r0 = _nt_ident
  r0.extend(TAlias0)
  r0.extend(TAlias0)

  node_cache[:t_alias][start_index] = r0

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

  r0 = _nt_ident
  r0.extend(TableName0)
  r0.extend(TableName0)

  node_cache[:table_name][start_index] = r0

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

  i0, s0 = index, []
  i1 = index
  i2, s2 = index, []
  i3 = index
  if (match_len = has_terminal?('(', false, index))
    r4 = true
    @index += match_len
  else
    terminal_parse_failure('\'(\'')
    r4 = nil
  end
  if r4
    @index = i3
    r3 = instantiate_node(SyntaxNode,input, index...index)
  else
    @index = i3
    r3 = nil
  end
  s2 << r3
  if r3
    r6 = _nt_space
    if r6
      r5 = r6
    else
      r5 = instantiate_node(SyntaxNode,input, index...index)
    end
    s2 << r5
    if r5
      r7 = _nt_subquery
      s2 << r7
    end
  end
  if s2.last
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    r2.extend(TableReference0)
  else
    @index = i2
    r2 = nil
  end
  if r2
    r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
    r1 = r2
  else
    i8, s8 = index, []
    r9 = _nt_schema_name
    s8 << r9
    if r9
      if (match_len = has_terminal?('.', false, index))
        r10 = true
        @index += match_len
      else
        terminal_parse_failure('\'.\'')
        r10 = nil
      end
      s8 << r10
      if r10
        r11 = _nt_table_name
        s8 << r11
      end
    end
    if s8.last
      r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
      r8.extend(TableReference1)
    else
      @index = i8
      r8 = nil
    end
    if r8
      r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
      r1 = r8
    else
      i12, s12 = index, []
      r13 = _nt_table_name
      s12 << r13
      if s12.last
        r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
        r12.extend(TableReference2)
      else
        @index = i12
        r12 = nil
      end
      if r12
        r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
        r1 = r12
      else
        @index = i1
        r1 = nil
      end
    end
  end
  s0 << r1
  if r1
    i15, s15 = index, []
    if (match_len = has_terminal?('@', false, index))
      r16 = true
      @index += match_len
    else
      terminal_parse_failure('\'@\'')
      r16 = nil
    end
    s15 << r16
    if r16
      r17 = _nt_dblink
      s15 << r17
    end
    if s15.last
      r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
      r15.extend(TableReference3)
    else
      @index = i15
      r15 = nil
    end
    if r15
      r14 = r15
    else
      r14 = instantiate_node(SyntaxNode,input, index...index)
    end
    s0 << r14
    if r14
      i19, s19 = index, []
      r20 = _nt_space
      s19 << r20
      if r20
        r21 = _nt_t_alias
        s19 << r21
      end
      if s19.last
        r19 = instantiate_node(SyntaxNode,input, i19...index, s19)
        r19.extend(TableReference4)
      else
        @index = i19
        r19 = nil
      end
      if r19
        r18 = r19
      else
        r18 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r18
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(TableReference5)
    r0.extend(TableReference6)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:table_reference][start_index] = r0

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

  i0, s0 = index, []
  if (match_len = has_terminal?("'", false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('"\'"')
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      i3 = index
      if (match_len = has_terminal?("\\'", false, index))
        r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
        @index += match_len
      else
        terminal_parse_failure('"\\\\\'"')
        r4 = nil
      end
      if r4
        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
        r3 = r4
      else
        i5, s5 = index, []
        i6 = index
        if (match_len = has_terminal?("'", false, index))
          r7 = true
          @index += match_len
        else
          terminal_parse_failure('"\'"')
          r7 = nil
        end
        if r7
          @index = i6
          r6 = nil
          terminal_parse_failure('"\'"', true)
        else
          @terminal_failures.pop
          @index = i6
          r6 = instantiate_node(SyntaxNode,input, index...index)
        end
        s5 << r6
        if r6
          if index < input_length
            r8 = true
            @index += 1
          else
            terminal_parse_failure("any character")
            r8 = nil
          end
          s5 << r8
        end
        if s5.last
          r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
          r5.extend(TextLiteral0)
        else
          @index = i5
          r5 = nil
        end
        if r5
          r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
          r3 = r5
        else
          @index = i3
          r3 = nil
        end
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
    if r2
      if (match_len = has_terminal?("'", false, index))
        r9 = true
        @index += match_len
      else
        terminal_parse_failure('"\'"')
        r9 = nil
      end
      s0 << r9
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(TextLiteral1)
    r0.extend(TextLiteral2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:text_literal][start_index] = r0

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