mirror of
https://github.com/elastic/logstash.git
synced 2025-04-24 14:47:19 -04:00
2884 lines
60 KiB
Ruby
2884 lines
60 KiB
Ruby
# Autogenerated from a Treetop grammar. Edits may be lost.
|
|
|
|
|
|
require "treetop"
|
|
require "logstash/config/config_ast"
|
|
|
|
module LogStashConfig
|
|
include Treetop::Runtime
|
|
|
|
def root
|
|
@root ||= :config
|
|
end
|
|
|
|
module Config0
|
|
def _
|
|
elements[0]
|
|
end
|
|
|
|
def plugin_section
|
|
elements[1]
|
|
end
|
|
end
|
|
|
|
module Config1
|
|
def _1
|
|
elements[0]
|
|
end
|
|
|
|
def plugin_section
|
|
elements[1]
|
|
end
|
|
|
|
def _2
|
|
elements[2]
|
|
end
|
|
|
|
def _3
|
|
elements[4]
|
|
end
|
|
end
|
|
|
|
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
|
|
|
|
module Comment0
|
|
end
|
|
|
|
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
|
|
|
|
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
|
|
|
|
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
|
|
|
|
module PluginSection0
|
|
def _1
|
|
elements[0]
|
|
end
|
|
|
|
def branch_or_plugin
|
|
elements[1]
|
|
end
|
|
|
|
def _2
|
|
elements[2]
|
|
end
|
|
end
|
|
|
|
module PluginSection1
|
|
def plugin_type
|
|
elements[0]
|
|
end
|
|
|
|
def _
|
|
elements[1]
|
|
end
|
|
|
|
end
|
|
|
|
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
|
|
s4, i4 = [], index
|
|
loop do
|
|
i5, s5 = index, []
|
|
r6 = _nt__
|
|
s5 << r6
|
|
if r6
|
|
r7 = _nt_branch_or_plugin
|
|
s5 << r7
|
|
if r7
|
|
r8 = _nt__
|
|
s5 << r8
|
|
end
|
|
end
|
|
if s5.last
|
|
r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
|
|
r5.extend(PluginSection0)
|
|
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
|
|
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(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
|
|
|
|
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
|
|
|
|
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
|
|
|
|
module Plugins0
|
|
def _
|
|
elements[0]
|
|
end
|
|
|
|
def plugin
|
|
elements[1]
|
|
end
|
|
end
|
|
|
|
module Plugins1
|
|
def plugin
|
|
elements[0]
|
|
end
|
|
|
|
end
|
|
|
|
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
|
|
|
|
module Plugin0
|
|
def whitespace
|
|
elements[0]
|
|
end
|
|
|
|
def attribute
|
|
elements[1]
|
|
end
|
|
end
|
|
|
|
module Plugin1
|
|
def attribute
|
|
elements[0]
|
|
end
|
|
|
|
end
|
|
|
|
module Plugin2
|
|
def name
|
|
elements[0]
|
|
end
|
|
|
|
def _1
|
|
elements[1]
|
|
end
|
|
|
|
def _2
|
|
elements[3]
|
|
end
|
|
|
|
def attributes
|
|
elements[4]
|
|
end
|
|
|
|
def _3
|
|
elements[5]
|
|
end
|
|
|
|
end
|
|
|
|
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_attribute
|
|
s9 << r11
|
|
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
|
|
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
|
|
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
|
|
|
|
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
|
|
|
|
s0, i0 = [], index
|
|
loop do
|
|
if has_terminal?('\G[A-Za-z0-9_-]', 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::Name,input, i0...index, s0)
|
|
end
|
|
|
|
node_cache[:name][start_index] = r0
|
|
|
|
r0
|
|
end
|
|
|
|
module Attribute0
|
|
def name
|
|
elements[0]
|
|
end
|
|
|
|
def _1
|
|
elements[1]
|
|
end
|
|
|
|
def _2
|
|
elements[3]
|
|
end
|
|
|
|
def value
|
|
elements[4]
|
|
end
|
|
end
|
|
|
|
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
|
|
|
|
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
|
|
|
|
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
|
|
|
|
module Bareword0
|
|
end
|
|
|
|
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
|
|
|
|
module String0
|
|
end
|
|
|
|
module String1
|
|
end
|
|
|
|
module String2
|
|
end
|
|
|
|
module String3
|
|
end
|
|
|
|
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
|
|
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
|
|
s3, i3 = [], index
|
|
loop do
|
|
i4 = index
|
|
if has_terminal?('\"', false, index)
|
|
r5 = instantiate_node(SyntaxNode,input, index...(index + 2))
|
|
@index += 2
|
|
else
|
|
terminal_parse_failure('\"')
|
|
r5 = nil
|
|
end
|
|
if r5
|
|
r4 = r5
|
|
else
|
|
i6, s6 = index, []
|
|
i7 = index
|
|
if has_terminal?('"', false, index)
|
|
r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
|
|
@index += 1
|
|
else
|
|
terminal_parse_failure('"')
|
|
r8 = nil
|
|
end
|
|
if r8
|
|
r7 = nil
|
|
else
|
|
@index = i7
|
|
r7 = instantiate_node(SyntaxNode,input, index...index)
|
|
end
|
|
s6 << r7
|
|
if r7
|
|
if index < input_length
|
|
r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
|
|
@index += 1
|
|
else
|
|
terminal_parse_failure("any character")
|
|
r9 = nil
|
|
end
|
|
s6 << r9
|
|
end
|
|
if s6.last
|
|
r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
|
|
r6.extend(String0)
|
|
else
|
|
@index = i6
|
|
r6 = nil
|
|
end
|
|
if r6
|
|
r4 = r6
|
|
else
|
|
@index = i4
|
|
r4 = nil
|
|
end
|
|
end
|
|
if r4
|
|
s3 << r4
|
|
else
|
|
break
|
|
end
|
|
end
|
|
r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
|
|
s1 << r3
|
|
if r3
|
|
if has_terminal?('"', false, index)
|
|
r10 = instantiate_node(SyntaxNode,input, index...(index + 1))
|
|
@index += 1
|
|
else
|
|
terminal_parse_failure('"')
|
|
r10 = nil
|
|
end
|
|
s1 << r10
|
|
end
|
|
end
|
|
if s1.last
|
|
r1 = instantiate_node(LogStash::Config::AST::String,input, i1...index, s1)
|
|
r1.extend(String1)
|
|
else
|
|
@index = i1
|
|
r1 = nil
|
|
end
|
|
if r1
|
|
r0 = r1
|
|
else
|
|
i11, s11 = index, []
|
|
if has_terminal?("'", false, index)
|
|
r12 = instantiate_node(SyntaxNode,input, index...(index + 1))
|
|
@index += 1
|
|
else
|
|
terminal_parse_failure("'")
|
|
r12 = nil
|
|
end
|
|
s11 << r12
|
|
if r12
|
|
s13, i13 = [], index
|
|
loop do
|
|
i14 = index
|
|
if has_terminal?("\\'", false, index)
|
|
r15 = instantiate_node(SyntaxNode,input, index...(index + 2))
|
|
@index += 2
|
|
else
|
|
terminal_parse_failure("\\'")
|
|
r15 = nil
|
|
end
|
|
if r15
|
|
r14 = r15
|
|
else
|
|
i16, s16 = index, []
|
|
i17 = index
|
|
if has_terminal?("'", false, index)
|
|
r18 = instantiate_node(SyntaxNode,input, index...(index + 1))
|
|
@index += 1
|
|
else
|
|
terminal_parse_failure("'")
|
|
r18 = nil
|
|
end
|
|
if r18
|
|
r17 = nil
|
|
else
|
|
@index = i17
|
|
r17 = instantiate_node(SyntaxNode,input, index...index)
|
|
end
|
|
s16 << r17
|
|
if r17
|
|
if index < input_length
|
|
r19 = instantiate_node(SyntaxNode,input, index...(index + 1))
|
|
@index += 1
|
|
else
|
|
terminal_parse_failure("any character")
|
|
r19 = nil
|
|
end
|
|
s16 << r19
|
|
end
|
|
if s16.last
|
|
r16 = instantiate_node(SyntaxNode,input, i16...index, s16)
|
|
r16.extend(String2)
|
|
else
|
|
@index = i16
|
|
r16 = nil
|
|
end
|
|
if r16
|
|
r14 = r16
|
|
else
|
|
@index = i14
|
|
r14 = nil
|
|
end
|
|
end
|
|
if r14
|
|
s13 << r14
|
|
else
|
|
break
|
|
end
|
|
end
|
|
r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
|
|
s11 << r13
|
|
if r13
|
|
if has_terminal?("'", false, index)
|
|
r20 = instantiate_node(SyntaxNode,input, index...(index + 1))
|
|
@index += 1
|
|
else
|
|
terminal_parse_failure("'")
|
|
r20 = nil
|
|
end
|
|
s11 << r20
|
|
end
|
|
end
|
|
if s11.last
|
|
r11 = instantiate_node(LogStash::Config::AST::String,input, i11...index, s11)
|
|
r11.extend(String3)
|
|
else
|
|
@index = i11
|
|
r11 = nil
|
|
end
|
|
if r11
|
|
r0 = r11
|
|
else
|
|
@index = i0
|
|
r0 = nil
|
|
end
|
|
end
|
|
|
|
node_cache[:string][start_index] = r0
|
|
|
|
r0
|
|
end
|
|
|
|
module Number0
|
|
end
|
|
|
|
module Number1
|
|
end
|
|
|
|
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
|
|
|
|
module Array0
|
|
def _1
|
|
elements[0]
|
|
end
|
|
|
|
def _2
|
|
elements[2]
|
|
end
|
|
|
|
def value
|
|
elements[3]
|
|
end
|
|
end
|
|
|
|
module Array1
|
|
def value
|
|
elements[0]
|
|
end
|
|
|
|
end
|
|
|
|
module Array2
|
|
def _1
|
|
elements[1]
|
|
end
|
|
|
|
def _2
|
|
elements[3]
|
|
end
|
|
|
|
end
|
|
|
|
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
|
|
|
|
module Hash0
|
|
def _1
|
|
elements[1]
|
|
end
|
|
|
|
def _2
|
|
elements[3]
|
|
end
|
|
|
|
end
|
|
|
|
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
|
|
|
|
module Hashentries0
|
|
def whitespace
|
|
elements[0]
|
|
end
|
|
|
|
def hashentry
|
|
elements[1]
|
|
end
|
|
end
|
|
|
|
module Hashentries1
|
|
def hashentry
|
|
elements[0]
|
|
end
|
|
|
|
end
|
|
|
|
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
|
|
|
|
module Hashentry0
|
|
def name
|
|
elements[0]
|
|
end
|
|
|
|
def _1
|
|
elements[1]
|
|
end
|
|
|
|
def _2
|
|
elements[3]
|
|
end
|
|
|
|
def value
|
|
elements[4]
|
|
end
|
|
end
|
|
|
|
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
|
|
|
|
module Branch0
|
|
def _
|
|
elements[0]
|
|
end
|
|
|
|
def elsif
|
|
elements[1]
|
|
end
|
|
end
|
|
|
|
module Branch1
|
|
def _
|
|
elements[0]
|
|
end
|
|
|
|
def else
|
|
elements[1]
|
|
end
|
|
end
|
|
|
|
module Branch2
|
|
def if
|
|
elements[0]
|
|
end
|
|
|
|
end
|
|
|
|
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_elsif
|
|
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
|
|
|
|
module If0
|
|
def branch_or_plugin
|
|
elements[0]
|
|
end
|
|
|
|
def _
|
|
elements[1]
|
|
end
|
|
end
|
|
|
|
module If1
|
|
def _1
|
|
elements[1]
|
|
end
|
|
|
|
def condition
|
|
elements[2]
|
|
end
|
|
|
|
def _2
|
|
elements[3]
|
|
end
|
|
|
|
def _3
|
|
elements[5]
|
|
end
|
|
|
|
end
|
|
|
|
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
|
|
|
|
module Elsif0
|
|
def branch_or_plugin
|
|
elements[0]
|
|
end
|
|
|
|
def _
|
|
elements[1]
|
|
end
|
|
end
|
|
|
|
module Elsif1
|
|
def _1
|
|
elements[1]
|
|
end
|
|
|
|
def condition
|
|
elements[2]
|
|
end
|
|
|
|
def _2
|
|
elements[3]
|
|
end
|
|
|
|
def _3
|
|
elements[5]
|
|
end
|
|
|
|
end
|
|
|
|
def _nt_elsif
|
|
start_index = index
|
|
if node_cache[:elsif].has_key?(index)
|
|
cached = node_cache[:elsif][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?("elsif", false, index)
|
|
r1 = instantiate_node(SyntaxNode,input, index...(index + 5))
|
|
@index += 5
|
|
else
|
|
terminal_parse_failure("elsif")
|
|
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(Elsif0)
|
|
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::Elsif,input, i0...index, s0)
|
|
r0.extend(Elsif1)
|
|
else
|
|
@index = i0
|
|
r0 = nil
|
|
end
|
|
|
|
node_cache[:elsif][start_index] = r0
|
|
|
|
r0
|
|
end
|
|
|
|
module Else0
|
|
def branch_or_plugin
|
|
elements[0]
|
|
end
|
|
|
|
def _
|
|
elements[1]
|
|
end
|
|
end
|
|
|
|
module Else1
|
|
def _1
|
|
elements[1]
|
|
end
|
|
|
|
def _2
|
|
elements[3]
|
|
end
|
|
|
|
end
|
|
|
|
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
|
|
|
|
module Condition0
|
|
def _1
|
|
elements[0]
|
|
end
|
|
|
|
def boolean_operator
|
|
elements[1]
|
|
end
|
|
|
|
def _2
|
|
elements[2]
|
|
end
|
|
|
|
def expression
|
|
elements[3]
|
|
end
|
|
end
|
|
|
|
module Condition1
|
|
def expression
|
|
elements[0]
|
|
end
|
|
|
|
end
|
|
|
|
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
|
|
|
|
module Expression0
|
|
def _1
|
|
elements[1]
|
|
end
|
|
|
|
def condition
|
|
elements[2]
|
|
end
|
|
|
|
def _2
|
|
elements[3]
|
|
end
|
|
|
|
end
|
|
|
|
module Expression1
|
|
def _
|
|
elements[1]
|
|
end
|
|
|
|
def condition
|
|
elements[2]
|
|
end
|
|
end
|
|
|
|
module Expression2
|
|
def rvalue1
|
|
elements[0]
|
|
end
|
|
|
|
def _1
|
|
elements[1]
|
|
end
|
|
|
|
def comparison
|
|
elements[2]
|
|
end
|
|
|
|
def _2
|
|
elements[3]
|
|
end
|
|
|
|
def rvalue2
|
|
elements[4]
|
|
end
|
|
end
|
|
|
|
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
|
|
i7, s7 = index, []
|
|
if has_terminal?("!", false, index)
|
|
r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
|
|
@index += 1
|
|
else
|
|
terminal_parse_failure("!")
|
|
r8 = nil
|
|
end
|
|
s7 << r8
|
|
if r8
|
|
r9 = _nt__
|
|
s7 << r9
|
|
if r9
|
|
r10 = _nt_condition
|
|
s7 << r10
|
|
end
|
|
end
|
|
if s7.last
|
|
r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
|
|
r7.extend(Expression1)
|
|
else
|
|
@index = i7
|
|
r7 = nil
|
|
end
|
|
if r7
|
|
r0 = r7
|
|
r0.extend(LogStash::Config::AST::Expression)
|
|
else
|
|
i11, s11 = index, []
|
|
r12 = _nt_rvalue
|
|
s11 << r12
|
|
if r12
|
|
r13 = _nt__
|
|
s11 << r13
|
|
if r13
|
|
r14 = _nt_comparison
|
|
s11 << r14
|
|
if r14
|
|
r15 = _nt__
|
|
s11 << r15
|
|
if r15
|
|
r16 = _nt_rvalue
|
|
s11 << r16
|
|
end
|
|
end
|
|
end
|
|
end
|
|
if s11.last
|
|
r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
|
|
r11.extend(Expression2)
|
|
else
|
|
@index = i11
|
|
r11 = nil
|
|
end
|
|
if r11
|
|
r0 = r11
|
|
r0.extend(LogStash::Config::AST::Expression)
|
|
else
|
|
r17 = _nt_rvalue
|
|
if r17
|
|
r0 = r17
|
|
r0.extend(LogStash::Config::AST::Expression)
|
|
else
|
|
@index = i0
|
|
r0 = nil
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
node_cache[:expression][start_index] = r0
|
|
|
|
r0
|
|
end
|
|
|
|
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
|
|
@index = i0
|
|
r0 = nil
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
node_cache[:rvalue][start_index] = r0
|
|
|
|
r0
|
|
end
|
|
|
|
module MethodCall0
|
|
def _1
|
|
elements[0]
|
|
end
|
|
|
|
def _2
|
|
elements[2]
|
|
end
|
|
|
|
def rvalue
|
|
elements[3]
|
|
end
|
|
end
|
|
|
|
module MethodCall1
|
|
def rvalue
|
|
elements[0]
|
|
end
|
|
|
|
end
|
|
|
|
module MethodCall2
|
|
def method
|
|
elements[0]
|
|
end
|
|
|
|
def _1
|
|
elements[1]
|
|
end
|
|
|
|
def _2
|
|
elements[3]
|
|
end
|
|
|
|
def _3
|
|
elements[5]
|
|
end
|
|
|
|
end
|
|
|
|
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
|
|
|
|
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
|
|
|
|
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
|
|
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 + 1))
|
|
@index += 1
|
|
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 + 1))
|
|
@index += 1
|
|
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 + 2))
|
|
@index += 2
|
|
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 + 2))
|
|
@index += 2
|
|
else
|
|
terminal_parse_failure(">=")
|
|
r6 = nil
|
|
end
|
|
if r6
|
|
r0 = r6
|
|
r0.extend(LogStash::Config::AST::ComparisonOperator)
|
|
else
|
|
if has_terminal?("=~", false, index)
|
|
r7 = instantiate_node(SyntaxNode,input, index...(index + 2))
|
|
@index += 2
|
|
else
|
|
terminal_parse_failure("=~")
|
|
r7 = nil
|
|
end
|
|
if r7
|
|
r0 = r7
|
|
r0.extend(LogStash::Config::AST::ComparisonOperator)
|
|
else
|
|
if has_terminal?("!~", false, index)
|
|
r8 = instantiate_node(SyntaxNode,input, index...(index + 2))
|
|
@index += 2
|
|
else
|
|
terminal_parse_failure("!~")
|
|
r8 = nil
|
|
end
|
|
if r8
|
|
r0 = r8
|
|
r0.extend(LogStash::Config::AST::ComparisonOperator)
|
|
else
|
|
if has_terminal?("in", false, index)
|
|
r9 = instantiate_node(SyntaxNode,input, index...(index + 2))
|
|
@index += 2
|
|
else
|
|
terminal_parse_failure("in")
|
|
r9 = nil
|
|
end
|
|
if r9
|
|
r0 = r9
|
|
r0.extend(LogStash::Config::AST::ComparisonOperator)
|
|
else
|
|
@index = i0
|
|
r0 = nil
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
node_cache[:comparison][start_index] = r0
|
|
|
|
r0
|
|
end
|
|
|
|
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
|
|
|
|
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
|
|
|
|
module SelectorElement0
|
|
end
|
|
|
|
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
|
|
|
|
end
|
|
|
|
class LogStashConfigParser < Treetop::Runtime::CompiledParser
|
|
include LogStashConfig
|
|
end
|
|
|