module LogStashConfig

Public Instance Methods

_nt__() click to toggle source
# File lib/logstash/config/grammar.rb, line 210
def _nt__
  start_index = index
  if node_cache[:_].has_key?(index)
    cached = node_cache[:_][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
    i1 = index
    r2 = _nt_comment
    if r2
      r1 = r2
    else
      r3 = _nt_whitespace
      if r3
        r1 = r3
      else
        @index = i1
        r1 = nil
      end
    end
    if r1
      s0 << r1
    else
      break
    end
  end
  r0 = instantiate_node(LogStash::Config::AST::Whitespace,input, i0...index, s0)

  node_cache[:_][start_index] = r0

  r0
end
_nt_array() click to toggle source
# File lib/logstash/config/grammar.rb, line 1477
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
    r2 = _nt__
    s0 << r2
    if r2
      i4, s4 = index, []
      r5 = _nt_value
      s4 << r5
      if r5
        s6, i6 = [], index
        loop do
          i7, s7 = index, []
          r8 = _nt__
          s7 << r8
          if r8
            if has_terminal?(",", false, index)
              r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
              @index += 1
            else
              terminal_parse_failure(",")
              r9 = nil
            end
            s7 << r9
            if r9
              r10 = _nt__
              s7 << r10
              if r10
                r11 = _nt_value
                s7 << r11
              end
            end
          end
          if s7.last
            r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
            r7.extend(Array0)
          else
            @index = i7
            r7 = nil
          end
          if r7
            s6 << r7
          else
            break
          end
        end
        r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
        s4 << r6
      end
      if s4.last
        r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
        r4.extend(Array1)
      else
        @index = i4
        r4 = nil
      end
      if r4
        r3 = r4
      else
        r3 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r3
      if r3
        r12 = _nt__
        s0 << r12
        if r12
          if has_terminal?("]", false, index)
            r13 = instantiate_node(SyntaxNode,input, index...(index + 1))
            @index += 1
          else
            terminal_parse_failure("]")
            r13 = nil
          end
          s0 << r13
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(LogStash::Config::AST::Array,input, i0...index, s0)
    r0.extend(Array2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:array][start_index] = r0

  r0
end
_nt_array_value() click to toggle source
# File lib/logstash/config/grammar.rb, line 867
def _nt_array_value
  start_index = index
  if node_cache[:array_value].has_key?(index)
    cached = node_cache[:array_value][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_bareword
  if r1
    r0 = r1
  else
    r2 = _nt_string
    if r2
      r0 = r2
    else
      r3 = _nt_number
      if r3
        r0 = r3
      else
        r4 = _nt_array
        if r4
          r0 = r4
        else
          r5 = _nt_hash
          if r5
            r0 = r5
          else
            @index = i0
            r0 = nil
          end
        end
      end
    end
  end

  node_cache[:array_value][start_index] = r0

  r0
end
_nt_attribute() click to toggle source
# File lib/logstash/config/grammar.rb, line 768
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, []
  r1 = _nt_name
  s0 << r1
  if r1
    r2 = _nt__
    s0 << r2
    if r2
      if has_terminal?("=>", false, index)
        r3 = instantiate_node(SyntaxNode,input, index...(index + 2))
        @index += 2
      else
        terminal_parse_failure("=>")
        r3 = nil
      end
      s0 << r3
      if r3
        r4 = _nt__
        s0 << r4
        if r4
          r5 = _nt_value
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(LogStash::Config::AST::Attribute,input, i0...index, s0)
    r0.extend(Attribute0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:attribute][start_index] = r0

  r0
end
_nt_bareword() click to toggle source
# File lib/logstash/config/grammar.rb, line 915
def _nt_bareword
  start_index = index
  if node_cache[:bareword].has_key?(index)
    cached = node_cache[:bareword][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?('\G[A-Za-z_]', true, index)
    r1 = true
    @index += 1
  else
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      if has_terminal?('\G[A-Za-z0-9_]', true, index)
        r3 = true
        @index += 1
      else
        r3 = nil
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    if s2.empty?
      @index = i2
      r2 = nil
    else
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    end
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(LogStash::Config::AST::Bareword,input, i0...index, s0)
    r0.extend(Bareword0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:bareword][start_index] = r0

  r0
end
_nt_boolean_operator() click to toggle source
# File lib/logstash/config/grammar.rb, line 3330
def _nt_boolean_operator
  start_index = index
  if node_cache[:boolean_operator].has_key?(index)
    cached = node_cache[:boolean_operator][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?("and", false, index)
    r1 = instantiate_node(SyntaxNode,input, index...(index + 3))
    @index += 3
  else
    terminal_parse_failure("and")
    r1 = nil
  end
  if r1
    r0 = r1
    r0.extend(LogStash::Config::AST::BooleanOperator)
  else
    if has_terminal?("or", false, index)
      r2 = instantiate_node(SyntaxNode,input, index...(index + 2))
      @index += 2
    else
      terminal_parse_failure("or")
      r2 = nil
    end
    if r2
      r0 = r2
      r0.extend(LogStash::Config::AST::BooleanOperator)
    else
      if has_terminal?("xor", false, index)
        r3 = instantiate_node(SyntaxNode,input, index...(index + 3))
        @index += 3
      else
        terminal_parse_failure("xor")
        r3 = nil
      end
      if r3
        r0 = r3
        r0.extend(LogStash::Config::AST::BooleanOperator)
      else
        if has_terminal?("nand", false, index)
          r4 = instantiate_node(SyntaxNode,input, index...(index + 4))
          @index += 4
        else
          terminal_parse_failure("nand")
          r4 = nil
        end
        if r4
          r0 = r4
          r0.extend(LogStash::Config::AST::BooleanOperator)
        else
          @index = i0
          r0 = nil
        end
      end
    end
  end

  node_cache[:boolean_operator][start_index] = r0

  r0
end
_nt_branch() click to toggle source
# File lib/logstash/config/grammar.rb, line 1838
def _nt_branch
  start_index = index
  if node_cache[:branch].has_key?(index)
    cached = node_cache[:branch][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_if
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      i3, s3 = index, []
      r4 = _nt__
      s3 << r4
      if r4
        r5 = _nt_else_if
        s3 << r5
      end
      if s3.last
        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
        r3.extend(Branch0)
      else
        @index = i3
        r3 = nil
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
    if r2
      i7, s7 = index, []
      r8 = _nt__
      s7 << r8
      if r8
        r9 = _nt_else
        s7 << r9
      end
      if s7.last
        r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
        r7.extend(Branch1)
      else
        @index = i7
        r7 = nil
      end
      if r7
        r6 = r7
      else
        r6 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r6
    end
  end
  if s0.last
    r0 = instantiate_node(LogStash::Config::AST::Branch,input, i0...index, s0)
    r0.extend(Branch2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:branch][start_index] = r0

  r0
end
_nt_branch_or_plugin() click to toggle source
# File lib/logstash/config/grammar.rb, line 392
def _nt_branch_or_plugin
  start_index = index
  if node_cache[:branch_or_plugin].has_key?(index)
    cached = node_cache[:branch_or_plugin][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_branch
  if r1
    r0 = r1
  else
    r2 = _nt_plugin
    if r2
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:branch_or_plugin][start_index] = r0

  r0
end
_nt_comment() click to toggle source
# File lib/logstash/config/grammar.rb, line 111
def _nt_comment
  start_index = index
  if node_cache[:comment].has_key?(index)
    cached = node_cache[:comment][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
    i1, s1 = index, []
    r3 = _nt_whitespace
    if r3
      r2 = r3
    else
      r2 = instantiate_node(SyntaxNode,input, index...index)
    end
    s1 << 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
      s1 << r4
      if r4
        s5, i5 = [], index
        loop do
          if has_terminal?('\G[^\\r\\n]', true, index)
            r6 = true
            @index += 1
          else
            r6 = nil
          end
          if r6
            s5 << r6
          else
            break
          end
        end
        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
        s1 << r5
        if r5
          if has_terminal?("\r", false, index)
            r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
            @index += 1
          else
            terminal_parse_failure("\r")
            r8 = nil
          end
          if r8
            r7 = r8
          else
            r7 = instantiate_node(SyntaxNode,input, index...index)
          end
          s1 << r7
          if r7
            if has_terminal?("\n", false, index)
              r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
              @index += 1
            else
              terminal_parse_failure("\n")
              r9 = nil
            end
            s1 << r9
          end
        end
      end
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(Comment0)
    else
      @index = i1
      r1 = nil
    end
    if r1
      s0 << r1
    else
      break
    end
  end
  if s0.empty?
    @index = i0
    r0 = nil
  else
    r0 = instantiate_node(LogStash::Config::AST::Comment,input, i0...index, s0)
  end

  node_cache[:comment][start_index] = r0

  r0
end
_nt_compare_expression() click to toggle source
# File lib/logstash/config/grammar.rb, line 3077
def _nt_compare_expression
  start_index = index
  if node_cache[:compare_expression].has_key?(index)
    cached = node_cache[:compare_expression][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_rvalue
  s0 << r1
  if r1
    r2 = _nt__
    s0 << r2
    if r2
      r3 = _nt_compare_operator
      s0 << r3
      if r3
        r4 = _nt__
        s0 << r4
        if r4
          r5 = _nt_rvalue
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(LogStash::Config::AST::ComparisonExpression,input, i0...index, s0)
    r0.extend(CompareExpression0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:compare_expression][start_index] = r0

  r0
end
_nt_compare_operator() click to toggle source
# File lib/logstash/config/grammar.rb, line 3120
def _nt_compare_operator
  start_index = index
  if node_cache[:compare_operator].has_key?(index)
    cached = node_cache[:compare_operator][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 + 2))
    @index += 2
  else
    terminal_parse_failure("==")
    r1 = nil
  end
  if r1
    r0 = r1
    r0.extend(LogStash::Config::AST::ComparisonOperator)
  else
    if has_terminal?("!=", false, index)
      r2 = instantiate_node(SyntaxNode,input, index...(index + 2))
      @index += 2
    else
      terminal_parse_failure("!=")
      r2 = nil
    end
    if r2
      r0 = r2
      r0.extend(LogStash::Config::AST::ComparisonOperator)
    else
      if has_terminal?("<=", false, index)
        r3 = instantiate_node(SyntaxNode,input, index...(index + 2))
        @index += 2
      else
        terminal_parse_failure("<=")
        r3 = nil
      end
      if r3
        r0 = r3
        r0.extend(LogStash::Config::AST::ComparisonOperator)
      else
        if has_terminal?(">=", false, index)
          r4 = instantiate_node(SyntaxNode,input, index...(index + 2))
          @index += 2
        else
          terminal_parse_failure(">=")
          r4 = nil
        end
        if r4
          r0 = r4
          r0.extend(LogStash::Config::AST::ComparisonOperator)
        else
          if has_terminal?("<", false, index)
            r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
            @index += 1
          else
            terminal_parse_failure("<")
            r5 = nil
          end
          if r5
            r0 = r5
            r0.extend(LogStash::Config::AST::ComparisonOperator)
          else
            if has_terminal?(">", false, index)
              r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
              @index += 1
            else
              terminal_parse_failure(">")
              r6 = nil
            end
            if r6
              r0 = r6
              r0.extend(LogStash::Config::AST::ComparisonOperator)
            else
              @index = i0
              r0 = nil
            end
          end
        end
      end
    end
  end

  node_cache[:compare_operator][start_index] = r0

  r0
end
_nt_condition() click to toggle source
# File lib/logstash/config/grammar.rb, line 2312
def _nt_condition
  start_index = index
  if node_cache[:condition].has_key?(index)
    cached = node_cache[:condition][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_expression
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      i3, s3 = index, []
      r4 = _nt__
      s3 << r4
      if r4
        r5 = _nt_boolean_operator
        s3 << r5
        if r5
          r6 = _nt__
          s3 << r6
          if r6
            r7 = _nt_expression
            s3 << r7
          end
        end
      end
      if s3.last
        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
        r3.extend(Condition0)
      else
        @index = i3
        r3 = nil
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(LogStash::Config::AST::Condition,input, i0...index, s0)
    r0.extend(Condition1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:condition][start_index] = r0

  r0
end
_nt_config() click to toggle source
# File lib/logstash/config/grammar.rb, line 43
def _nt_config
  start_index = index
  if node_cache[:config].has_key?(index)
    cached = node_cache[:config][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__
  s0 << r1
  if r1
    r2 = _nt_plugin_section
    s0 << r2
    if r2
      r3 = _nt__
      s0 << r3
      if r3
        s4, i4 = [], index
        loop do
          i5, s5 = index, []
          r6 = _nt__
          s5 << r6
          if r6
            r7 = _nt_plugin_section
            s5 << r7
          end
          if s5.last
            r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
            r5.extend(Config0)
          else
            @index = i5
            r5 = nil
          end
          if r5
            s4 << r5
          else
            break
          end
        end
        r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
        s0 << r4
        if r4
          r8 = _nt__
          s0 << r8
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(LogStash::Config::AST::Config,input, i0...index, s0)
    r0.extend(Config1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:config][start_index] = r0

  r0
end
_nt_double_quoted_string() click to toggle source
# File lib/logstash/config/grammar.rb, line 976
def _nt_double_quoted_string
  start_index = index
  if node_cache[:double_quoted_string].has_key?(index)
    cached = node_cache[:double_quoted_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
      i3 = index
      if has_terminal?('\"', false, index)
        r4 = instantiate_node(SyntaxNode,input, index...(index + 2))
        @index += 2
      else
        terminal_parse_failure('\"')
        r4 = nil
      end
      if r4
        r3 = r4
      else
        i5, s5 = index, []
        i6 = index
        if has_terminal?('"', false, index)
          r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
          @index += 1
        else
          terminal_parse_failure('"')
          r7 = nil
        end
        if r7
          r6 = nil
        else
          @index = i6
          r6 = instantiate_node(SyntaxNode,input, index...index)
        end
        s5 << r6
        if r6
          if index < input_length
            r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
            @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(DoubleQuotedString0)
        else
          @index = i5
          r5 = nil
        end
        if r5
          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 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
  if s0.last
    r0 = instantiate_node(LogStash::Config::AST::String,input, i0...index, s0)
    r0.extend(DoubleQuotedString1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:double_quoted_string][start_index] = r0

  r0
end
_nt_else() click to toggle source
# File lib/logstash/config/grammar.rb, line 2200
def _nt_else
  start_index = index
  if node_cache[:else].has_key?(index)
    cached = node_cache[:else][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?("else", false, index)
    r1 = instantiate_node(SyntaxNode,input, index...(index + 4))
    @index += 4
  else
    terminal_parse_failure("else")
    r1 = nil
  end
  s0 << r1
  if r1
    r2 = _nt__
    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
      if r3
        r4 = _nt__
        s0 << r4
        if r4
          s5, i5 = [], index
          loop do
            i6, s6 = index, []
            r7 = _nt_branch_or_plugin
            s6 << r7
            if r7
              r8 = _nt__
              s6 << r8
            end
            if s6.last
              r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
              r6.extend(Else0)
            else
              @index = i6
              r6 = nil
            end
            if r6
              s5 << r6
            else
              break
            end
          end
          r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
          s0 << r5
          if r5
            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
  end
  if s0.last
    r0 = instantiate_node(LogStash::Config::AST::Else,input, i0...index, s0)
    r0.extend(Else1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:else][start_index] = r0

  r0
end
_nt_else_if() click to toggle source
# File lib/logstash/config/grammar.rb, line 2070
def _nt_else_if
  start_index = index
  if node_cache[:else_if].has_key?(index)
    cached = node_cache[:else_if][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?("else", false, index)
    r1 = instantiate_node(SyntaxNode,input, index...(index + 4))
    @index += 4
  else
    terminal_parse_failure("else")
    r1 = nil
  end
  s0 << r1
  if r1
    r2 = _nt__
    s0 << r2
    if r2
      if has_terminal?("if", false, index)
        r3 = instantiate_node(SyntaxNode,input, index...(index + 2))
        @index += 2
      else
        terminal_parse_failure("if")
        r3 = nil
      end
      s0 << r3
      if r3
        r4 = _nt__
        s0 << r4
        if r4
          r5 = _nt_condition
          s0 << r5
          if r5
            r6 = _nt__
            s0 << r6
            if r6
              if has_terminal?("{", false, index)
                r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
                @index += 1
              else
                terminal_parse_failure("{")
                r7 = nil
              end
              s0 << r7
              if r7
                r8 = _nt__
                s0 << r8
                if r8
                  s9, i9 = [], index
                  loop do
                    i10, s10 = index, []
                    r11 = _nt_branch_or_plugin
                    s10 << r11
                    if r11
                      r12 = _nt__
                      s10 << r12
                    end
                    if s10.last
                      r10 = instantiate_node(SyntaxNode,input, i10...index, s10)
                      r10.extend(ElseIf0)
                    else
                      @index = i10
                      r10 = nil
                    end
                    if r10
                      s9 << r10
                    else
                      break
                    end
                  end
                  r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
                  s0 << r9
                  if r9
                    if has_terminal?("}", false, index)
                      r13 = instantiate_node(SyntaxNode,input, index...(index + 1))
                      @index += 1
                    else
                      terminal_parse_failure("}")
                      r13 = nil
                    end
                    s0 << r13
                  end
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(LogStash::Config::AST::Elsif,input, i0...index, s0)
    r0.extend(ElseIf1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:else_if][start_index] = r0

  r0
end
_nt_expression() click to toggle source
# File lib/logstash/config/grammar.rb, line 2388
def _nt_expression
  start_index = index
  if node_cache[:expression].has_key?(index)
    cached = node_cache[:expression][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  if has_terminal?("(", false, index)
    r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
    @index += 1
  else
    terminal_parse_failure("(")
    r2 = nil
  end
  s1 << r2
  if r2
    r3 = _nt__
    s1 << r3
    if r3
      r4 = _nt_condition
      s1 << r4
      if r4
        r5 = _nt__
        s1 << r5
        if r5
          if has_terminal?(")", false, index)
            r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
            @index += 1
          else
            terminal_parse_failure(")")
            r6 = nil
          end
          s1 << r6
        end
      end
    end
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(Expression0)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r0 = r1
    r0.extend(LogStash::Config::AST::Expression)
  else
    r7 = _nt_negative_expression
    if r7
      r0 = r7
      r0.extend(LogStash::Config::AST::Expression)
    else
      r8 = _nt_in_expression
      if r8
        r0 = r8
        r0.extend(LogStash::Config::AST::Expression)
      else
        r9 = _nt_not_in_expression
        if r9
          r0 = r9
          r0.extend(LogStash::Config::AST::Expression)
        else
          r10 = _nt_compare_expression
          if r10
            r0 = r10
            r0.extend(LogStash::Config::AST::Expression)
          else
            r11 = _nt_regexp_expression
            if r11
              r0 = r11
              r0.extend(LogStash::Config::AST::Expression)
            else
              r12 = _nt_rvalue
              if r12
                r0 = r12
                r0.extend(LogStash::Config::AST::Expression)
              else
                @index = i0
                r0 = nil
              end
            end
          end
        end
      end
    end
  end

  node_cache[:expression][start_index] = r0

  r0
end
_nt_hash() click to toggle source
# File lib/logstash/config/grammar.rb, line 1597
def _nt_hash
  start_index = index
  if node_cache[:hash].has_key?(index)
    cached = node_cache[:hash][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__
    s0 << r2
    if r2
      r4 = _nt_hashentries
      if r4
        r3 = r4
      else
        r3 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r3
      if r3
        r5 = _nt__
        s0 << r5
        if r5
          if has_terminal?("}", false, index)
            r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
            @index += 1
          else
            terminal_parse_failure("}")
            r6 = nil
          end
          s0 << r6
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(LogStash::Config::AST::Hash,input, i0...index, s0)
    r0.extend(Hash0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:hash][start_index] = r0

  r0
end
_nt_hashentries() click to toggle source
# File lib/logstash/config/grammar.rb, line 1674
def _nt_hashentries
  start_index = index
  if node_cache[:hashentries].has_key?(index)
    cached = node_cache[:hashentries][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_hashentry
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      i3, s3 = index, []
      r4 = _nt_whitespace
      s3 << r4
      if r4
        r5 = _nt_hashentry
        s3 << r5
      end
      if s3.last
        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
        r3.extend(Hashentries0)
      else
        @index = i3
        r3 = nil
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(LogStash::Config::AST::HashEntries,input, i0...index, s0)
    r0.extend(Hashentries1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:hashentries][start_index] = r0

  r0
end
_nt_hashentry() click to toggle source
# File lib/logstash/config/grammar.rb, line 1745
def _nt_hashentry
  start_index = index
  if node_cache[:hashentry].has_key?(index)
    cached = node_cache[:hashentry][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_number
  if r2
    r1 = r2
  else
    r3 = _nt_bareword
    if r3
      r1 = r3
    else
      r4 = _nt_string
      if r4
        r1 = r4
      else
        @index = i1
        r1 = nil
      end
    end
  end
  s0 << r1
  if r1
    r5 = _nt__
    s0 << r5
    if r5
      if has_terminal?("=>", false, index)
        r6 = instantiate_node(SyntaxNode,input, index...(index + 2))
        @index += 2
      else
        terminal_parse_failure("=>")
        r6 = nil
      end
      s0 << r6
      if r6
        r7 = _nt__
        s0 << r7
        if r7
          r8 = _nt_value
          s0 << r8
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(LogStash::Config::AST::HashEntry,input, i0...index, s0)
    r0.extend(Hashentry0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:hashentry][start_index] = r0

  r0
end
_nt_if() click to toggle source
# File lib/logstash/config/grammar.rb, line 1942
def _nt_if
  start_index = index
  if node_cache[:if].has_key?(index)
    cached = node_cache[:if][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?("if", false, index)
    r1 = instantiate_node(SyntaxNode,input, index...(index + 2))
    @index += 2
  else
    terminal_parse_failure("if")
    r1 = nil
  end
  s0 << r1
  if r1
    r2 = _nt__
    s0 << r2
    if r2
      r3 = _nt_condition
      s0 << r3
      if r3
        r4 = _nt__
        s0 << r4
        if r4
          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
            r6 = _nt__
            s0 << r6
            if r6
              s7, i7 = [], index
              loop do
                i8, s8 = index, []
                r9 = _nt_branch_or_plugin
                s8 << r9
                if r9
                  r10 = _nt__
                  s8 << r10
                end
                if s8.last
                  r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
                  r8.extend(If0)
                else
                  @index = i8
                  r8 = nil
                end
                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)
                  r11 = instantiate_node(SyntaxNode,input, index...(index + 1))
                  @index += 1
                else
                  terminal_parse_failure("}")
                  r11 = nil
                end
                s0 << r11
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(LogStash::Config::AST::If,input, i0...index, s0)
    r0.extend(If1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:if][start_index] = r0

  r0
end
_nt_in_expression() click to toggle source
# File lib/logstash/config/grammar.rb, line 2644
def _nt_in_expression
  start_index = index
  if node_cache[:in_expression].has_key?(index)
    cached = node_cache[:in_expression][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_rvalue
  s0 << r1
  if r1
    r2 = _nt__
    s0 << r2
    if r2
      r3 = _nt_in_operator
      s0 << r3
      if r3
        r4 = _nt__
        s0 << r4
        if r4
          r5 = _nt_rvalue
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(LogStash::Config::AST::InExpression,input, i0...index, s0)
    r0.extend(InExpression0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:in_expression][start_index] = r0

  r0
end
_nt_in_operator() click to toggle source
# File lib/logstash/config/grammar.rb, line 2752
def _nt_in_operator
  start_index = index
  if node_cache[:in_operator].has_key?(index)
    cached = node_cache[:in_operator][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  if has_terminal?("in", false, index)
    r0 = instantiate_node(SyntaxNode,input, index...(index + 2))
    @index += 2
  else
    terminal_parse_failure("in")
    r0 = nil
  end

  node_cache[:in_operator][start_index] = r0

  r0
end
_nt_method() click to toggle source
# File lib/logstash/config/grammar.rb, line 3037
def _nt_method
  start_index = index
  if node_cache[:method].has_key?(index)
    cached = node_cache[:method][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  r0 = _nt_bareword

  node_cache[:method][start_index] = r0

  r0
end
_nt_method_call() click to toggle source
# File lib/logstash/config/grammar.rb, line 2920
def _nt_method_call
  start_index = index
  if node_cache[:method_call].has_key?(index)
    cached = node_cache[:method_call][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_method
  s0 << r1
  if r1
    r2 = _nt__
    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
      if r3
        r4 = _nt__
        s0 << r4
        if r4
          i6, s6 = index, []
          r7 = _nt_rvalue
          s6 << r7
          if r7
            s8, i8 = [], index
            loop do
              i9, s9 = index, []
              r10 = _nt__
              s9 << r10
              if r10
                if has_terminal?(",", false, index)
                  r11 = instantiate_node(SyntaxNode,input, index...(index + 1))
                  @index += 1
                else
                  terminal_parse_failure(",")
                  r11 = nil
                end
                s9 << r11
                if r11
                  r12 = _nt__
                  s9 << r12
                  if r12
                    r13 = _nt_rvalue
                    s9 << r13
                  end
                end
              end
              if s9.last
                r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
                r9.extend(MethodCall0)
              else
                @index = i9
                r9 = nil
              end
              if r9
                s8 << r9
              else
                break
              end
            end
            r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
            s6 << r8
          end
          if s6.last
            r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
            r6.extend(MethodCall1)
          else
            @index = i6
            r6 = nil
          end
          if r6
            r5 = r6
          else
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
          if r5
            r14 = _nt__
            s0 << r14
            if r14
              if has_terminal?(")", false, index)
                r15 = instantiate_node(SyntaxNode,input, index...(index + 1))
                @index += 1
              else
                terminal_parse_failure(")")
                r15 = nil
              end
              s0 << r15
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(LogStash::Config::AST::MethodCall,input, i0...index, s0)
    r0.extend(MethodCall2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:method_call][start_index] = r0

  r0
end
_nt_name() click to toggle source
# File lib/logstash/config/grammar.rb, line 701
def _nt_name
  start_index = index
  if node_cache[:name].has_key?(index)
    cached = node_cache[:name][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  s1, i1 = [], index
  loop do
    if has_terminal?('\G[A-Za-z0-9_-]', true, index)
      r2 = true
      @index += 1
    else
      r2 = nil
    end
    if r2
      s1 << r2
    else
      break
    end
  end
  if s1.empty?
    @index = i1
    r1 = nil
  else
    r1 = instantiate_node(LogStash::Config::AST::Name,input, i1...index, s1)
  end
  if r1
    r0 = r1
  else
    r3 = _nt_string
    if r3
      r0 = r3
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:name][start_index] = r0

  r0
end
_nt_negative_expression() click to toggle source
# File lib/logstash/config/grammar.rb, line 2516
def _nt_negative_expression
  start_index = index
  if node_cache[:negative_expression].has_key?(index)
    cached = node_cache[:negative_expression][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  if has_terminal?("!", false, index)
    r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
    @index += 1
  else
    terminal_parse_failure("!")
    r2 = nil
  end
  s1 << r2
  if r2
    r3 = _nt__
    s1 << 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
      s1 << r4
      if r4
        r5 = _nt__
        s1 << r5
        if r5
          r6 = _nt_condition
          s1 << r6
          if r6
            r7 = _nt__
            s1 << r7
            if r7
              if has_terminal?(")", false, index)
                r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
                @index += 1
              else
                terminal_parse_failure(")")
                r8 = nil
              end
              s1 << r8
            end
          end
        end
      end
    end
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(NegativeExpression0)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r0 = r1
    r0.extend(LogStash::Config::AST::NegativeExpression)
  else
    i9, s9 = index, []
    if has_terminal?("!", false, index)
      r10 = instantiate_node(SyntaxNode,input, index...(index + 1))
      @index += 1
    else
      terminal_parse_failure("!")
      r10 = nil
    end
    s9 << r10
    if r10
      r11 = _nt__
      s9 << r11
      if r11
        r12 = _nt_selector
        s9 << r12
      end
    end
    if s9.last
      r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
      r9.extend(NegativeExpression1)
    else
      @index = i9
      r9 = nil
    end
    if r9
      r0 = r9
      r0.extend(LogStash::Config::AST::NegativeExpression)
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:negative_expression][start_index] = r0

  r0
end
_nt_not_in_expression() click to toggle source
# File lib/logstash/config/grammar.rb, line 2709
def _nt_not_in_expression
  start_index = index
  if node_cache[:not_in_expression].has_key?(index)
    cached = node_cache[:not_in_expression][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_rvalue
  s0 << r1
  if r1
    r2 = _nt__
    s0 << r2
    if r2
      r3 = _nt_not_in_operator
      s0 << r3
      if r3
        r4 = _nt__
        s0 << r4
        if r4
          r5 = _nt_rvalue
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(LogStash::Config::AST::NotInExpression,input, i0...index, s0)
    r0.extend(NotInExpression0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:not_in_expression][start_index] = r0

  r0
end
_nt_not_in_operator() click to toggle source
# File lib/logstash/config/grammar.rb, line 2783
def _nt_not_in_operator
  start_index = index
  if node_cache[:not_in_operator].has_key?(index)
    cached = node_cache[:not_in_operator][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?("not ", false, index)
    r1 = instantiate_node(SyntaxNode,input, index...(index + 4))
    @index += 4
  else
    terminal_parse_failure("not ")
    r1 = nil
  end
  s0 << r1
  if r1
    r2 = _nt__
    s0 << r2
    if r2
      if has_terminal?("in", false, index)
        r3 = instantiate_node(SyntaxNode,input, index...(index + 2))
        @index += 2
      else
        terminal_parse_failure("in")
        r3 = nil
      end
      s0 << r3
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(NotInOperator0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:not_in_operator][start_index] = r0

  r0
end
_nt_number() click to toggle source
# File lib/logstash/config/grammar.rb, line 1342
def _nt_number
  start_index = index
  if node_cache[:number].has_key?(index)
    cached = node_cache[:number][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)
    r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
    @index += 1
  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?('\G[0-9]', true, index)
        r4 = true
        @index += 1
      else
        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?(".", false, index)
        r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure(".")
        r7 = nil
      end
      s6 << r7
      if r7
        s8, i8 = [], index
        loop do
          if has_terminal?('\G[0-9]', true, index)
            r9 = true
            @index += 1
          else
            r9 = nil
          end
          if r9
            s8 << r9
          else
            break
          end
        end
        r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
        s6 << r8
      end
      if s6.last
        r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
        r6.extend(Number0)
      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(LogStash::Config::AST::Number,input, i0...index, s0)
    r0.extend(Number1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:number][start_index] = r0

  r0
end
_nt_plugin() click to toggle source
# File lib/logstash/config/grammar.rb, line 594
def _nt_plugin
  start_index = index
  if node_cache[:plugin].has_key?(index)
    cached = node_cache[:plugin][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_name
  s0 << r1
  if r1
    r2 = _nt__
    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
      if r3
        r4 = _nt__
        s0 << r4
        if r4
          i6, s6 = index, []
          r7 = _nt_attribute
          s6 << r7
          if r7
            s8, i8 = [], index
            loop do
              i9, s9 = index, []
              r10 = _nt_whitespace
              s9 << r10
              if r10
                r11 = _nt__
                s9 << r11
                if r11
                  r12 = _nt_attribute
                  s9 << r12
                end
              end
              if s9.last
                r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
                r9.extend(Plugin0)
              else
                @index = i9
                r9 = nil
              end
              if r9
                s8 << r9
              else
                break
              end
            end
            r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
            s6 << r8
          end
          if s6.last
            r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
            r6.extend(Plugin1)
          else
            @index = i6
            r6 = nil
          end
          if r6
            r5 = r6
          else
            r5 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r5
          if r5
            r13 = _nt__
            s0 << r13
            if r13
              if has_terminal?("}", false, index)
                r14 = instantiate_node(SyntaxNode,input, index...(index + 1))
                @index += 1
              else
                terminal_parse_failure("}")
                r14 = nil
              end
              s0 << r14
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(LogStash::Config::AST::Plugin,input, i0...index, s0)
    r0.extend(Plugin2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:plugin][start_index] = r0

  r0
end
_nt_plugin_section() click to toggle source
# File lib/logstash/config/grammar.rb, line 311
def _nt_plugin_section
  start_index = index
  if node_cache[:plugin_section].has_key?(index)
    cached = node_cache[:plugin_section][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_plugin_type
  s0 << r1
  if r1
    r2 = _nt__
    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
      if r3
        r4 = _nt__
        s0 << r4
        if r4
          s5, i5 = [], index
          loop do
            i6, s6 = index, []
            r7 = _nt_branch_or_plugin
            s6 << r7
            if r7
              r8 = _nt__
              s6 << r8
            end
            if s6.last
              r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
              r6.extend(PluginSection0)
            else
              @index = i6
              r6 = nil
            end
            if r6
              s5 << r6
            else
              break
            end
          end
          r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
          s0 << r5
          if r5
            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
  end
  if s0.last
    r0 = instantiate_node(LogStash::Config::AST::PluginSection,input, i0...index, s0)
    r0.extend(PluginSection1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:plugin_section][start_index] = r0

  r0
end
_nt_plugin_type() click to toggle source
# File lib/logstash/config/grammar.rb, line 422
def _nt_plugin_type
  start_index = index
  if node_cache[:plugin_type].has_key?(index)
    cached = node_cache[:plugin_type][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?("input", false, index)
    r1 = instantiate_node(SyntaxNode,input, index...(index + 5))
    @index += 5
  else
    terminal_parse_failure("input")
    r1 = nil
  end
  if r1
    r0 = r1
  else
    if has_terminal?("filter", false, index)
      r2 = instantiate_node(SyntaxNode,input, index...(index + 6))
      @index += 6
    else
      terminal_parse_failure("filter")
      r2 = nil
    end
    if r2
      r0 = r2
    else
      if has_terminal?("output", false, index)
        r3 = instantiate_node(SyntaxNode,input, index...(index + 6))
        @index += 6
      else
        terminal_parse_failure("output")
        r3 = nil
      end
      if r3
        r0 = r3
      else
        @index = i0
        r0 = nil
      end
    end
  end

  node_cache[:plugin_type][start_index] = r0

  r0
end
_nt_plugins() click to toggle source
# File lib/logstash/config/grammar.rb, line 492
def _nt_plugins
  start_index = index
  if node_cache[:plugins].has_key?(index)
    cached = node_cache[:plugins][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i1, s1 = index, []
  r2 = _nt_plugin
  s1 << r2
  if r2
    s3, i3 = [], index
    loop do
      i4, s4 = index, []
      r5 = _nt__
      s4 << r5
      if r5
        r6 = _nt_plugin
        s4 << r6
      end
      if s4.last
        r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
        r4.extend(Plugins0)
      else
        @index = i4
        r4 = nil
      end
      if r4
        s3 << r4
      else
        break
      end
    end
    r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
    s1 << r3
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(Plugins1)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r0 = r1
  else
    r0 = instantiate_node(SyntaxNode,input, index...index)
  end

  node_cache[:plugins][start_index] = r0

  r0
end
_nt_regexp() click to toggle source
# File lib/logstash/config/grammar.rb, line 1230
def _nt_regexp
  start_index = index
  if node_cache[:regexp].has_key?(index)
    cached = node_cache[:regexp][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
      i3 = index
      if has_terminal?('\/', false, index)
        r4 = instantiate_node(SyntaxNode,input, index...(index + 2))
        @index += 2
      else
        terminal_parse_failure('\/')
        r4 = nil
      end
      if r4
        r3 = r4
      else
        i5, s5 = index, []
        i6 = index
        if has_terminal?('/', false, index)
          r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
          @index += 1
        else
          terminal_parse_failure('/')
          r7 = nil
        end
        if r7
          r6 = nil
        else
          @index = i6
          r6 = instantiate_node(SyntaxNode,input, index...index)
        end
        s5 << r6
        if r6
          if index < input_length
            r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
            @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(Regexp0)
        else
          @index = i5
          r5 = nil
        end
        if r5
          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 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
  if s0.last
    r0 = instantiate_node(LogStash::Config::AST::RegExp,input, i0...index, s0)
    r0.extend(Regexp1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:regexp][start_index] = r0

  r0
end
_nt_regexp_expression() click to toggle source
# File lib/logstash/config/grammar.rb, line 3231
def _nt_regexp_expression
  start_index = index
  if node_cache[:regexp_expression].has_key?(index)
    cached = node_cache[:regexp_expression][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_rvalue
  s0 << r1
  if r1
    r2 = _nt__
    s0 << r2
    if r2
      r3 = _nt_regexp_operator
      s0 << r3
      if r3
        r4 = _nt__
        s0 << r4
        if r4
          i5 = index
          r6 = _nt_string
          if r6
            r5 = r6
          else
            r7 = _nt_regexp
            if r7
              r5 = r7
            else
              @index = i5
              r5 = nil
            end
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(LogStash::Config::AST::RegexpExpression,input, i0...index, s0)
    r0.extend(RegexpExpression0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:regexp_expression][start_index] = r0

  r0
end
_nt_regexp_operator() click to toggle source
# File lib/logstash/config/grammar.rb, line 3286
def _nt_regexp_operator
  start_index = index
  if node_cache[:regexp_operator].has_key?(index)
    cached = node_cache[:regexp_operator][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 + 2))
    @index += 2
  else
    terminal_parse_failure("=~")
    r1 = nil
  end
  if r1
    r0 = r1
    r0.extend(LogStash::Config::AST::RegExpOperator)
  else
    if has_terminal?("!~", false, index)
      r2 = instantiate_node(SyntaxNode,input, index...(index + 2))
      @index += 2
    else
      terminal_parse_failure("!~")
      r2 = nil
    end
    if r2
      r0 = r2
      r0.extend(LogStash::Config::AST::RegExpOperator)
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:regexp_operator][start_index] = r0

  r0
end
_nt_rvalue() click to toggle source
# File lib/logstash/config/grammar.rb, line 2830
def _nt_rvalue
  start_index = index
  if node_cache[:rvalue].has_key?(index)
    cached = node_cache[:rvalue][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_string
  if r1
    r0 = r1
  else
    r2 = _nt_number
    if r2
      r0 = r2
    else
      r3 = _nt_selector
      if r3
        r0 = r3
      else
        r4 = _nt_array
        if r4
          r0 = r4
        else
          r5 = _nt_method_call
          if r5
            r0 = r5
          else
            r6 = _nt_regexp
            if r6
              r0 = r6
            else
              @index = i0
              r0 = nil
            end
          end
        end
      end
    end
  end

  node_cache[:rvalue][start_index] = r0

  r0
end
_nt_selector() click to toggle source
# File lib/logstash/config/grammar.rb, line 3398
def _nt_selector
  start_index = index
  if node_cache[:selector].has_key?(index)
    cached = node_cache[:selector][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_selector_element
    if r1
      s0 << r1
    else
      break
    end
  end
  if s0.empty?
    @index = i0
    r0 = nil
  else
    r0 = instantiate_node(LogStash::Config::AST::Selector,input, i0...index, s0)
  end

  node_cache[:selector][start_index] = r0

  r0
end
_nt_selector_element() click to toggle source
# File lib/logstash/config/grammar.rb, line 3433
def _nt_selector_element
  start_index = index
  if node_cache[:selector_element].has_key?(index)
    cached = node_cache[:selector_element][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
      if has_terminal?('\G[^\\], ]', true, index)
        r3 = true
        @index += 1
      else
        r3 = nil
      end
      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(LogStash::Config::AST::SelectorElement,input, i0...index, s0)
    r0.extend(SelectorElement0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:selector_element][start_index] = r0

  r0
end
_nt_single_quoted_string() click to toggle source
# File lib/logstash/config/grammar.rb, line 1088
def _nt_single_quoted_string
  start_index = index
  if node_cache[:single_quoted_string].has_key?(index)
    cached = node_cache[:single_quoted_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
      i3 = index
      if has_terminal?("\\'", false, index)
        r4 = instantiate_node(SyntaxNode,input, index...(index + 2))
        @index += 2
      else
        terminal_parse_failure("\\'")
        r4 = nil
      end
      if r4
        r3 = r4
      else
        i5, s5 = index, []
        i6 = index
        if has_terminal?("'", false, index)
          r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
          @index += 1
        else
          terminal_parse_failure("'")
          r7 = nil
        end
        if r7
          r6 = nil
        else
          @index = i6
          r6 = instantiate_node(SyntaxNode,input, index...index)
        end
        s5 << r6
        if r6
          if index < input_length
            r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
            @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(SingleQuotedString0)
        else
          @index = i5
          r5 = nil
        end
        if r5
          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 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
  if s0.last
    r0 = instantiate_node(LogStash::Config::AST::String,input, i0...index, s0)
    r0.extend(SingleQuotedString1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:single_quoted_string][start_index] = r0

  r0
end
_nt_string() click to toggle source
# File lib/logstash/config/grammar.rb, line 1194
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

  i0 = index
  r1 = _nt_double_quoted_string
  if r1
    r0 = r1
  else
    r2 = _nt_single_quoted_string
    if r2
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:string][start_index] = r0

  r0
end
_nt_value() click to toggle source
# File lib/logstash/config/grammar.rb, line 817
def _nt_value
  start_index = index
  if node_cache[:value].has_key?(index)
    cached = node_cache[:value][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_plugin
  if r1
    r0 = r1
  else
    r2 = _nt_bareword
    if r2
      r0 = r2
    else
      r3 = _nt_string
      if r3
        r0 = r3
      else
        r4 = _nt_number
        if r4
          r0 = r4
        else
          r5 = _nt_array
          if r5
            r0 = r5
          else
            r6 = _nt_hash
            if r6
              r0 = r6
            else
              @index = i0
              r0 = nil
            end
          end
        end
      end
    end
  end

  node_cache[:value][start_index] = r0

  r0
end
_nt_whitespace() click to toggle source
# File lib/logstash/config/grammar.rb, line 249
def _nt_whitespace
  start_index = index
  if node_cache[:whitespace].has_key?(index)
    cached = node_cache[:whitespace][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[ \\t\\r\\n]', 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(LogStash::Config::AST::Whitespace,input, i0...index, s0)
  end

  node_cache[:whitespace][start_index] = r0

  r0
end
root() click to toggle source
# File lib/logstash/config/grammar.rb, line 11
def root
  @root ||= :config
end