module Rasti::DB::NQL::Syntax

Public Instance Methods

_nt_any_character() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 2195
def _nt_any_character
  start_index = index
  if node_cache[:any_character].has_key?(index)
    cached = node_cache[:any_character][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_valid_character
  if r1
    r0 = r1
  else
    r2 = _nt_reserved_character
    if r2
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:any_character][start_index] = r0

  r0
end
_nt_argument() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 1241
def _nt_argument
  start_index = index
  if node_cache[:argument].has_key?(index)
    cached = node_cache[:argument][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_array
  if r1
    r0 = r1
  else
    r2 = _nt_basic
    if r2
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:argument][start_index] = r0

  r0
end
_nt_array() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 1335
def _nt_array
  start_index = index
  if node_cache[:array].has_key?(index)
    cached = node_cache[:array][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?('[', false, index)
    r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
    @index += 1
  else
    terminal_parse_failure('[')
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_space
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
    if r2
      i4 = index
      r5 = _nt_array_content
      if r5
        r4 = r5
      else
        r6 = _nt_basic
        if r6
          r4 = r6
        else
          @index = i4
          r4 = nil
        end
      end
      s0 << r4
      if r4
        s7, i7 = [], index
        loop do
          r8 = _nt_space
          if r8
            s7 << r8
          else
            break
          end
        end
        r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
        s0 << r7
        if r7
          if has_terminal?(']', false, index)
            r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
            @index += 1
          else
            terminal_parse_failure(']')
            r9 = nil
          end
          s0 << r9
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(Nodes::Constants::Array,input, i0...index, s0)
    r0.extend(Array0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:array][start_index] = r0

  r0
end
_nt_array_content() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 1430
def _nt_array_content
  start_index = index
  if node_cache[:array_content].has_key?(index)
    cached = node_cache[:array_content][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_basic
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_space
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
    if r2
      if has_terminal?(',', false, index)
        r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure(',')
        r4 = nil
      end
      s0 << r4
      if r4
        s5, i5 = [], index
        loop do
          r6 = _nt_space
          if r6
            s5 << r6
          else
            break
          end
        end
        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
        s0 << r5
        if r5
          i7 = index
          r8 = _nt_array_content
          if r8
            r7 = r8
          else
            r9 = _nt_basic
            if r9
              r7 = r9
            else
              @index = i7
              r7 = nil
            end
          end
          s0 << r7
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(Nodes::ArrayContent,input, i0...index, s0)
    r0.extend(ArrayContent0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:array_content][start_index] = r0

  r0
end
_nt_attribute() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 453
def _nt_attribute
  start_index = index
  if node_cache[:attribute].has_key?(index)
    cached = node_cache[:attribute][index]
    if cached
      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
    i2, s2 = index, []
    r3 = _nt_attribute_name
    s2 << r3
    if r3
      if has_terminal?('.', false, index)
        r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure('.')
        r4 = nil
      end
      s2 << r4
    end
    if s2.last
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
      r2.extend(Attribute0)
    else
      @index = i2
      r2 = nil
    end
    if r2
      s1 << r2
    else
      break
    end
  end
  r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
  s0 << r1
  if r1
    r5 = _nt_attribute_name
    s0 << r5
  end
  if s0.last
    r0 = instantiate_node(Nodes::Attribute,input, i0...index, s0)
    r0.extend(Attribute1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:attribute][start_index] = r0

  r0
end
_nt_attribute_name() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 1532
def _nt_attribute_name
  start_index = index
  if node_cache[:attribute_name].has_key?(index)
    cached = node_cache[:attribute_name][index]
    if cached
      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?('\G[a-z_]', true, index)
      r1 = true
      @index += 1
    else
      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[:attribute_name][start_index] = r0

  r0
end
_nt_basic() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 1271
def _nt_basic
  start_index = index
  if node_cache[:basic].has_key?(index)
    cached = node_cache[:basic][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_boolean
  if r1
    r0 = r1
  else
    r2 = _nt_time
    if r2
      r0 = r2
    else
      r3 = _nt_float
      if r3
        r0 = r3
      else
        r4 = _nt_integer
        if r4
          r0 = r4
        else
          r5 = _nt_literal_string
          if r5
            r0 = r5
          else
            r6 = _nt_string
            if r6
              r0 = r6
            else
              @index = i0
              r0 = nil
            end
          end
        end
      end
    end
  end

  node_cache[:basic][start_index] = r0

  r0
end
_nt_boolean() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 2248
def _nt_boolean
  start_index = index
  if node_cache[:boolean].has_key?(index)
    cached = node_cache[:boolean][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_true
  if r1
    r0 = r1
  else
    r2 = _nt_false
    if r2
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:boolean][start_index] = r0

  r0
end
_nt_comparison() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 371
def _nt_comparison
  start_index = index
  if node_cache[:comparison].has_key?(index)
    cached = node_cache[:comparison][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_comparison_not_include
  if r1
    r0 = r1
  else
    r2 = _nt_comparison_include
    if r2
      r0 = r2
    else
      r3 = _nt_comparison_like
      if r3
        r0 = r3
      else
        r4 = _nt_comparison_greater_than_or_equal
        if r4
          r0 = r4
        else
          r5 = _nt_comparison_less_than_or_equal
          if r5
            r0 = r5
          else
            r6 = _nt_comparison_greater_than
            if r6
              r0 = r6
            else
              r7 = _nt_comparison_less_than
              if r7
                r0 = r7
              else
                r8 = _nt_comparison_not_equal
                if r8
                  r0 = r8
                else
                  r9 = _nt_comparison_equal
                  if r9
                    r0 = r9
                  else
                    @index = i0
                    r0 = nil
                  end
                end
              end
            end
          end
        end
      end
    end
  end

  node_cache[:comparison][start_index] = r0

  r0
end
_nt_comparison_equal() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 1174
def _nt_comparison_equal
  start_index = index
  if node_cache[:comparison_equal].has_key?(index)
    cached = node_cache[:comparison_equal][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_attribute
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_space
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
    if r2
      if has_terminal?('=', false, index)
        r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure('=')
        r4 = nil
      end
      s0 << r4
      if r4
        s5, i5 = [], index
        loop do
          r6 = _nt_space
          if r6
            s5 << r6
          else
            break
          end
        end
        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
        s0 << r5
        if r5
          r7 = _nt_argument
          s0 << r7
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(Nodes::Comparisons::Equal,input, i0...index, s0)
    r0.extend(ComparisonEqual0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:comparison_equal][start_index] = r0

  r0
end
_nt_comparison_greater_than() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 769
def _nt_comparison_greater_than
  start_index = index
  if node_cache[:comparison_greater_than].has_key?(index)
    cached = node_cache[:comparison_greater_than][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_attribute
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_space
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
    if r2
      if has_terminal?('>', false, index)
        r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure('>')
        r4 = nil
      end
      s0 << r4
      if r4
        s5, i5 = [], index
        loop do
          r6 = _nt_space
          if r6
            s5 << r6
          else
            break
          end
        end
        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
        s0 << r5
        if r5
          r7 = _nt_argument
          s0 << r7
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(Nodes::Comparisons::GreaterThan,input, i0...index, s0)
    r0.extend(ComparisonGreaterThan0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:comparison_greater_than][start_index] = r0

  r0
end
_nt_comparison_greater_than_or_equal() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 850
def _nt_comparison_greater_than_or_equal
  start_index = index
  if node_cache[:comparison_greater_than_or_equal].has_key?(index)
    cached = node_cache[:comparison_greater_than_or_equal][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_attribute
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_space
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
    if r2
      if has_terminal?('>=', false, index)
        r4 = instantiate_node(SyntaxNode,input, index...(index + 2))
        @index += 2
      else
        terminal_parse_failure('>=')
        r4 = nil
      end
      s0 << r4
      if r4
        s5, i5 = [], index
        loop do
          r6 = _nt_space
          if r6
            s5 << r6
          else
            break
          end
        end
        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
        s0 << r5
        if r5
          r7 = _nt_argument
          s0 << r7
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(Nodes::Comparisons::GreaterThanOrEqual,input, i0...index, s0)
    r0.extend(ComparisonGreaterThanOrEqual0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:comparison_greater_than_or_equal][start_index] = r0

  r0
end
_nt_comparison_include() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 526
def _nt_comparison_include
  start_index = index
  if node_cache[:comparison_include].has_key?(index)
    cached = node_cache[:comparison_include][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_attribute
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_space
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
    if r2
      if has_terminal?(':', false, index)
        r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure(':')
        r4 = nil
      end
      s0 << r4
      if r4
        s5, i5 = [], index
        loop do
          r6 = _nt_space
          if r6
            s5 << r6
          else
            break
          end
        end
        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
        s0 << r5
        if r5
          r7 = _nt_argument
          s0 << r7
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(Nodes::Comparisons::Include,input, i0...index, s0)
    r0.extend(ComparisonInclude0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:comparison_include][start_index] = r0

  r0
end
_nt_comparison_less_than() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 931
def _nt_comparison_less_than
  start_index = index
  if node_cache[:comparison_less_than].has_key?(index)
    cached = node_cache[:comparison_less_than][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_attribute
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_space
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
    if r2
      if has_terminal?('<', false, index)
        r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure('<')
        r4 = nil
      end
      s0 << r4
      if r4
        s5, i5 = [], index
        loop do
          r6 = _nt_space
          if r6
            s5 << r6
          else
            break
          end
        end
        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
        s0 << r5
        if r5
          r7 = _nt_argument
          s0 << r7
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(Nodes::Comparisons::LessThan,input, i0...index, s0)
    r0.extend(ComparisonLessThan0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:comparison_less_than][start_index] = r0

  r0
end
_nt_comparison_less_than_or_equal() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 1012
def _nt_comparison_less_than_or_equal
  start_index = index
  if node_cache[:comparison_less_than_or_equal].has_key?(index)
    cached = node_cache[:comparison_less_than_or_equal][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_attribute
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_space
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
    if r2
      if has_terminal?('<=', false, index)
        r4 = instantiate_node(SyntaxNode,input, index...(index + 2))
        @index += 2
      else
        terminal_parse_failure('<=')
        r4 = nil
      end
      s0 << r4
      if r4
        s5, i5 = [], index
        loop do
          r6 = _nt_space
          if r6
            s5 << r6
          else
            break
          end
        end
        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
        s0 << r5
        if r5
          r7 = _nt_argument
          s0 << r7
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(Nodes::Comparisons::LessThanOrEqual,input, i0...index, s0)
    r0.extend(ComparisonLessThanOrEqual0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:comparison_less_than_or_equal][start_index] = r0

  r0
end
_nt_comparison_like() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 688
def _nt_comparison_like
  start_index = index
  if node_cache[:comparison_like].has_key?(index)
    cached = node_cache[:comparison_like][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_attribute
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_space
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
    if r2
      if has_terminal?('~', false, index)
        r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure('~')
        r4 = nil
      end
      s0 << r4
      if r4
        s5, i5 = [], index
        loop do
          r6 = _nt_space
          if r6
            s5 << r6
          else
            break
          end
        end
        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
        s0 << r5
        if r5
          r7 = _nt_argument
          s0 << r7
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(Nodes::Comparisons::Like,input, i0...index, s0)
    r0.extend(ComparisonLike0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:comparison_like][start_index] = r0

  r0
end
_nt_comparison_not_equal() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 1093
def _nt_comparison_not_equal
  start_index = index
  if node_cache[:comparison_not_equal].has_key?(index)
    cached = node_cache[:comparison_not_equal][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_attribute
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_space
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
    if r2
      if has_terminal?('!=', false, index)
        r4 = instantiate_node(SyntaxNode,input, index...(index + 2))
        @index += 2
      else
        terminal_parse_failure('!=')
        r4 = nil
      end
      s0 << r4
      if r4
        s5, i5 = [], index
        loop do
          r6 = _nt_space
          if r6
            s5 << r6
          else
            break
          end
        end
        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
        s0 << r5
        if r5
          r7 = _nt_argument
          s0 << r7
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(Nodes::Comparisons::NotEqual,input, i0...index, s0)
    r0.extend(ComparisonNotEqual0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:comparison_not_equal][start_index] = r0

  r0
end
_nt_comparison_not_include() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 607
def _nt_comparison_not_include
  start_index = index
  if node_cache[:comparison_not_include].has_key?(index)
    cached = node_cache[:comparison_not_include][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_attribute
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_space
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
    if r2
      if has_terminal?('!:', false, index)
        r4 = instantiate_node(SyntaxNode,input, index...(index + 2))
        @index += 2
      else
        terminal_parse_failure('!:')
        r4 = nil
      end
      s0 << r4
      if r4
        s5, i5 = [], index
        loop do
          r6 = _nt_space
          if r6
            s5 << r6
          else
            break
          end
        end
        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
        s0 << r5
        if r5
          r7 = _nt_argument
          s0 << r7
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(Nodes::Comparisons::NotInclude,input, i0...index, s0)
    r0.extend(ComparisonNotInclude0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:comparison_not_include][start_index] = r0

  r0
end
_nt_conjunction() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 208
def _nt_conjunction
  start_index = index
  if node_cache[:conjunction].has_key?(index)
    cached = node_cache[:conjunction][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_statement
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_space
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
    if r2
      if has_terminal?('&', false, index)
        r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure('&')
        r4 = nil
      end
      s0 << r4
      if r4
        s5, i5 = [], index
        loop do
          r6 = _nt_space
          if r6
            s5 << r6
          else
            break
          end
        end
        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
        s0 << r5
        if r5
          i7 = index
          r8 = _nt_conjunction
          if r8
            r7 = r8
          else
            r9 = _nt_statement
            if r9
              r7 = r9
            else
              @index = i7
              r7 = nil
            end
          end
          s0 << r7
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(Nodes::Conjunction,input, i0...index, s0)
    r0.extend(Conjunction0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:conjunction][start_index] = r0

  r0
end
_nt_date() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 1846
def _nt_date
  start_index = index
  if node_cache[:date].has_key?(index)
    cached = node_cache[:date][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  i1, s1 = index, []
  r2 = _nt_digit
  s1 << r2
  if r2
    r3 = _nt_digit
    s1 << r3
    if r3
      r4 = _nt_digit
      s1 << r4
      if r4
        r5 = _nt_digit
        s1 << r5
      end
    end
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(Date0)
  else
    @index = i1
    r1 = nil
  end
  s0 << r1
  if r1
    if has_terminal?('-', false, index)
      r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
      @index += 1
    else
      terminal_parse_failure('-')
      r6 = nil
    end
    s0 << r6
    if r6
      i7, s7 = index, []
      r8 = _nt_digit
      s7 << r8
      if r8
        r9 = _nt_digit
        s7 << r9
      end
      if s7.last
        r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
        r7.extend(Date1)
      else
        @index = i7
        r7 = nil
      end
      s0 << r7
      if r7
        if has_terminal?('-', false, index)
          r10 = instantiate_node(SyntaxNode,input, index...(index + 1))
          @index += 1
        else
          terminal_parse_failure('-')
          r10 = nil
        end
        s0 << r10
        if r10
          i11, s11 = index, []
          r12 = _nt_digit
          s11 << r12
          if r12
            r13 = _nt_digit
            s11 << r13
          end
          if s11.last
            r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
            r11.extend(Date2)
          else
            @index = i11
            r11 = nil
          end
          s0 << r11
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Date3)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:date][start_index] = r0

  r0
end
_nt_digit() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 2430
def _nt_digit
  start_index = index
  if node_cache[:digit].has_key?(index)
    cached = node_cache[:digit][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  if has_terminal?('\G[0-9]', true, index)
    r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
    @index += 1
  else
    r0 = nil
  end

  node_cache[:digit][start_index] = r0

  r0
end
_nt_disjunction() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 119
def _nt_disjunction
  start_index = index
  if node_cache[:disjunction].has_key?(index)
    cached = node_cache[:disjunction][index]
    if cached
      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_conjunction
  if r2
    r1 = r2
  else
    r3 = _nt_statement
    if r3
      r1 = r3
    else
      @index = i1
      r1 = nil
    end
  end
  s0 << r1
  if r1
    s4, i4 = [], index
    loop do
      r5 = _nt_space
      if r5
        s4 << r5
      else
        break
      end
    end
    r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
    s0 << r4
    if r4
      if has_terminal?('|', false, index)
        r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure('|')
        r6 = nil
      end
      s0 << r6
      if r6
        s7, i7 = [], index
        loop do
          r8 = _nt_space
          if r8
            s7 << r8
          else
            break
          end
        end
        r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
        s0 << r7
        if r7
          r9 = _nt_proposition
          s0 << r9
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(Nodes::Disjunction,input, i0...index, s0)
    r0.extend(Disjunction0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:disjunction][start_index] = r0

  r0
end
_nt_false() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 2302
def _nt_false
  start_index = index
  if node_cache[:false].has_key?(index)
    cached = node_cache[:false][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  if has_terminal?('false', false, index)
    r0 = instantiate_node(Nodes::Constants::False,input, index...(index + 5))
    @index += 5
  else
    terminal_parse_failure('false')
    r0 = nil
  end

  node_cache[:false][start_index] = r0

  r0
end
_nt_float() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 2329
def _nt_float
  start_index = index
  if node_cache[:float].has_key?(index)
    cached = node_cache[:float][index]
    if cached
      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
    r2 = _nt_digit
    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
    if has_terminal?('.', false, index)
      r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
      @index += 1
    else
      terminal_parse_failure('.')
      r3 = nil
    end
    s0 << r3
    if r3
      s4, i4 = [], index
      loop do
        r5 = _nt_digit
        if r5
          s4 << r5
        else
          break
        end
      end
      if s4.empty?
        @index = i4
        r4 = nil
      else
        r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
      end
      s0 << r4
    end
  end
  if s0.last
    r0 = instantiate_node(Nodes::Constants::Float,input, i0...index, s0)
    r0.extend(Float0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:float][start_index] = r0

  r0
end
_nt_integer() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 2398
def _nt_integer
  start_index = index
  if node_cache[:integer].has_key?(index)
    cached = node_cache[:integer][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  s0, i0 = [], index
  loop do
    r1 = _nt_digit
    if r1
      s0 << r1
    else
      break
    end
  end
  if s0.empty?
    @index = i0
    r0 = nil
  else
    r0 = instantiate_node(Nodes::Constants::Integer,input, i0...index, s0)
  end

  node_cache[:integer][start_index] = r0

  r0
end
_nt_literal_string() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 2102
def _nt_literal_string
  start_index = index
  if node_cache[:literal_string].has_key?(index)
    cached = node_cache[:literal_string][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?('"', false, index)
    r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
    @index += 1
  else
    terminal_parse_failure('"')
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      r3 = _nt_any_character
      if r3
        s2 << r3
      else
        break
      end
    end
    if s2.empty?
      @index = i2
      r2 = nil
    else
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    end
    s0 << r2
    if r2
      if has_terminal?('"', false, index)
        r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure('"')
        r4 = nil
      end
      s0 << r4
    end
  end
  if s0.last
    r0 = instantiate_node(Nodes::Constants::LiteralString,input, i0...index, s0)
    r0.extend(LiteralString0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:literal_string][start_index] = r0

  r0
end
_nt_parenthesis_sentence() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 324
def _nt_parenthesis_sentence
  start_index = index
  if node_cache[:parenthesis_sentence].has_key?(index)
    cached = node_cache[:parenthesis_sentence][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?('(', false, index)
    r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
    @index += 1
  else
    terminal_parse_failure('(')
    r1 = nil
  end
  s0 << r1
  if r1
    r2 = _nt_sentence
    s0 << r2
    if r2
      if has_terminal?(')', false, index)
        r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure(')')
        r3 = nil
      end
      s0 << r3
    end
  end
  if s0.last
    r0 = instantiate_node(Nodes::ParenthesisSentence,input, i0...index, s0)
    r0.extend(ParenthesisSentence0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:parenthesis_sentence][start_index] = r0

  r0
end
_nt_proposition() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 74
def _nt_proposition
  start_index = index
  if node_cache[:proposition].has_key?(index)
    cached = node_cache[:proposition][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_disjunction
  if r1
    r0 = r1
  else
    r2 = _nt_conjunction
    if r2
      r0 = r2
    else
      r3 = _nt_statement
      if r3
        r0 = r3
      else
        @index = i0
        r0 = nil
      end
    end
  end

  node_cache[:proposition][start_index] = r0

  r0
end
_nt_reserved_character() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 2453
def _nt_reserved_character
  start_index = index
  if node_cache[:reserved_character].has_key?(index)
    cached = node_cache[:reserved_character][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  if has_terminal?('\G[&|.():!=<>~,\\]\\[]', true, index)
    r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
    @index += 1
  else
    r0 = nil
  end

  node_cache[:reserved_character][start_index] = r0

  r0
end
_nt_sentence() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 21
def _nt_sentence
  start_index = index
  if node_cache[:sentence].has_key?(index)
    cached = node_cache[:sentence][index]
    if cached
      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
    r2 = _nt_space
    if r2
      s1 << r2
    else
      break
    end
  end
  r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
  s0 << r1
  if r1
    r3 = _nt_proposition
    s0 << r3
    if r3
      s4, i4 = [], index
      loop do
        r5 = _nt_space
        if r5
          s4 << r5
        else
          break
        end
      end
      r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
      s0 << r4
    end
  end
  if s0.last
    r0 = instantiate_node(Nodes::Sentence,input, i0...index, s0)
    r0.extend(Sentence0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:sentence][start_index] = r0

  r0
end
_nt_sign() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 2053
def _nt_sign
  start_index = index
  if node_cache[:sign].has_key?(index)
    cached = node_cache[:sign][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  if has_terminal?('+', false, index)
    r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
    @index += 1
  else
    terminal_parse_failure('+')
    r1 = nil
  end
  if r1
    r0 = r1
  else
    if has_terminal?('-', false, index)
      r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
      @index += 1
    else
      terminal_parse_failure('-')
      r2 = nil
    end
    if r2
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:sign][start_index] = r0

  r0
end
_nt_space() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 1509
def _nt_space
  start_index = index
  if node_cache[:space].has_key?(index)
    cached = node_cache[:space][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  if has_terminal?('\G[\\s\\t\\n]', true, index)
    r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
    @index += 1
  else
    r0 = nil
  end

  node_cache[:space][start_index] = r0

  r0
end
_nt_statement() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 287
def _nt_statement
  start_index = index
  if node_cache[:statement].has_key?(index)
    cached = node_cache[:statement][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_parenthesis_sentence
  if r1
    r0 = r1
  else
    r2 = _nt_comparison
    if r2
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:statement][start_index] = r0

  r0
end
_nt_string() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 2163
def _nt_string
  start_index = index
  if node_cache[:string].has_key?(index)
    cached = node_cache[:string][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  s0, i0 = [], index
  loop do
    r1 = _nt_valid_character
    if r1
      s0 << r1
    else
      break
    end
  end
  if s0.empty?
    @index = i0
    r0 = nil
  else
    r0 = instantiate_node(Nodes::Constants::String,input, i0...index, s0)
  end

  node_cache[:string][start_index] = r0

  r0
end
_nt_time() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 1640
def _nt_time
  start_index = index
  if node_cache[:time].has_key?(index)
    cached = node_cache[:time][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  i2, s2 = index, []
  r3 = _nt_date
  s2 << r3
  if r3
    if has_terminal?('T', false, index)
      r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
      @index += 1
    else
      terminal_parse_failure('T')
      r4 = nil
    end
    s2 << r4
  end
  if s2.last
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    r2.extend(Time0)
  else
    @index = i2
    r2 = nil
  end
  if r2
    r1 = r2
  else
    r1 = instantiate_node(SyntaxNode,input, index...index)
  end
  s0 << r1
  if r1
    i5, s5 = index, []
    r6 = _nt_digit
    s5 << r6
    if r6
      r7 = _nt_digit
      s5 << r7
    end
    if s5.last
      r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
      r5.extend(Time1)
    else
      @index = i5
      r5 = nil
    end
    s0 << r5
    if r5
      if has_terminal?(':', false, index)
        r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure(':')
        r8 = nil
      end
      s0 << r8
      if r8
        i9, s9 = index, []
        r10 = _nt_digit
        s9 << r10
        if r10
          r11 = _nt_digit
          s9 << r11
        end
        if s9.last
          r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
          r9.extend(Time2)
        else
          @index = i9
          r9 = nil
        end
        s0 << r9
        if r9
          i13, s13 = index, []
          if has_terminal?(':', false, index)
            r14 = instantiate_node(SyntaxNode,input, index...(index + 1))
            @index += 1
          else
            terminal_parse_failure(':')
            r14 = nil
          end
          s13 << r14
          if r14
            i15, s15 = index, []
            r16 = _nt_digit
            s15 << r16
            if r16
              r17 = _nt_digit
              s15 << r17
            end
            if s15.last
              r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
              r15.extend(Time3)
            else
              @index = i15
              r15 = nil
            end
            s13 << r15
          end
          if s13.last
            r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
            r13.extend(Time4)
          else
            @index = i13
            r13 = nil
          end
          if r13
            r12 = r13
          else
            r12 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r12
          if r12
            i19, s19 = index, []
            r20 = _nt_timezone
            s19 << r20
            if s19.last
              r19 = instantiate_node(SyntaxNode,input, i19...index, s19)
              r19.extend(Time5)
            else
              @index = i19
              r19 = nil
            end
            if r19
              r18 = r19
            else
              r18 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r18
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(Nodes::Constants::Time,input, i0...index, s0)
    r0.extend(Time6)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:time][start_index] = r0

  r0
end
_nt_timezone() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 1982
def _nt_timezone
  start_index = index
  if node_cache[:timezone].has_key?(index)
    cached = node_cache[:timezone][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_sign
  s0 << r1
  if r1
    i2, s2 = index, []
    r3 = _nt_digit
    s2 << r3
    if r3
      r4 = _nt_digit
      s2 << r4
    end
    if s2.last
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
      r2.extend(Timezone0)
    else
      @index = i2
      r2 = nil
    end
    s0 << r2
    if r2
      if has_terminal?(':', false, index)
        r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure(':')
        r5 = nil
      end
      s0 << r5
      if r5
        i6, s6 = index, []
        r7 = _nt_digit
        s6 << r7
        if r7
          r8 = _nt_digit
          s6 << r8
        end
        if s6.last
          r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
          r6.extend(Timezone1)
        else
          @index = i6
          r6 = nil
        end
        s0 << r6
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Timezone2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:timezone][start_index] = r0

  r0
end
_nt_true() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 2278
def _nt_true
  start_index = index
  if node_cache[:true].has_key?(index)
    cached = node_cache[:true][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  if has_terminal?('true', false, index)
    r0 = instantiate_node(Nodes::Constants::True,input, index...(index + 4))
    @index += 4
  else
    terminal_parse_failure('true')
    r0 = nil
  end

  node_cache[:true][start_index] = r0

  r0
end
_nt_valid_character() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 2225
def _nt_valid_character
  start_index = index
  if node_cache[:valid_character].has_key?(index)
    cached = node_cache[:valid_character][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  if has_terminal?('\G[0-9a-zA-ZÁÀÄÂÃÅĀĂǍáàäâãåāăǎÉÈËÊĒĔĖĚéèëêēĕėěÍÌÏÎĨĬǏíìïîĩĭǐÓÒÖÔÕŌŎŐǑóòöôõōŏőǒÚÙÜÛŨŪŬŮŰǓúùüûũūŭůűǔÑñçÇ%@#+\\--Z\\\\^_\'?!$*/\\s]', true, index)
    r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
    @index += 1
  else
    r0 = nil
  end

  node_cache[:valid_character][start_index] = r0

  r0
end
root() click to toggle source
# File lib/rasti/db/nql/syntax.rb, line 10
def root
  @root ||= :sentence
end