You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4299 lines
162 KiB
Plaintext
4299 lines
162 KiB
Plaintext
Created by PLY version 3.2 (http://www.dabeaz.com/ply)
|
|
|
|
Grammar
|
|
|
|
Rule 0 S' -> file
|
|
Rule 1 file -> pipeline_stage_1n
|
|
Rule 2 pipeline_stage_1n -> pipeline_stage pipeline_stage_1n
|
|
Rule 3 pipeline_stage_1n -> <empty>
|
|
Rule 4 pipeline_stage -> splitter
|
|
Rule 5 pipeline_stage -> filter
|
|
Rule 6 pipeline_stage -> composite_filter
|
|
Rule 7 pipeline_stage -> branch
|
|
Rule 8 pipeline_stage -> ungrouper
|
|
Rule 9 pipeline_stage -> grouper
|
|
Rule 10 pipeline_stage -> group_filter
|
|
Rule 11 pipeline_stage -> merger
|
|
Rule 12 splitter -> splitterKeyword id { }
|
|
Rule 13 filter -> filterKeyword id { filter_rule_1n }
|
|
Rule 14 composite_filter -> filterKeyword id { filter_ref_rule_1n }
|
|
Rule 15 group_filter -> groupFilterKeyword id { filter_rule_1n }
|
|
Rule 16 filter_rule_1n -> filter_rule filter_rule_1n
|
|
Rule 17 filter_rule_1n -> <empty>
|
|
Rule 18 filter_rule -> or_rule
|
|
Rule 19 filter_ref_rule_1n -> filter_ref_rule filter_ref_rule_1n
|
|
Rule 20 filter_ref_rule_1n -> filter_ref_rule
|
|
Rule 21 filter_ref_rule -> or_id
|
|
Rule 22 or_id -> not_id opt_or_id
|
|
Rule 23 opt_or_id -> ORKeyword not_id opt_or_id
|
|
Rule 24 opt_or_id -> <empty>
|
|
Rule 25 not_id -> NOTKeyword id
|
|
Rule 26 not_id -> id
|
|
Rule 27 or_rule -> rule_or_not opt_rule
|
|
Rule 28 opt_rule -> ORKeyword rule_or_not opt_rule
|
|
Rule 29 opt_rule -> <empty>
|
|
Rule 30 rule_or_not -> rule
|
|
Rule 31 rule_or_not -> NOTKeyword rule
|
|
Rule 32 rule -> infix_rule
|
|
Rule 33 rule -> prefix_rule
|
|
Rule 34 infix_rule -> arg op arg
|
|
Rule 35 op -> EQ
|
|
Rule 36 op -> LT
|
|
Rule 37 op -> GT
|
|
Rule 38 op -> LTEQ
|
|
Rule 39 op -> GTEQ
|
|
Rule 40 op -> ML
|
|
Rule 41 op -> MG
|
|
Rule 42 op -> inKeyword
|
|
Rule 43 op -> notinKeyword
|
|
Rule 44 prefix_rule -> id ( args )
|
|
Rule 45 prefix_rule -> bitANDKeyword ( args )
|
|
Rule 46 prefix_rule -> bitORKeyword ( args )
|
|
Rule 47 args -> arg , args
|
|
Rule 48 args -> arg
|
|
Rule 49 args -> <empty>
|
|
Rule 50 arg -> id
|
|
Rule 51 arg -> IPv4
|
|
Rule 52 arg -> IPv6
|
|
Rule 53 arg -> CIDR
|
|
Rule 54 arg -> MAC
|
|
Rule 55 arg -> int
|
|
Rule 56 arg -> float
|
|
Rule 57 arg -> hex
|
|
Rule 58 arg -> prefix_rule
|
|
Rule 59 arg -> string
|
|
Rule 60 CIDR -> IPv4 / int
|
|
Rule 61 CIDR -> IPv6 / int
|
|
Rule 62 branch -> id arrow mid_branch
|
|
Rule 63 branch -> string arrow mid_branch
|
|
Rule 64 branch -> id branchKeyword mid_branch
|
|
Rule 65 mid_branch -> id arrow mid_branch
|
|
Rule 66 mid_branch -> end_branch
|
|
Rule 67 end_branch -> id
|
|
Rule 68 end_branch -> string
|
|
Rule 69 arrow -> - GT
|
|
Rule 70 ungrouper -> ungrouperKeyword id { }
|
|
Rule 71 grouper -> grouperKeyword id { module1_n aggregate }
|
|
Rule 72 module1_n -> module module1_n
|
|
Rule 73 module1_n -> <empty>
|
|
Rule 74 module -> moduleKeyword id { grouper_rule1_n }
|
|
Rule 75 grouper_rule1_n -> grouper_rule grouper_rule1_n
|
|
Rule 76 grouper_rule1_n -> <empty>
|
|
Rule 77 grouper_rule -> id grouper_op id
|
|
Rule 78 grouper_rule -> id grouper_op id deltaKeyword delta_arg
|
|
Rule 79 grouper_rule -> id grouper_op id rdeltaKeyword delta_arg
|
|
Rule 80 grouper_op -> EQ
|
|
Rule 81 grouper_op -> LT
|
|
Rule 82 grouper_op -> GT
|
|
Rule 83 grouper_op -> GTEQ
|
|
Rule 84 grouper_op -> LTEQ
|
|
Rule 85 delta_arg -> time
|
|
Rule 86 delta_arg -> int
|
|
Rule 87 time -> int sKeyword
|
|
Rule 88 time -> int msKeyword
|
|
Rule 89 time -> int minKeyword
|
|
Rule 90 aggregate -> aggregateKeyword aggr1_n
|
|
Rule 91 aggr1_n -> aggr opt_aggr
|
|
Rule 92 opt_aggr -> , aggr opt_aggr
|
|
Rule 93 opt_aggr -> <empty>
|
|
Rule 94 aggr -> aggr_op ( id_or_qid ) asKeyword id
|
|
Rule 95 aggr -> id_or_qid asKeyword id
|
|
Rule 96 aggr -> id_or_qid
|
|
Rule 97 qid -> id . id
|
|
Rule 98 id_or_qid -> id
|
|
Rule 99 id_or_qid -> qid
|
|
Rule 100 aggr_op -> minKeyword
|
|
Rule 101 aggr_op -> maxKeyword
|
|
Rule 102 aggr_op -> sumKeyword
|
|
Rule 103 aggr_op -> avgKeyword
|
|
Rule 104 aggr_op -> unionKeyword
|
|
Rule 105 aggr_op -> countKeyword
|
|
Rule 106 aggr_op -> bitANDKeyword
|
|
Rule 107 aggr_op -> bitORKeyword
|
|
Rule 108 merger -> mergerKeyword id { merger_module1_n export }
|
|
Rule 109 merger_module1_n -> merger_module merger_module1_n
|
|
Rule 110 merger_module1_n -> <empty>
|
|
Rule 111 merger_module -> moduleKeyword id { merger_branches merger_rule1_n }
|
|
Rule 112 merger_branches -> branchesKeyword branches1_n
|
|
Rule 113 branches1_n -> id , branches1_n
|
|
Rule 114 branches1_n -> id
|
|
Rule 115 export -> exportKeyword id
|
|
Rule 116 merger_rule1_n -> merger_rule merger_rule1_n
|
|
Rule 117 merger_rule1_n -> <empty>
|
|
Rule 118 merger_rule -> merger_prefix_rule
|
|
Rule 119 merger_rule -> merger_infix_rule
|
|
Rule 120 merger_rule -> NOTKeyword merger_prefix_rule
|
|
Rule 121 merger_rule -> NOTKeyword merger_infix_rule
|
|
Rule 122 merger_infix_rule -> qid_arg op qid_arg
|
|
Rule 123 merger_prefix_rule -> id ( qid_args )
|
|
Rule 124 qid_args -> qid_arg , qid_args
|
|
Rule 125 qid_args -> qid_arg
|
|
Rule 126 qid_args -> <empty>
|
|
Rule 127 qid_arg -> qid
|
|
Rule 128 qid_arg -> IPv4
|
|
Rule 129 qid_arg -> IPv6
|
|
Rule 130 qid_arg -> CIDR
|
|
Rule 131 qid_arg -> MAC
|
|
Rule 132 qid_arg -> int
|
|
Rule 133 qid_arg -> float
|
|
Rule 134 qid_arg -> hex
|
|
Rule 135 qid_arg -> merger_prefix_rule
|
|
Rule 136 qid_arg -> string
|
|
Rule 137 merger_rule -> allen_rule opt_or_allen_rule
|
|
Rule 138 opt_or_allen_rule -> ORKeyword allen_rule opt_or_allen_rule
|
|
Rule 139 opt_or_allen_rule -> <empty>
|
|
Rule 140 allen_rule -> id allen_op id opt_allen_delta
|
|
Rule 141 opt_allen_delta -> deltaKeyword time
|
|
Rule 142 opt_allen_delta -> <empty>
|
|
Rule 143 allen_op -> LT
|
|
Rule 144 allen_op -> GT
|
|
Rule 145 allen_op -> EQ
|
|
Rule 146 allen_op -> mKeyword
|
|
Rule 147 allen_op -> miKeyword
|
|
Rule 148 allen_op -> oKeyword
|
|
Rule 149 allen_op -> oiKeyword
|
|
Rule 150 allen_op -> sKeyword
|
|
Rule 151 allen_op -> siKeyword
|
|
Rule 152 allen_op -> dKeyword
|
|
Rule 153 allen_op -> diKeyword
|
|
Rule 154 allen_op -> fKeyword
|
|
Rule 155 allen_op -> fiKeyword
|
|
Rule 156 allen_op -> eqKeyword
|
|
|
|
Terminals, with rules where they appear
|
|
|
|
( : 44 45 46 94 123
|
|
) : 44 45 46 94 123
|
|
, : 47 92 113 124
|
|
- : 69
|
|
. : 97
|
|
/ : 60 61
|
|
EQ : 35 80 145
|
|
GT : 37 69 82 144
|
|
GTEQ : 39 83
|
|
IPv4 : 51 60 128
|
|
IPv6 : 52 61 129
|
|
LT : 36 81 143
|
|
LTEQ : 38 84
|
|
MAC : 54 131
|
|
MG : 41
|
|
ML : 40
|
|
NOTKeyword : 25 31 120 121
|
|
ORKeyword : 23 28 138
|
|
aggregateKeyword : 90
|
|
asKeyword : 94 95
|
|
avgKeyword : 103
|
|
bitANDKeyword : 45 106
|
|
bitORKeyword : 46 107
|
|
branchKeyword : 64
|
|
branchesKeyword : 112
|
|
countKeyword : 105
|
|
dKeyword : 152
|
|
deltaKeyword : 78 141
|
|
diKeyword : 153
|
|
eqKeyword : 156
|
|
error :
|
|
exportKeyword : 115
|
|
fKeyword : 154
|
|
fiKeyword : 155
|
|
filterKeyword : 13 14
|
|
float : 56 133
|
|
groupFilterKeyword : 15
|
|
grouperKeyword : 71
|
|
hex : 57 134
|
|
id : 12 13 14 15 25 26 44 50 62 64 65 67 70 71 74 77 77 78 78 79 79 94 95 97 97 98 108 111 113 114 115 123 140 140
|
|
inKeyword : 42
|
|
int : 55 60 61 86 87 88 89 132
|
|
mKeyword : 146
|
|
maxKeyword : 101
|
|
mergerKeyword : 108
|
|
miKeyword : 147
|
|
minKeyword : 89 100
|
|
moduleKeyword : 74 111
|
|
msKeyword : 88
|
|
notinKeyword : 43
|
|
oKeyword : 148
|
|
oiKeyword : 149
|
|
rdeltaKeyword : 79
|
|
sKeyword : 87 150
|
|
siKeyword : 151
|
|
splitterKeyword : 12
|
|
string : 59 63 68 136
|
|
sumKeyword : 102
|
|
ungrouperKeyword : 70
|
|
unionKeyword : 104
|
|
{ : 12 13 14 15 70 71 74 108 111
|
|
} : 12 13 14 15 70 71 74 108 111
|
|
|
|
Nonterminals, with rules where they appear
|
|
|
|
CIDR : 53 130
|
|
aggr : 91 92
|
|
aggr1_n : 90
|
|
aggr_op : 94
|
|
aggregate : 71
|
|
allen_op : 140
|
|
allen_rule : 137 138
|
|
arg : 34 34 47 48
|
|
args : 44 45 46 47
|
|
arrow : 62 63 65
|
|
branch : 7
|
|
branches1_n : 112 113
|
|
composite_filter : 6
|
|
delta_arg : 78 79
|
|
end_branch : 66
|
|
export : 108
|
|
file : 0
|
|
filter : 5
|
|
filter_ref_rule : 19 20
|
|
filter_ref_rule_1n : 14 19
|
|
filter_rule : 16
|
|
filter_rule_1n : 13 15 16
|
|
group_filter : 10
|
|
grouper : 9
|
|
grouper_op : 77 78 79
|
|
grouper_rule : 75
|
|
grouper_rule1_n : 74 75
|
|
id_or_qid : 94 95 96
|
|
infix_rule : 32
|
|
merger : 11
|
|
merger_branches : 111
|
|
merger_infix_rule : 119 121
|
|
merger_module : 109
|
|
merger_module1_n : 108 109
|
|
merger_prefix_rule : 118 120 135
|
|
merger_rule : 116
|
|
merger_rule1_n : 111 116
|
|
mid_branch : 62 63 64 65
|
|
module : 72
|
|
module1_n : 71 72
|
|
not_id : 22 23
|
|
op : 34 122
|
|
opt_aggr : 91 92
|
|
opt_allen_delta : 140
|
|
opt_or_allen_rule : 137 138
|
|
opt_or_id : 22 23
|
|
opt_rule : 27 28
|
|
or_id : 21
|
|
or_rule : 18
|
|
pipeline_stage : 2
|
|
pipeline_stage_1n : 1 2
|
|
prefix_rule : 33 58
|
|
qid : 99 127
|
|
qid_arg : 122 122 124 125
|
|
qid_args : 123 124
|
|
rule : 30 31
|
|
rule_or_not : 27 28
|
|
splitter : 4
|
|
time : 85 141
|
|
ungrouper : 8
|
|
|
|
Parsing method: LALR
|
|
|
|
state 0
|
|
|
|
(0) S' -> . file
|
|
(1) file -> . pipeline_stage_1n
|
|
(2) pipeline_stage_1n -> . pipeline_stage pipeline_stage_1n
|
|
(3) pipeline_stage_1n -> .
|
|
(4) pipeline_stage -> . splitter
|
|
(5) pipeline_stage -> . filter
|
|
(6) pipeline_stage -> . composite_filter
|
|
(7) pipeline_stage -> . branch
|
|
(8) pipeline_stage -> . ungrouper
|
|
(9) pipeline_stage -> . grouper
|
|
(10) pipeline_stage -> . group_filter
|
|
(11) pipeline_stage -> . merger
|
|
(12) splitter -> . splitterKeyword id { }
|
|
(13) filter -> . filterKeyword id { filter_rule_1n }
|
|
(14) composite_filter -> . filterKeyword id { filter_ref_rule_1n }
|
|
(62) branch -> . id arrow mid_branch
|
|
(63) branch -> . string arrow mid_branch
|
|
(64) branch -> . id branchKeyword mid_branch
|
|
(70) ungrouper -> . ungrouperKeyword id { }
|
|
(71) grouper -> . grouperKeyword id { module1_n aggregate }
|
|
(15) group_filter -> . groupFilterKeyword id { filter_rule_1n }
|
|
(108) merger -> . mergerKeyword id { merger_module1_n export }
|
|
|
|
$end reduce using rule 3 (pipeline_stage_1n -> .)
|
|
splitterKeyword shift and go to state 10
|
|
filterKeyword shift and go to state 9
|
|
id shift and go to state 5
|
|
string shift and go to state 13
|
|
ungrouperKeyword shift and go to state 15
|
|
grouperKeyword shift and go to state 4
|
|
groupFilterKeyword shift and go to state 17
|
|
mergerKeyword shift and go to state 14
|
|
|
|
splitter shift and go to state 16
|
|
branch shift and go to state 11
|
|
ungrouper shift and go to state 6
|
|
grouper shift and go to state 7
|
|
merger shift and go to state 8
|
|
pipeline_stage shift and go to state 1
|
|
group_filter shift and go to state 2
|
|
filter shift and go to state 18
|
|
composite_filter shift and go to state 19
|
|
file shift and go to state 3
|
|
pipeline_stage_1n shift and go to state 12
|
|
|
|
state 1
|
|
|
|
(2) pipeline_stage_1n -> pipeline_stage . pipeline_stage_1n
|
|
(2) pipeline_stage_1n -> . pipeline_stage pipeline_stage_1n
|
|
(3) pipeline_stage_1n -> .
|
|
(4) pipeline_stage -> . splitter
|
|
(5) pipeline_stage -> . filter
|
|
(6) pipeline_stage -> . composite_filter
|
|
(7) pipeline_stage -> . branch
|
|
(8) pipeline_stage -> . ungrouper
|
|
(9) pipeline_stage -> . grouper
|
|
(10) pipeline_stage -> . group_filter
|
|
(11) pipeline_stage -> . merger
|
|
(12) splitter -> . splitterKeyword id { }
|
|
(13) filter -> . filterKeyword id { filter_rule_1n }
|
|
(14) composite_filter -> . filterKeyword id { filter_ref_rule_1n }
|
|
(62) branch -> . id arrow mid_branch
|
|
(63) branch -> . string arrow mid_branch
|
|
(64) branch -> . id branchKeyword mid_branch
|
|
(70) ungrouper -> . ungrouperKeyword id { }
|
|
(71) grouper -> . grouperKeyword id { module1_n aggregate }
|
|
(15) group_filter -> . groupFilterKeyword id { filter_rule_1n }
|
|
(108) merger -> . mergerKeyword id { merger_module1_n export }
|
|
|
|
$end reduce using rule 3 (pipeline_stage_1n -> .)
|
|
splitterKeyword shift and go to state 10
|
|
filterKeyword shift and go to state 9
|
|
id shift and go to state 5
|
|
string shift and go to state 13
|
|
ungrouperKeyword shift and go to state 15
|
|
grouperKeyword shift and go to state 4
|
|
groupFilterKeyword shift and go to state 17
|
|
mergerKeyword shift and go to state 14
|
|
|
|
splitter shift and go to state 16
|
|
ungrouper shift and go to state 6
|
|
grouper shift and go to state 7
|
|
merger shift and go to state 8
|
|
pipeline_stage shift and go to state 1
|
|
group_filter shift and go to state 2
|
|
filter shift and go to state 18
|
|
composite_filter shift and go to state 19
|
|
branch shift and go to state 11
|
|
pipeline_stage_1n shift and go to state 20
|
|
|
|
state 2
|
|
|
|
(10) pipeline_stage -> group_filter .
|
|
|
|
splitterKeyword reduce using rule 10 (pipeline_stage -> group_filter .)
|
|
filterKeyword reduce using rule 10 (pipeline_stage -> group_filter .)
|
|
id reduce using rule 10 (pipeline_stage -> group_filter .)
|
|
string reduce using rule 10 (pipeline_stage -> group_filter .)
|
|
ungrouperKeyword reduce using rule 10 (pipeline_stage -> group_filter .)
|
|
grouperKeyword reduce using rule 10 (pipeline_stage -> group_filter .)
|
|
groupFilterKeyword reduce using rule 10 (pipeline_stage -> group_filter .)
|
|
mergerKeyword reduce using rule 10 (pipeline_stage -> group_filter .)
|
|
$end reduce using rule 10 (pipeline_stage -> group_filter .)
|
|
|
|
|
|
state 3
|
|
|
|
(0) S' -> file .
|
|
|
|
|
|
|
|
state 4
|
|
|
|
(71) grouper -> grouperKeyword . id { module1_n aggregate }
|
|
|
|
id shift and go to state 21
|
|
|
|
|
|
state 5
|
|
|
|
(62) branch -> id . arrow mid_branch
|
|
(64) branch -> id . branchKeyword mid_branch
|
|
(69) arrow -> . - GT
|
|
|
|
branchKeyword shift and go to state 24
|
|
- shift and go to state 22
|
|
|
|
arrow shift and go to state 23
|
|
|
|
state 6
|
|
|
|
(8) pipeline_stage -> ungrouper .
|
|
|
|
splitterKeyword reduce using rule 8 (pipeline_stage -> ungrouper .)
|
|
filterKeyword reduce using rule 8 (pipeline_stage -> ungrouper .)
|
|
id reduce using rule 8 (pipeline_stage -> ungrouper .)
|
|
string reduce using rule 8 (pipeline_stage -> ungrouper .)
|
|
ungrouperKeyword reduce using rule 8 (pipeline_stage -> ungrouper .)
|
|
grouperKeyword reduce using rule 8 (pipeline_stage -> ungrouper .)
|
|
groupFilterKeyword reduce using rule 8 (pipeline_stage -> ungrouper .)
|
|
mergerKeyword reduce using rule 8 (pipeline_stage -> ungrouper .)
|
|
$end reduce using rule 8 (pipeline_stage -> ungrouper .)
|
|
|
|
|
|
state 7
|
|
|
|
(9) pipeline_stage -> grouper .
|
|
|
|
splitterKeyword reduce using rule 9 (pipeline_stage -> grouper .)
|
|
filterKeyword reduce using rule 9 (pipeline_stage -> grouper .)
|
|
id reduce using rule 9 (pipeline_stage -> grouper .)
|
|
string reduce using rule 9 (pipeline_stage -> grouper .)
|
|
ungrouperKeyword reduce using rule 9 (pipeline_stage -> grouper .)
|
|
grouperKeyword reduce using rule 9 (pipeline_stage -> grouper .)
|
|
groupFilterKeyword reduce using rule 9 (pipeline_stage -> grouper .)
|
|
mergerKeyword reduce using rule 9 (pipeline_stage -> grouper .)
|
|
$end reduce using rule 9 (pipeline_stage -> grouper .)
|
|
|
|
|
|
state 8
|
|
|
|
(11) pipeline_stage -> merger .
|
|
|
|
splitterKeyword reduce using rule 11 (pipeline_stage -> merger .)
|
|
filterKeyword reduce using rule 11 (pipeline_stage -> merger .)
|
|
id reduce using rule 11 (pipeline_stage -> merger .)
|
|
string reduce using rule 11 (pipeline_stage -> merger .)
|
|
ungrouperKeyword reduce using rule 11 (pipeline_stage -> merger .)
|
|
grouperKeyword reduce using rule 11 (pipeline_stage -> merger .)
|
|
groupFilterKeyword reduce using rule 11 (pipeline_stage -> merger .)
|
|
mergerKeyword reduce using rule 11 (pipeline_stage -> merger .)
|
|
$end reduce using rule 11 (pipeline_stage -> merger .)
|
|
|
|
|
|
state 9
|
|
|
|
(13) filter -> filterKeyword . id { filter_rule_1n }
|
|
(14) composite_filter -> filterKeyword . id { filter_ref_rule_1n }
|
|
|
|
id shift and go to state 25
|
|
|
|
|
|
state 10
|
|
|
|
(12) splitter -> splitterKeyword . id { }
|
|
|
|
id shift and go to state 26
|
|
|
|
|
|
state 11
|
|
|
|
(7) pipeline_stage -> branch .
|
|
|
|
splitterKeyword reduce using rule 7 (pipeline_stage -> branch .)
|
|
filterKeyword reduce using rule 7 (pipeline_stage -> branch .)
|
|
id reduce using rule 7 (pipeline_stage -> branch .)
|
|
string reduce using rule 7 (pipeline_stage -> branch .)
|
|
ungrouperKeyword reduce using rule 7 (pipeline_stage -> branch .)
|
|
grouperKeyword reduce using rule 7 (pipeline_stage -> branch .)
|
|
groupFilterKeyword reduce using rule 7 (pipeline_stage -> branch .)
|
|
mergerKeyword reduce using rule 7 (pipeline_stage -> branch .)
|
|
$end reduce using rule 7 (pipeline_stage -> branch .)
|
|
|
|
|
|
state 12
|
|
|
|
(1) file -> pipeline_stage_1n .
|
|
|
|
$end reduce using rule 1 (file -> pipeline_stage_1n .)
|
|
|
|
|
|
state 13
|
|
|
|
(63) branch -> string . arrow mid_branch
|
|
(69) arrow -> . - GT
|
|
|
|
- shift and go to state 22
|
|
|
|
arrow shift and go to state 27
|
|
|
|
state 14
|
|
|
|
(108) merger -> mergerKeyword . id { merger_module1_n export }
|
|
|
|
id shift and go to state 28
|
|
|
|
|
|
state 15
|
|
|
|
(70) ungrouper -> ungrouperKeyword . id { }
|
|
|
|
id shift and go to state 29
|
|
|
|
|
|
state 16
|
|
|
|
(4) pipeline_stage -> splitter .
|
|
|
|
splitterKeyword reduce using rule 4 (pipeline_stage -> splitter .)
|
|
filterKeyword reduce using rule 4 (pipeline_stage -> splitter .)
|
|
id reduce using rule 4 (pipeline_stage -> splitter .)
|
|
string reduce using rule 4 (pipeline_stage -> splitter .)
|
|
ungrouperKeyword reduce using rule 4 (pipeline_stage -> splitter .)
|
|
grouperKeyword reduce using rule 4 (pipeline_stage -> splitter .)
|
|
groupFilterKeyword reduce using rule 4 (pipeline_stage -> splitter .)
|
|
mergerKeyword reduce using rule 4 (pipeline_stage -> splitter .)
|
|
$end reduce using rule 4 (pipeline_stage -> splitter .)
|
|
|
|
|
|
state 17
|
|
|
|
(15) group_filter -> groupFilterKeyword . id { filter_rule_1n }
|
|
|
|
id shift and go to state 30
|
|
|
|
|
|
state 18
|
|
|
|
(5) pipeline_stage -> filter .
|
|
|
|
splitterKeyword reduce using rule 5 (pipeline_stage -> filter .)
|
|
filterKeyword reduce using rule 5 (pipeline_stage -> filter .)
|
|
id reduce using rule 5 (pipeline_stage -> filter .)
|
|
string reduce using rule 5 (pipeline_stage -> filter .)
|
|
ungrouperKeyword reduce using rule 5 (pipeline_stage -> filter .)
|
|
grouperKeyword reduce using rule 5 (pipeline_stage -> filter .)
|
|
groupFilterKeyword reduce using rule 5 (pipeline_stage -> filter .)
|
|
mergerKeyword reduce using rule 5 (pipeline_stage -> filter .)
|
|
$end reduce using rule 5 (pipeline_stage -> filter .)
|
|
|
|
|
|
state 19
|
|
|
|
(6) pipeline_stage -> composite_filter .
|
|
|
|
splitterKeyword reduce using rule 6 (pipeline_stage -> composite_filter .)
|
|
filterKeyword reduce using rule 6 (pipeline_stage -> composite_filter .)
|
|
id reduce using rule 6 (pipeline_stage -> composite_filter .)
|
|
string reduce using rule 6 (pipeline_stage -> composite_filter .)
|
|
ungrouperKeyword reduce using rule 6 (pipeline_stage -> composite_filter .)
|
|
grouperKeyword reduce using rule 6 (pipeline_stage -> composite_filter .)
|
|
groupFilterKeyword reduce using rule 6 (pipeline_stage -> composite_filter .)
|
|
mergerKeyword reduce using rule 6 (pipeline_stage -> composite_filter .)
|
|
$end reduce using rule 6 (pipeline_stage -> composite_filter .)
|
|
|
|
|
|
state 20
|
|
|
|
(2) pipeline_stage_1n -> pipeline_stage pipeline_stage_1n .
|
|
|
|
$end reduce using rule 2 (pipeline_stage_1n -> pipeline_stage pipeline_stage_1n .)
|
|
|
|
|
|
state 21
|
|
|
|
(71) grouper -> grouperKeyword id . { module1_n aggregate }
|
|
|
|
{ shift and go to state 31
|
|
|
|
|
|
state 22
|
|
|
|
(69) arrow -> - . GT
|
|
|
|
GT shift and go to state 32
|
|
|
|
|
|
state 23
|
|
|
|
(62) branch -> id arrow . mid_branch
|
|
(65) mid_branch -> . id arrow mid_branch
|
|
(66) mid_branch -> . end_branch
|
|
(67) end_branch -> . id
|
|
(68) end_branch -> . string
|
|
|
|
id shift and go to state 35
|
|
string shift and go to state 34
|
|
|
|
end_branch shift and go to state 33
|
|
mid_branch shift and go to state 36
|
|
|
|
state 24
|
|
|
|
(64) branch -> id branchKeyword . mid_branch
|
|
(65) mid_branch -> . id arrow mid_branch
|
|
(66) mid_branch -> . end_branch
|
|
(67) end_branch -> . id
|
|
(68) end_branch -> . string
|
|
|
|
id shift and go to state 35
|
|
string shift and go to state 34
|
|
|
|
end_branch shift and go to state 33
|
|
mid_branch shift and go to state 37
|
|
|
|
state 25
|
|
|
|
(13) filter -> filterKeyword id . { filter_rule_1n }
|
|
(14) composite_filter -> filterKeyword id . { filter_ref_rule_1n }
|
|
|
|
{ shift and go to state 38
|
|
|
|
|
|
state 26
|
|
|
|
(12) splitter -> splitterKeyword id . { }
|
|
|
|
{ shift and go to state 39
|
|
|
|
|
|
state 27
|
|
|
|
(63) branch -> string arrow . mid_branch
|
|
(65) mid_branch -> . id arrow mid_branch
|
|
(66) mid_branch -> . end_branch
|
|
(67) end_branch -> . id
|
|
(68) end_branch -> . string
|
|
|
|
id shift and go to state 35
|
|
string shift and go to state 34
|
|
|
|
end_branch shift and go to state 33
|
|
mid_branch shift and go to state 40
|
|
|
|
state 28
|
|
|
|
(108) merger -> mergerKeyword id . { merger_module1_n export }
|
|
|
|
{ shift and go to state 41
|
|
|
|
|
|
state 29
|
|
|
|
(70) ungrouper -> ungrouperKeyword id . { }
|
|
|
|
{ shift and go to state 42
|
|
|
|
|
|
state 30
|
|
|
|
(15) group_filter -> groupFilterKeyword id . { filter_rule_1n }
|
|
|
|
{ shift and go to state 43
|
|
|
|
|
|
state 31
|
|
|
|
(71) grouper -> grouperKeyword id { . module1_n aggregate }
|
|
(72) module1_n -> . module module1_n
|
|
(73) module1_n -> .
|
|
(74) module -> . moduleKeyword id { grouper_rule1_n }
|
|
|
|
aggregateKeyword reduce using rule 73 (module1_n -> .)
|
|
moduleKeyword shift and go to state 44
|
|
|
|
module1_n shift and go to state 45
|
|
module shift and go to state 46
|
|
|
|
state 32
|
|
|
|
(69) arrow -> - GT .
|
|
|
|
id reduce using rule 69 (arrow -> - GT .)
|
|
string reduce using rule 69 (arrow -> - GT .)
|
|
|
|
|
|
state 33
|
|
|
|
(66) mid_branch -> end_branch .
|
|
|
|
splitterKeyword reduce using rule 66 (mid_branch -> end_branch .)
|
|
filterKeyword reduce using rule 66 (mid_branch -> end_branch .)
|
|
id reduce using rule 66 (mid_branch -> end_branch .)
|
|
string reduce using rule 66 (mid_branch -> end_branch .)
|
|
ungrouperKeyword reduce using rule 66 (mid_branch -> end_branch .)
|
|
grouperKeyword reduce using rule 66 (mid_branch -> end_branch .)
|
|
groupFilterKeyword reduce using rule 66 (mid_branch -> end_branch .)
|
|
mergerKeyword reduce using rule 66 (mid_branch -> end_branch .)
|
|
$end reduce using rule 66 (mid_branch -> end_branch .)
|
|
|
|
|
|
state 34
|
|
|
|
(68) end_branch -> string .
|
|
|
|
splitterKeyword reduce using rule 68 (end_branch -> string .)
|
|
filterKeyword reduce using rule 68 (end_branch -> string .)
|
|
id reduce using rule 68 (end_branch -> string .)
|
|
string reduce using rule 68 (end_branch -> string .)
|
|
ungrouperKeyword reduce using rule 68 (end_branch -> string .)
|
|
grouperKeyword reduce using rule 68 (end_branch -> string .)
|
|
groupFilterKeyword reduce using rule 68 (end_branch -> string .)
|
|
mergerKeyword reduce using rule 68 (end_branch -> string .)
|
|
$end reduce using rule 68 (end_branch -> string .)
|
|
|
|
|
|
state 35
|
|
|
|
(65) mid_branch -> id . arrow mid_branch
|
|
(67) end_branch -> id .
|
|
(69) arrow -> . - GT
|
|
|
|
splitterKeyword reduce using rule 67 (end_branch -> id .)
|
|
filterKeyword reduce using rule 67 (end_branch -> id .)
|
|
id reduce using rule 67 (end_branch -> id .)
|
|
string reduce using rule 67 (end_branch -> id .)
|
|
ungrouperKeyword reduce using rule 67 (end_branch -> id .)
|
|
grouperKeyword reduce using rule 67 (end_branch -> id .)
|
|
groupFilterKeyword reduce using rule 67 (end_branch -> id .)
|
|
mergerKeyword reduce using rule 67 (end_branch -> id .)
|
|
$end reduce using rule 67 (end_branch -> id .)
|
|
- shift and go to state 22
|
|
|
|
arrow shift and go to state 47
|
|
|
|
state 36
|
|
|
|
(62) branch -> id arrow mid_branch .
|
|
|
|
splitterKeyword reduce using rule 62 (branch -> id arrow mid_branch .)
|
|
filterKeyword reduce using rule 62 (branch -> id arrow mid_branch .)
|
|
id reduce using rule 62 (branch -> id arrow mid_branch .)
|
|
string reduce using rule 62 (branch -> id arrow mid_branch .)
|
|
ungrouperKeyword reduce using rule 62 (branch -> id arrow mid_branch .)
|
|
grouperKeyword reduce using rule 62 (branch -> id arrow mid_branch .)
|
|
groupFilterKeyword reduce using rule 62 (branch -> id arrow mid_branch .)
|
|
mergerKeyword reduce using rule 62 (branch -> id arrow mid_branch .)
|
|
$end reduce using rule 62 (branch -> id arrow mid_branch .)
|
|
|
|
|
|
state 37
|
|
|
|
(64) branch -> id branchKeyword mid_branch .
|
|
|
|
splitterKeyword reduce using rule 64 (branch -> id branchKeyword mid_branch .)
|
|
filterKeyword reduce using rule 64 (branch -> id branchKeyword mid_branch .)
|
|
id reduce using rule 64 (branch -> id branchKeyword mid_branch .)
|
|
string reduce using rule 64 (branch -> id branchKeyword mid_branch .)
|
|
ungrouperKeyword reduce using rule 64 (branch -> id branchKeyword mid_branch .)
|
|
grouperKeyword reduce using rule 64 (branch -> id branchKeyword mid_branch .)
|
|
groupFilterKeyword reduce using rule 64 (branch -> id branchKeyword mid_branch .)
|
|
mergerKeyword reduce using rule 64 (branch -> id branchKeyword mid_branch .)
|
|
$end reduce using rule 64 (branch -> id branchKeyword mid_branch .)
|
|
|
|
|
|
state 38
|
|
|
|
(13) filter -> filterKeyword id { . filter_rule_1n }
|
|
(14) composite_filter -> filterKeyword id { . filter_ref_rule_1n }
|
|
(16) filter_rule_1n -> . filter_rule filter_rule_1n
|
|
(17) filter_rule_1n -> .
|
|
(19) filter_ref_rule_1n -> . filter_ref_rule filter_ref_rule_1n
|
|
(20) filter_ref_rule_1n -> . filter_ref_rule
|
|
(18) filter_rule -> . or_rule
|
|
(21) filter_ref_rule -> . or_id
|
|
(27) or_rule -> . rule_or_not opt_rule
|
|
(22) or_id -> . not_id opt_or_id
|
|
(30) rule_or_not -> . rule
|
|
(31) rule_or_not -> . NOTKeyword rule
|
|
(25) not_id -> . NOTKeyword id
|
|
(26) not_id -> . id
|
|
(32) rule -> . infix_rule
|
|
(33) rule -> . prefix_rule
|
|
(34) infix_rule -> . arg op arg
|
|
(44) prefix_rule -> . id ( args )
|
|
(45) prefix_rule -> . bitANDKeyword ( args )
|
|
(46) prefix_rule -> . bitORKeyword ( args )
|
|
(50) arg -> . id
|
|
(51) arg -> . IPv4
|
|
(52) arg -> . IPv6
|
|
(53) arg -> . CIDR
|
|
(54) arg -> . MAC
|
|
(55) arg -> . int
|
|
(56) arg -> . float
|
|
(57) arg -> . hex
|
|
(58) arg -> . prefix_rule
|
|
(59) arg -> . string
|
|
(60) CIDR -> . IPv4 / int
|
|
(61) CIDR -> . IPv6 / int
|
|
|
|
} reduce using rule 17 (filter_rule_1n -> .)
|
|
NOTKeyword shift and go to state 57
|
|
id shift and go to state 56
|
|
bitANDKeyword shift and go to state 48
|
|
bitORKeyword shift and go to state 58
|
|
IPv4 shift and go to state 70
|
|
IPv6 shift and go to state 71
|
|
MAC shift and go to state 68
|
|
int shift and go to state 51
|
|
float shift and go to state 52
|
|
hex shift and go to state 60
|
|
string shift and go to state 62
|
|
|
|
filter_ref_rule_1n shift and go to state 49
|
|
or_rule shift and go to state 50
|
|
filter_rule shift and go to state 59
|
|
not_id shift and go to state 66
|
|
or_id shift and go to state 63
|
|
rule shift and go to state 67
|
|
infix_rule shift and go to state 53
|
|
rule_or_not shift and go to state 69
|
|
prefix_rule shift and go to state 54
|
|
arg shift and go to state 55
|
|
filter_rule_1n shift and go to state 64
|
|
CIDR shift and go to state 65
|
|
filter_ref_rule shift and go to state 61
|
|
|
|
state 39
|
|
|
|
(12) splitter -> splitterKeyword id { . }
|
|
|
|
} shift and go to state 72
|
|
|
|
|
|
state 40
|
|
|
|
(63) branch -> string arrow mid_branch .
|
|
|
|
splitterKeyword reduce using rule 63 (branch -> string arrow mid_branch .)
|
|
filterKeyword reduce using rule 63 (branch -> string arrow mid_branch .)
|
|
id reduce using rule 63 (branch -> string arrow mid_branch .)
|
|
string reduce using rule 63 (branch -> string arrow mid_branch .)
|
|
ungrouperKeyword reduce using rule 63 (branch -> string arrow mid_branch .)
|
|
grouperKeyword reduce using rule 63 (branch -> string arrow mid_branch .)
|
|
groupFilterKeyword reduce using rule 63 (branch -> string arrow mid_branch .)
|
|
mergerKeyword reduce using rule 63 (branch -> string arrow mid_branch .)
|
|
$end reduce using rule 63 (branch -> string arrow mid_branch .)
|
|
|
|
|
|
state 41
|
|
|
|
(108) merger -> mergerKeyword id { . merger_module1_n export }
|
|
(109) merger_module1_n -> . merger_module merger_module1_n
|
|
(110) merger_module1_n -> .
|
|
(111) merger_module -> . moduleKeyword id { merger_branches merger_rule1_n }
|
|
|
|
exportKeyword reduce using rule 110 (merger_module1_n -> .)
|
|
moduleKeyword shift and go to state 75
|
|
|
|
merger_module shift and go to state 73
|
|
merger_module1_n shift and go to state 74
|
|
|
|
state 42
|
|
|
|
(70) ungrouper -> ungrouperKeyword id { . }
|
|
|
|
} shift and go to state 76
|
|
|
|
|
|
state 43
|
|
|
|
(15) group_filter -> groupFilterKeyword id { . filter_rule_1n }
|
|
(16) filter_rule_1n -> . filter_rule filter_rule_1n
|
|
(17) filter_rule_1n -> .
|
|
(18) filter_rule -> . or_rule
|
|
(27) or_rule -> . rule_or_not opt_rule
|
|
(30) rule_or_not -> . rule
|
|
(31) rule_or_not -> . NOTKeyword rule
|
|
(32) rule -> . infix_rule
|
|
(33) rule -> . prefix_rule
|
|
(34) infix_rule -> . arg op arg
|
|
(44) prefix_rule -> . id ( args )
|
|
(45) prefix_rule -> . bitANDKeyword ( args )
|
|
(46) prefix_rule -> . bitORKeyword ( args )
|
|
(50) arg -> . id
|
|
(51) arg -> . IPv4
|
|
(52) arg -> . IPv6
|
|
(53) arg -> . CIDR
|
|
(54) arg -> . MAC
|
|
(55) arg -> . int
|
|
(56) arg -> . float
|
|
(57) arg -> . hex
|
|
(58) arg -> . prefix_rule
|
|
(59) arg -> . string
|
|
(60) CIDR -> . IPv4 / int
|
|
(61) CIDR -> . IPv6 / int
|
|
|
|
} reduce using rule 17 (filter_rule_1n -> .)
|
|
NOTKeyword shift and go to state 78
|
|
id shift and go to state 77
|
|
bitANDKeyword shift and go to state 48
|
|
bitORKeyword shift and go to state 58
|
|
IPv4 shift and go to state 70
|
|
IPv6 shift and go to state 71
|
|
MAC shift and go to state 68
|
|
int shift and go to state 51
|
|
float shift and go to state 52
|
|
hex shift and go to state 60
|
|
string shift and go to state 62
|
|
|
|
or_rule shift and go to state 50
|
|
filter_rule shift and go to state 59
|
|
rule shift and go to state 67
|
|
infix_rule shift and go to state 53
|
|
rule_or_not shift and go to state 69
|
|
prefix_rule shift and go to state 54
|
|
arg shift and go to state 55
|
|
filter_rule_1n shift and go to state 79
|
|
CIDR shift and go to state 65
|
|
|
|
state 44
|
|
|
|
(74) module -> moduleKeyword . id { grouper_rule1_n }
|
|
|
|
id shift and go to state 80
|
|
|
|
|
|
state 45
|
|
|
|
(71) grouper -> grouperKeyword id { module1_n . aggregate }
|
|
(90) aggregate -> . aggregateKeyword aggr1_n
|
|
|
|
aggregateKeyword shift and go to state 81
|
|
|
|
aggregate shift and go to state 82
|
|
|
|
state 46
|
|
|
|
(72) module1_n -> module . module1_n
|
|
(72) module1_n -> . module module1_n
|
|
(73) module1_n -> .
|
|
(74) module -> . moduleKeyword id { grouper_rule1_n }
|
|
|
|
aggregateKeyword reduce using rule 73 (module1_n -> .)
|
|
moduleKeyword shift and go to state 44
|
|
|
|
module1_n shift and go to state 83
|
|
module shift and go to state 46
|
|
|
|
state 47
|
|
|
|
(65) mid_branch -> id arrow . mid_branch
|
|
(65) mid_branch -> . id arrow mid_branch
|
|
(66) mid_branch -> . end_branch
|
|
(67) end_branch -> . id
|
|
(68) end_branch -> . string
|
|
|
|
id shift and go to state 35
|
|
string shift and go to state 34
|
|
|
|
end_branch shift and go to state 33
|
|
mid_branch shift and go to state 84
|
|
|
|
state 48
|
|
|
|
(45) prefix_rule -> bitANDKeyword . ( args )
|
|
|
|
( shift and go to state 85
|
|
|
|
|
|
state 49
|
|
|
|
(14) composite_filter -> filterKeyword id { filter_ref_rule_1n . }
|
|
|
|
} shift and go to state 86
|
|
|
|
|
|
state 50
|
|
|
|
(18) filter_rule -> or_rule .
|
|
|
|
NOTKeyword reduce using rule 18 (filter_rule -> or_rule .)
|
|
id reduce using rule 18 (filter_rule -> or_rule .)
|
|
bitANDKeyword reduce using rule 18 (filter_rule -> or_rule .)
|
|
bitORKeyword reduce using rule 18 (filter_rule -> or_rule .)
|
|
IPv4 reduce using rule 18 (filter_rule -> or_rule .)
|
|
IPv6 reduce using rule 18 (filter_rule -> or_rule .)
|
|
MAC reduce using rule 18 (filter_rule -> or_rule .)
|
|
int reduce using rule 18 (filter_rule -> or_rule .)
|
|
float reduce using rule 18 (filter_rule -> or_rule .)
|
|
hex reduce using rule 18 (filter_rule -> or_rule .)
|
|
string reduce using rule 18 (filter_rule -> or_rule .)
|
|
} reduce using rule 18 (filter_rule -> or_rule .)
|
|
|
|
|
|
state 51
|
|
|
|
(55) arg -> int .
|
|
|
|
, reduce using rule 55 (arg -> int .)
|
|
) reduce using rule 55 (arg -> int .)
|
|
EQ reduce using rule 55 (arg -> int .)
|
|
LT reduce using rule 55 (arg -> int .)
|
|
GT reduce using rule 55 (arg -> int .)
|
|
LTEQ reduce using rule 55 (arg -> int .)
|
|
GTEQ reduce using rule 55 (arg -> int .)
|
|
ML reduce using rule 55 (arg -> int .)
|
|
MG reduce using rule 55 (arg -> int .)
|
|
inKeyword reduce using rule 55 (arg -> int .)
|
|
notinKeyword reduce using rule 55 (arg -> int .)
|
|
ORKeyword reduce using rule 55 (arg -> int .)
|
|
NOTKeyword reduce using rule 55 (arg -> int .)
|
|
id reduce using rule 55 (arg -> int .)
|
|
bitANDKeyword reduce using rule 55 (arg -> int .)
|
|
bitORKeyword reduce using rule 55 (arg -> int .)
|
|
IPv4 reduce using rule 55 (arg -> int .)
|
|
IPv6 reduce using rule 55 (arg -> int .)
|
|
MAC reduce using rule 55 (arg -> int .)
|
|
int reduce using rule 55 (arg -> int .)
|
|
float reduce using rule 55 (arg -> int .)
|
|
hex reduce using rule 55 (arg -> int .)
|
|
string reduce using rule 55 (arg -> int .)
|
|
} reduce using rule 55 (arg -> int .)
|
|
|
|
|
|
state 52
|
|
|
|
(56) arg -> float .
|
|
|
|
, reduce using rule 56 (arg -> float .)
|
|
) reduce using rule 56 (arg -> float .)
|
|
EQ reduce using rule 56 (arg -> float .)
|
|
LT reduce using rule 56 (arg -> float .)
|
|
GT reduce using rule 56 (arg -> float .)
|
|
LTEQ reduce using rule 56 (arg -> float .)
|
|
GTEQ reduce using rule 56 (arg -> float .)
|
|
ML reduce using rule 56 (arg -> float .)
|
|
MG reduce using rule 56 (arg -> float .)
|
|
inKeyword reduce using rule 56 (arg -> float .)
|
|
notinKeyword reduce using rule 56 (arg -> float .)
|
|
ORKeyword reduce using rule 56 (arg -> float .)
|
|
NOTKeyword reduce using rule 56 (arg -> float .)
|
|
id reduce using rule 56 (arg -> float .)
|
|
bitANDKeyword reduce using rule 56 (arg -> float .)
|
|
bitORKeyword reduce using rule 56 (arg -> float .)
|
|
IPv4 reduce using rule 56 (arg -> float .)
|
|
IPv6 reduce using rule 56 (arg -> float .)
|
|
MAC reduce using rule 56 (arg -> float .)
|
|
int reduce using rule 56 (arg -> float .)
|
|
float reduce using rule 56 (arg -> float .)
|
|
hex reduce using rule 56 (arg -> float .)
|
|
string reduce using rule 56 (arg -> float .)
|
|
} reduce using rule 56 (arg -> float .)
|
|
|
|
|
|
state 53
|
|
|
|
(32) rule -> infix_rule .
|
|
|
|
ORKeyword reduce using rule 32 (rule -> infix_rule .)
|
|
NOTKeyword reduce using rule 32 (rule -> infix_rule .)
|
|
id reduce using rule 32 (rule -> infix_rule .)
|
|
bitANDKeyword reduce using rule 32 (rule -> infix_rule .)
|
|
bitORKeyword reduce using rule 32 (rule -> infix_rule .)
|
|
IPv4 reduce using rule 32 (rule -> infix_rule .)
|
|
IPv6 reduce using rule 32 (rule -> infix_rule .)
|
|
MAC reduce using rule 32 (rule -> infix_rule .)
|
|
int reduce using rule 32 (rule -> infix_rule .)
|
|
float reduce using rule 32 (rule -> infix_rule .)
|
|
hex reduce using rule 32 (rule -> infix_rule .)
|
|
string reduce using rule 32 (rule -> infix_rule .)
|
|
} reduce using rule 32 (rule -> infix_rule .)
|
|
|
|
|
|
state 54
|
|
|
|
(33) rule -> prefix_rule .
|
|
(58) arg -> prefix_rule .
|
|
|
|
ORKeyword reduce using rule 33 (rule -> prefix_rule .)
|
|
NOTKeyword reduce using rule 33 (rule -> prefix_rule .)
|
|
id reduce using rule 33 (rule -> prefix_rule .)
|
|
bitANDKeyword reduce using rule 33 (rule -> prefix_rule .)
|
|
bitORKeyword reduce using rule 33 (rule -> prefix_rule .)
|
|
IPv4 reduce using rule 33 (rule -> prefix_rule .)
|
|
IPv6 reduce using rule 33 (rule -> prefix_rule .)
|
|
MAC reduce using rule 33 (rule -> prefix_rule .)
|
|
int reduce using rule 33 (rule -> prefix_rule .)
|
|
float reduce using rule 33 (rule -> prefix_rule .)
|
|
hex reduce using rule 33 (rule -> prefix_rule .)
|
|
string reduce using rule 33 (rule -> prefix_rule .)
|
|
} reduce using rule 33 (rule -> prefix_rule .)
|
|
EQ reduce using rule 58 (arg -> prefix_rule .)
|
|
LT reduce using rule 58 (arg -> prefix_rule .)
|
|
GT reduce using rule 58 (arg -> prefix_rule .)
|
|
LTEQ reduce using rule 58 (arg -> prefix_rule .)
|
|
GTEQ reduce using rule 58 (arg -> prefix_rule .)
|
|
ML reduce using rule 58 (arg -> prefix_rule .)
|
|
MG reduce using rule 58 (arg -> prefix_rule .)
|
|
inKeyword reduce using rule 58 (arg -> prefix_rule .)
|
|
notinKeyword reduce using rule 58 (arg -> prefix_rule .)
|
|
|
|
|
|
state 55
|
|
|
|
(34) infix_rule -> arg . op arg
|
|
(35) op -> . EQ
|
|
(36) op -> . LT
|
|
(37) op -> . GT
|
|
(38) op -> . LTEQ
|
|
(39) op -> . GTEQ
|
|
(40) op -> . ML
|
|
(41) op -> . MG
|
|
(42) op -> . inKeyword
|
|
(43) op -> . notinKeyword
|
|
|
|
EQ shift and go to state 95
|
|
LT shift and go to state 93
|
|
GT shift and go to state 88
|
|
LTEQ shift and go to state 91
|
|
GTEQ shift and go to state 89
|
|
ML shift and go to state 90
|
|
MG shift and go to state 87
|
|
inKeyword shift and go to state 92
|
|
notinKeyword shift and go to state 94
|
|
|
|
op shift and go to state 96
|
|
|
|
state 56
|
|
|
|
(26) not_id -> id .
|
|
(44) prefix_rule -> id . ( args )
|
|
(50) arg -> id .
|
|
|
|
ORKeyword reduce using rule 26 (not_id -> id .)
|
|
NOTKeyword reduce using rule 26 (not_id -> id .)
|
|
id reduce using rule 26 (not_id -> id .)
|
|
} reduce using rule 26 (not_id -> id .)
|
|
( shift and go to state 97
|
|
EQ reduce using rule 50 (arg -> id .)
|
|
LT reduce using rule 50 (arg -> id .)
|
|
GT reduce using rule 50 (arg -> id .)
|
|
LTEQ reduce using rule 50 (arg -> id .)
|
|
GTEQ reduce using rule 50 (arg -> id .)
|
|
ML reduce using rule 50 (arg -> id .)
|
|
MG reduce using rule 50 (arg -> id .)
|
|
inKeyword reduce using rule 50 (arg -> id .)
|
|
notinKeyword reduce using rule 50 (arg -> id .)
|
|
|
|
|
|
state 57
|
|
|
|
(31) rule_or_not -> NOTKeyword . rule
|
|
(25) not_id -> NOTKeyword . id
|
|
(32) rule -> . infix_rule
|
|
(33) rule -> . prefix_rule
|
|
(34) infix_rule -> . arg op arg
|
|
(44) prefix_rule -> . id ( args )
|
|
(45) prefix_rule -> . bitANDKeyword ( args )
|
|
(46) prefix_rule -> . bitORKeyword ( args )
|
|
(50) arg -> . id
|
|
(51) arg -> . IPv4
|
|
(52) arg -> . IPv6
|
|
(53) arg -> . CIDR
|
|
(54) arg -> . MAC
|
|
(55) arg -> . int
|
|
(56) arg -> . float
|
|
(57) arg -> . hex
|
|
(58) arg -> . prefix_rule
|
|
(59) arg -> . string
|
|
(60) CIDR -> . IPv4 / int
|
|
(61) CIDR -> . IPv6 / int
|
|
|
|
id shift and go to state 99
|
|
bitANDKeyword shift and go to state 48
|
|
bitORKeyword shift and go to state 58
|
|
IPv4 shift and go to state 70
|
|
IPv6 shift and go to state 71
|
|
MAC shift and go to state 68
|
|
int shift and go to state 51
|
|
float shift and go to state 52
|
|
hex shift and go to state 60
|
|
string shift and go to state 62
|
|
|
|
prefix_rule shift and go to state 54
|
|
infix_rule shift and go to state 53
|
|
rule shift and go to state 98
|
|
arg shift and go to state 55
|
|
CIDR shift and go to state 65
|
|
|
|
state 58
|
|
|
|
(46) prefix_rule -> bitORKeyword . ( args )
|
|
|
|
( shift and go to state 100
|
|
|
|
|
|
state 59
|
|
|
|
(16) filter_rule_1n -> filter_rule . filter_rule_1n
|
|
(16) filter_rule_1n -> . filter_rule filter_rule_1n
|
|
(17) filter_rule_1n -> .
|
|
(18) filter_rule -> . or_rule
|
|
(27) or_rule -> . rule_or_not opt_rule
|
|
(30) rule_or_not -> . rule
|
|
(31) rule_or_not -> . NOTKeyword rule
|
|
(32) rule -> . infix_rule
|
|
(33) rule -> . prefix_rule
|
|
(34) infix_rule -> . arg op arg
|
|
(44) prefix_rule -> . id ( args )
|
|
(45) prefix_rule -> . bitANDKeyword ( args )
|
|
(46) prefix_rule -> . bitORKeyword ( args )
|
|
(50) arg -> . id
|
|
(51) arg -> . IPv4
|
|
(52) arg -> . IPv6
|
|
(53) arg -> . CIDR
|
|
(54) arg -> . MAC
|
|
(55) arg -> . int
|
|
(56) arg -> . float
|
|
(57) arg -> . hex
|
|
(58) arg -> . prefix_rule
|
|
(59) arg -> . string
|
|
(60) CIDR -> . IPv4 / int
|
|
(61) CIDR -> . IPv6 / int
|
|
|
|
} reduce using rule 17 (filter_rule_1n -> .)
|
|
NOTKeyword shift and go to state 78
|
|
id shift and go to state 77
|
|
bitANDKeyword shift and go to state 48
|
|
bitORKeyword shift and go to state 58
|
|
IPv4 shift and go to state 70
|
|
IPv6 shift and go to state 71
|
|
MAC shift and go to state 68
|
|
int shift and go to state 51
|
|
float shift and go to state 52
|
|
hex shift and go to state 60
|
|
string shift and go to state 62
|
|
|
|
or_rule shift and go to state 50
|
|
filter_rule shift and go to state 59
|
|
rule shift and go to state 67
|
|
infix_rule shift and go to state 53
|
|
rule_or_not shift and go to state 69
|
|
prefix_rule shift and go to state 54
|
|
arg shift and go to state 55
|
|
filter_rule_1n shift and go to state 101
|
|
CIDR shift and go to state 65
|
|
|
|
state 60
|
|
|
|
(57) arg -> hex .
|
|
|
|
, reduce using rule 57 (arg -> hex .)
|
|
) reduce using rule 57 (arg -> hex .)
|
|
EQ reduce using rule 57 (arg -> hex .)
|
|
LT reduce using rule 57 (arg -> hex .)
|
|
GT reduce using rule 57 (arg -> hex .)
|
|
LTEQ reduce using rule 57 (arg -> hex .)
|
|
GTEQ reduce using rule 57 (arg -> hex .)
|
|
ML reduce using rule 57 (arg -> hex .)
|
|
MG reduce using rule 57 (arg -> hex .)
|
|
inKeyword reduce using rule 57 (arg -> hex .)
|
|
notinKeyword reduce using rule 57 (arg -> hex .)
|
|
ORKeyword reduce using rule 57 (arg -> hex .)
|
|
NOTKeyword reduce using rule 57 (arg -> hex .)
|
|
id reduce using rule 57 (arg -> hex .)
|
|
bitANDKeyword reduce using rule 57 (arg -> hex .)
|
|
bitORKeyword reduce using rule 57 (arg -> hex .)
|
|
IPv4 reduce using rule 57 (arg -> hex .)
|
|
IPv6 reduce using rule 57 (arg -> hex .)
|
|
MAC reduce using rule 57 (arg -> hex .)
|
|
int reduce using rule 57 (arg -> hex .)
|
|
float reduce using rule 57 (arg -> hex .)
|
|
hex reduce using rule 57 (arg -> hex .)
|
|
string reduce using rule 57 (arg -> hex .)
|
|
} reduce using rule 57 (arg -> hex .)
|
|
|
|
|
|
state 61
|
|
|
|
(19) filter_ref_rule_1n -> filter_ref_rule . filter_ref_rule_1n
|
|
(20) filter_ref_rule_1n -> filter_ref_rule .
|
|
(19) filter_ref_rule_1n -> . filter_ref_rule filter_ref_rule_1n
|
|
(20) filter_ref_rule_1n -> . filter_ref_rule
|
|
(21) filter_ref_rule -> . or_id
|
|
(22) or_id -> . not_id opt_or_id
|
|
(25) not_id -> . NOTKeyword id
|
|
(26) not_id -> . id
|
|
|
|
} reduce using rule 20 (filter_ref_rule_1n -> filter_ref_rule .)
|
|
NOTKeyword shift and go to state 102
|
|
id shift and go to state 104
|
|
|
|
filter_ref_rule_1n shift and go to state 103
|
|
or_id shift and go to state 63
|
|
filter_ref_rule shift and go to state 61
|
|
not_id shift and go to state 66
|
|
|
|
state 62
|
|
|
|
(59) arg -> string .
|
|
|
|
, reduce using rule 59 (arg -> string .)
|
|
) reduce using rule 59 (arg -> string .)
|
|
EQ reduce using rule 59 (arg -> string .)
|
|
LT reduce using rule 59 (arg -> string .)
|
|
GT reduce using rule 59 (arg -> string .)
|
|
LTEQ reduce using rule 59 (arg -> string .)
|
|
GTEQ reduce using rule 59 (arg -> string .)
|
|
ML reduce using rule 59 (arg -> string .)
|
|
MG reduce using rule 59 (arg -> string .)
|
|
inKeyword reduce using rule 59 (arg -> string .)
|
|
notinKeyword reduce using rule 59 (arg -> string .)
|
|
ORKeyword reduce using rule 59 (arg -> string .)
|
|
NOTKeyword reduce using rule 59 (arg -> string .)
|
|
id reduce using rule 59 (arg -> string .)
|
|
bitANDKeyword reduce using rule 59 (arg -> string .)
|
|
bitORKeyword reduce using rule 59 (arg -> string .)
|
|
IPv4 reduce using rule 59 (arg -> string .)
|
|
IPv6 reduce using rule 59 (arg -> string .)
|
|
MAC reduce using rule 59 (arg -> string .)
|
|
int reduce using rule 59 (arg -> string .)
|
|
float reduce using rule 59 (arg -> string .)
|
|
hex reduce using rule 59 (arg -> string .)
|
|
string reduce using rule 59 (arg -> string .)
|
|
} reduce using rule 59 (arg -> string .)
|
|
|
|
|
|
state 63
|
|
|
|
(21) filter_ref_rule -> or_id .
|
|
|
|
NOTKeyword reduce using rule 21 (filter_ref_rule -> or_id .)
|
|
id reduce using rule 21 (filter_ref_rule -> or_id .)
|
|
} reduce using rule 21 (filter_ref_rule -> or_id .)
|
|
|
|
|
|
state 64
|
|
|
|
(13) filter -> filterKeyword id { filter_rule_1n . }
|
|
|
|
} shift and go to state 105
|
|
|
|
|
|
state 65
|
|
|
|
(53) arg -> CIDR .
|
|
|
|
, reduce using rule 53 (arg -> CIDR .)
|
|
) reduce using rule 53 (arg -> CIDR .)
|
|
EQ reduce using rule 53 (arg -> CIDR .)
|
|
LT reduce using rule 53 (arg -> CIDR .)
|
|
GT reduce using rule 53 (arg -> CIDR .)
|
|
LTEQ reduce using rule 53 (arg -> CIDR .)
|
|
GTEQ reduce using rule 53 (arg -> CIDR .)
|
|
ML reduce using rule 53 (arg -> CIDR .)
|
|
MG reduce using rule 53 (arg -> CIDR .)
|
|
inKeyword reduce using rule 53 (arg -> CIDR .)
|
|
notinKeyword reduce using rule 53 (arg -> CIDR .)
|
|
ORKeyword reduce using rule 53 (arg -> CIDR .)
|
|
NOTKeyword reduce using rule 53 (arg -> CIDR .)
|
|
id reduce using rule 53 (arg -> CIDR .)
|
|
bitANDKeyword reduce using rule 53 (arg -> CIDR .)
|
|
bitORKeyword reduce using rule 53 (arg -> CIDR .)
|
|
IPv4 reduce using rule 53 (arg -> CIDR .)
|
|
IPv6 reduce using rule 53 (arg -> CIDR .)
|
|
MAC reduce using rule 53 (arg -> CIDR .)
|
|
int reduce using rule 53 (arg -> CIDR .)
|
|
float reduce using rule 53 (arg -> CIDR .)
|
|
hex reduce using rule 53 (arg -> CIDR .)
|
|
string reduce using rule 53 (arg -> CIDR .)
|
|
} reduce using rule 53 (arg -> CIDR .)
|
|
|
|
|
|
state 66
|
|
|
|
(22) or_id -> not_id . opt_or_id
|
|
(23) opt_or_id -> . ORKeyword not_id opt_or_id
|
|
(24) opt_or_id -> .
|
|
|
|
ORKeyword shift and go to state 106
|
|
NOTKeyword reduce using rule 24 (opt_or_id -> .)
|
|
id reduce using rule 24 (opt_or_id -> .)
|
|
} reduce using rule 24 (opt_or_id -> .)
|
|
|
|
opt_or_id shift and go to state 107
|
|
|
|
state 67
|
|
|
|
(30) rule_or_not -> rule .
|
|
|
|
ORKeyword reduce using rule 30 (rule_or_not -> rule .)
|
|
NOTKeyword reduce using rule 30 (rule_or_not -> rule .)
|
|
id reduce using rule 30 (rule_or_not -> rule .)
|
|
bitANDKeyword reduce using rule 30 (rule_or_not -> rule .)
|
|
bitORKeyword reduce using rule 30 (rule_or_not -> rule .)
|
|
IPv4 reduce using rule 30 (rule_or_not -> rule .)
|
|
IPv6 reduce using rule 30 (rule_or_not -> rule .)
|
|
MAC reduce using rule 30 (rule_or_not -> rule .)
|
|
int reduce using rule 30 (rule_or_not -> rule .)
|
|
float reduce using rule 30 (rule_or_not -> rule .)
|
|
hex reduce using rule 30 (rule_or_not -> rule .)
|
|
string reduce using rule 30 (rule_or_not -> rule .)
|
|
} reduce using rule 30 (rule_or_not -> rule .)
|
|
|
|
|
|
state 68
|
|
|
|
(54) arg -> MAC .
|
|
|
|
, reduce using rule 54 (arg -> MAC .)
|
|
) reduce using rule 54 (arg -> MAC .)
|
|
EQ reduce using rule 54 (arg -> MAC .)
|
|
LT reduce using rule 54 (arg -> MAC .)
|
|
GT reduce using rule 54 (arg -> MAC .)
|
|
LTEQ reduce using rule 54 (arg -> MAC .)
|
|
GTEQ reduce using rule 54 (arg -> MAC .)
|
|
ML reduce using rule 54 (arg -> MAC .)
|
|
MG reduce using rule 54 (arg -> MAC .)
|
|
inKeyword reduce using rule 54 (arg -> MAC .)
|
|
notinKeyword reduce using rule 54 (arg -> MAC .)
|
|
ORKeyword reduce using rule 54 (arg -> MAC .)
|
|
NOTKeyword reduce using rule 54 (arg -> MAC .)
|
|
id reduce using rule 54 (arg -> MAC .)
|
|
bitANDKeyword reduce using rule 54 (arg -> MAC .)
|
|
bitORKeyword reduce using rule 54 (arg -> MAC .)
|
|
IPv4 reduce using rule 54 (arg -> MAC .)
|
|
IPv6 reduce using rule 54 (arg -> MAC .)
|
|
MAC reduce using rule 54 (arg -> MAC .)
|
|
int reduce using rule 54 (arg -> MAC .)
|
|
float reduce using rule 54 (arg -> MAC .)
|
|
hex reduce using rule 54 (arg -> MAC .)
|
|
string reduce using rule 54 (arg -> MAC .)
|
|
} reduce using rule 54 (arg -> MAC .)
|
|
|
|
|
|
state 69
|
|
|
|
(27) or_rule -> rule_or_not . opt_rule
|
|
(28) opt_rule -> . ORKeyword rule_or_not opt_rule
|
|
(29) opt_rule -> .
|
|
|
|
ORKeyword shift and go to state 109
|
|
NOTKeyword reduce using rule 29 (opt_rule -> .)
|
|
id reduce using rule 29 (opt_rule -> .)
|
|
bitANDKeyword reduce using rule 29 (opt_rule -> .)
|
|
bitORKeyword reduce using rule 29 (opt_rule -> .)
|
|
IPv4 reduce using rule 29 (opt_rule -> .)
|
|
IPv6 reduce using rule 29 (opt_rule -> .)
|
|
MAC reduce using rule 29 (opt_rule -> .)
|
|
int reduce using rule 29 (opt_rule -> .)
|
|
float reduce using rule 29 (opt_rule -> .)
|
|
hex reduce using rule 29 (opt_rule -> .)
|
|
string reduce using rule 29 (opt_rule -> .)
|
|
} reduce using rule 29 (opt_rule -> .)
|
|
|
|
opt_rule shift and go to state 108
|
|
|
|
state 70
|
|
|
|
(51) arg -> IPv4 .
|
|
(60) CIDR -> IPv4 . / int
|
|
|
|
, reduce using rule 51 (arg -> IPv4 .)
|
|
) reduce using rule 51 (arg -> IPv4 .)
|
|
EQ reduce using rule 51 (arg -> IPv4 .)
|
|
LT reduce using rule 51 (arg -> IPv4 .)
|
|
GT reduce using rule 51 (arg -> IPv4 .)
|
|
LTEQ reduce using rule 51 (arg -> IPv4 .)
|
|
GTEQ reduce using rule 51 (arg -> IPv4 .)
|
|
ML reduce using rule 51 (arg -> IPv4 .)
|
|
MG reduce using rule 51 (arg -> IPv4 .)
|
|
inKeyword reduce using rule 51 (arg -> IPv4 .)
|
|
notinKeyword reduce using rule 51 (arg -> IPv4 .)
|
|
ORKeyword reduce using rule 51 (arg -> IPv4 .)
|
|
NOTKeyword reduce using rule 51 (arg -> IPv4 .)
|
|
id reduce using rule 51 (arg -> IPv4 .)
|
|
bitANDKeyword reduce using rule 51 (arg -> IPv4 .)
|
|
bitORKeyword reduce using rule 51 (arg -> IPv4 .)
|
|
IPv4 reduce using rule 51 (arg -> IPv4 .)
|
|
IPv6 reduce using rule 51 (arg -> IPv4 .)
|
|
MAC reduce using rule 51 (arg -> IPv4 .)
|
|
int reduce using rule 51 (arg -> IPv4 .)
|
|
float reduce using rule 51 (arg -> IPv4 .)
|
|
hex reduce using rule 51 (arg -> IPv4 .)
|
|
string reduce using rule 51 (arg -> IPv4 .)
|
|
} reduce using rule 51 (arg -> IPv4 .)
|
|
/ shift and go to state 110
|
|
|
|
|
|
state 71
|
|
|
|
(52) arg -> IPv6 .
|
|
(61) CIDR -> IPv6 . / int
|
|
|
|
, reduce using rule 52 (arg -> IPv6 .)
|
|
) reduce using rule 52 (arg -> IPv6 .)
|
|
EQ reduce using rule 52 (arg -> IPv6 .)
|
|
LT reduce using rule 52 (arg -> IPv6 .)
|
|
GT reduce using rule 52 (arg -> IPv6 .)
|
|
LTEQ reduce using rule 52 (arg -> IPv6 .)
|
|
GTEQ reduce using rule 52 (arg -> IPv6 .)
|
|
ML reduce using rule 52 (arg -> IPv6 .)
|
|
MG reduce using rule 52 (arg -> IPv6 .)
|
|
inKeyword reduce using rule 52 (arg -> IPv6 .)
|
|
notinKeyword reduce using rule 52 (arg -> IPv6 .)
|
|
ORKeyword reduce using rule 52 (arg -> IPv6 .)
|
|
NOTKeyword reduce using rule 52 (arg -> IPv6 .)
|
|
id reduce using rule 52 (arg -> IPv6 .)
|
|
bitANDKeyword reduce using rule 52 (arg -> IPv6 .)
|
|
bitORKeyword reduce using rule 52 (arg -> IPv6 .)
|
|
IPv4 reduce using rule 52 (arg -> IPv6 .)
|
|
IPv6 reduce using rule 52 (arg -> IPv6 .)
|
|
MAC reduce using rule 52 (arg -> IPv6 .)
|
|
int reduce using rule 52 (arg -> IPv6 .)
|
|
float reduce using rule 52 (arg -> IPv6 .)
|
|
hex reduce using rule 52 (arg -> IPv6 .)
|
|
string reduce using rule 52 (arg -> IPv6 .)
|
|
} reduce using rule 52 (arg -> IPv6 .)
|
|
/ shift and go to state 111
|
|
|
|
|
|
state 72
|
|
|
|
(12) splitter -> splitterKeyword id { } .
|
|
|
|
splitterKeyword reduce using rule 12 (splitter -> splitterKeyword id { } .)
|
|
filterKeyword reduce using rule 12 (splitter -> splitterKeyword id { } .)
|
|
id reduce using rule 12 (splitter -> splitterKeyword id { } .)
|
|
string reduce using rule 12 (splitter -> splitterKeyword id { } .)
|
|
ungrouperKeyword reduce using rule 12 (splitter -> splitterKeyword id { } .)
|
|
grouperKeyword reduce using rule 12 (splitter -> splitterKeyword id { } .)
|
|
groupFilterKeyword reduce using rule 12 (splitter -> splitterKeyword id { } .)
|
|
mergerKeyword reduce using rule 12 (splitter -> splitterKeyword id { } .)
|
|
$end reduce using rule 12 (splitter -> splitterKeyword id { } .)
|
|
|
|
|
|
state 73
|
|
|
|
(109) merger_module1_n -> merger_module . merger_module1_n
|
|
(109) merger_module1_n -> . merger_module merger_module1_n
|
|
(110) merger_module1_n -> .
|
|
(111) merger_module -> . moduleKeyword id { merger_branches merger_rule1_n }
|
|
|
|
exportKeyword reduce using rule 110 (merger_module1_n -> .)
|
|
moduleKeyword shift and go to state 75
|
|
|
|
merger_module shift and go to state 73
|
|
merger_module1_n shift and go to state 112
|
|
|
|
state 74
|
|
|
|
(108) merger -> mergerKeyword id { merger_module1_n . export }
|
|
(115) export -> . exportKeyword id
|
|
|
|
exportKeyword shift and go to state 113
|
|
|
|
export shift and go to state 114
|
|
|
|
state 75
|
|
|
|
(111) merger_module -> moduleKeyword . id { merger_branches merger_rule1_n }
|
|
|
|
id shift and go to state 115
|
|
|
|
|
|
state 76
|
|
|
|
(70) ungrouper -> ungrouperKeyword id { } .
|
|
|
|
splitterKeyword reduce using rule 70 (ungrouper -> ungrouperKeyword id { } .)
|
|
filterKeyword reduce using rule 70 (ungrouper -> ungrouperKeyword id { } .)
|
|
id reduce using rule 70 (ungrouper -> ungrouperKeyword id { } .)
|
|
string reduce using rule 70 (ungrouper -> ungrouperKeyword id { } .)
|
|
ungrouperKeyword reduce using rule 70 (ungrouper -> ungrouperKeyword id { } .)
|
|
grouperKeyword reduce using rule 70 (ungrouper -> ungrouperKeyword id { } .)
|
|
groupFilterKeyword reduce using rule 70 (ungrouper -> ungrouperKeyword id { } .)
|
|
mergerKeyword reduce using rule 70 (ungrouper -> ungrouperKeyword id { } .)
|
|
$end reduce using rule 70 (ungrouper -> ungrouperKeyword id { } .)
|
|
|
|
|
|
state 77
|
|
|
|
(44) prefix_rule -> id . ( args )
|
|
(50) arg -> id .
|
|
|
|
( shift and go to state 97
|
|
EQ reduce using rule 50 (arg -> id .)
|
|
LT reduce using rule 50 (arg -> id .)
|
|
GT reduce using rule 50 (arg -> id .)
|
|
LTEQ reduce using rule 50 (arg -> id .)
|
|
GTEQ reduce using rule 50 (arg -> id .)
|
|
ML reduce using rule 50 (arg -> id .)
|
|
MG reduce using rule 50 (arg -> id .)
|
|
inKeyword reduce using rule 50 (arg -> id .)
|
|
notinKeyword reduce using rule 50 (arg -> id .)
|
|
|
|
|
|
state 78
|
|
|
|
(31) rule_or_not -> NOTKeyword . rule
|
|
(32) rule -> . infix_rule
|
|
(33) rule -> . prefix_rule
|
|
(34) infix_rule -> . arg op arg
|
|
(44) prefix_rule -> . id ( args )
|
|
(45) prefix_rule -> . bitANDKeyword ( args )
|
|
(46) prefix_rule -> . bitORKeyword ( args )
|
|
(50) arg -> . id
|
|
(51) arg -> . IPv4
|
|
(52) arg -> . IPv6
|
|
(53) arg -> . CIDR
|
|
(54) arg -> . MAC
|
|
(55) arg -> . int
|
|
(56) arg -> . float
|
|
(57) arg -> . hex
|
|
(58) arg -> . prefix_rule
|
|
(59) arg -> . string
|
|
(60) CIDR -> . IPv4 / int
|
|
(61) CIDR -> . IPv6 / int
|
|
|
|
id shift and go to state 77
|
|
bitANDKeyword shift and go to state 48
|
|
bitORKeyword shift and go to state 58
|
|
IPv4 shift and go to state 70
|
|
IPv6 shift and go to state 71
|
|
MAC shift and go to state 68
|
|
int shift and go to state 51
|
|
float shift and go to state 52
|
|
hex shift and go to state 60
|
|
string shift and go to state 62
|
|
|
|
prefix_rule shift and go to state 54
|
|
infix_rule shift and go to state 53
|
|
rule shift and go to state 98
|
|
arg shift and go to state 55
|
|
CIDR shift and go to state 65
|
|
|
|
state 79
|
|
|
|
(15) group_filter -> groupFilterKeyword id { filter_rule_1n . }
|
|
|
|
} shift and go to state 116
|
|
|
|
|
|
state 80
|
|
|
|
(74) module -> moduleKeyword id . { grouper_rule1_n }
|
|
|
|
{ shift and go to state 117
|
|
|
|
|
|
state 81
|
|
|
|
(90) aggregate -> aggregateKeyword . aggr1_n
|
|
(91) aggr1_n -> . aggr opt_aggr
|
|
(94) aggr -> . aggr_op ( id_or_qid ) asKeyword id
|
|
(95) aggr -> . id_or_qid asKeyword id
|
|
(96) aggr -> . id_or_qid
|
|
(100) aggr_op -> . minKeyword
|
|
(101) aggr_op -> . maxKeyword
|
|
(102) aggr_op -> . sumKeyword
|
|
(103) aggr_op -> . avgKeyword
|
|
(104) aggr_op -> . unionKeyword
|
|
(105) aggr_op -> . countKeyword
|
|
(106) aggr_op -> . bitANDKeyword
|
|
(107) aggr_op -> . bitORKeyword
|
|
(98) id_or_qid -> . id
|
|
(99) id_or_qid -> . qid
|
|
(97) qid -> . id . id
|
|
|
|
minKeyword shift and go to state 121
|
|
maxKeyword shift and go to state 120
|
|
sumKeyword shift and go to state 125
|
|
avgKeyword shift and go to state 127
|
|
unionKeyword shift and go to state 126
|
|
countKeyword shift and go to state 130
|
|
bitANDKeyword shift and go to state 119
|
|
bitORKeyword shift and go to state 128
|
|
id shift and go to state 123
|
|
|
|
aggr_op shift and go to state 118
|
|
qid shift and go to state 124
|
|
aggr shift and go to state 129
|
|
id_or_qid shift and go to state 122
|
|
aggr1_n shift and go to state 131
|
|
|
|
state 82
|
|
|
|
(71) grouper -> grouperKeyword id { module1_n aggregate . }
|
|
|
|
} shift and go to state 132
|
|
|
|
|
|
state 83
|
|
|
|
(72) module1_n -> module module1_n .
|
|
|
|
aggregateKeyword reduce using rule 72 (module1_n -> module module1_n .)
|
|
|
|
|
|
state 84
|
|
|
|
(65) mid_branch -> id arrow mid_branch .
|
|
|
|
splitterKeyword reduce using rule 65 (mid_branch -> id arrow mid_branch .)
|
|
filterKeyword reduce using rule 65 (mid_branch -> id arrow mid_branch .)
|
|
id reduce using rule 65 (mid_branch -> id arrow mid_branch .)
|
|
string reduce using rule 65 (mid_branch -> id arrow mid_branch .)
|
|
ungrouperKeyword reduce using rule 65 (mid_branch -> id arrow mid_branch .)
|
|
grouperKeyword reduce using rule 65 (mid_branch -> id arrow mid_branch .)
|
|
groupFilterKeyword reduce using rule 65 (mid_branch -> id arrow mid_branch .)
|
|
mergerKeyword reduce using rule 65 (mid_branch -> id arrow mid_branch .)
|
|
$end reduce using rule 65 (mid_branch -> id arrow mid_branch .)
|
|
|
|
|
|
state 85
|
|
|
|
(45) prefix_rule -> bitANDKeyword ( . args )
|
|
(47) args -> . arg , args
|
|
(48) args -> . arg
|
|
(49) args -> .
|
|
(50) arg -> . id
|
|
(51) arg -> . IPv4
|
|
(52) arg -> . IPv6
|
|
(53) arg -> . CIDR
|
|
(54) arg -> . MAC
|
|
(55) arg -> . int
|
|
(56) arg -> . float
|
|
(57) arg -> . hex
|
|
(58) arg -> . prefix_rule
|
|
(59) arg -> . string
|
|
(60) CIDR -> . IPv4 / int
|
|
(61) CIDR -> . IPv6 / int
|
|
(44) prefix_rule -> . id ( args )
|
|
(45) prefix_rule -> . bitANDKeyword ( args )
|
|
(46) prefix_rule -> . bitORKeyword ( args )
|
|
|
|
) reduce using rule 49 (args -> .)
|
|
id shift and go to state 136
|
|
IPv4 shift and go to state 70
|
|
IPv6 shift and go to state 71
|
|
MAC shift and go to state 68
|
|
int shift and go to state 51
|
|
float shift and go to state 52
|
|
hex shift and go to state 60
|
|
string shift and go to state 62
|
|
bitANDKeyword shift and go to state 48
|
|
bitORKeyword shift and go to state 58
|
|
|
|
CIDR shift and go to state 65
|
|
args shift and go to state 133
|
|
prefix_rule shift and go to state 134
|
|
arg shift and go to state 135
|
|
|
|
state 86
|
|
|
|
(14) composite_filter -> filterKeyword id { filter_ref_rule_1n } .
|
|
|
|
splitterKeyword reduce using rule 14 (composite_filter -> filterKeyword id { filter_ref_rule_1n } .)
|
|
filterKeyword reduce using rule 14 (composite_filter -> filterKeyword id { filter_ref_rule_1n } .)
|
|
id reduce using rule 14 (composite_filter -> filterKeyword id { filter_ref_rule_1n } .)
|
|
string reduce using rule 14 (composite_filter -> filterKeyword id { filter_ref_rule_1n } .)
|
|
ungrouperKeyword reduce using rule 14 (composite_filter -> filterKeyword id { filter_ref_rule_1n } .)
|
|
grouperKeyword reduce using rule 14 (composite_filter -> filterKeyword id { filter_ref_rule_1n } .)
|
|
groupFilterKeyword reduce using rule 14 (composite_filter -> filterKeyword id { filter_ref_rule_1n } .)
|
|
mergerKeyword reduce using rule 14 (composite_filter -> filterKeyword id { filter_ref_rule_1n } .)
|
|
$end reduce using rule 14 (composite_filter -> filterKeyword id { filter_ref_rule_1n } .)
|
|
|
|
|
|
state 87
|
|
|
|
(41) op -> MG .
|
|
|
|
IPv4 reduce using rule 41 (op -> MG .)
|
|
IPv6 reduce using rule 41 (op -> MG .)
|
|
MAC reduce using rule 41 (op -> MG .)
|
|
int reduce using rule 41 (op -> MG .)
|
|
float reduce using rule 41 (op -> MG .)
|
|
hex reduce using rule 41 (op -> MG .)
|
|
string reduce using rule 41 (op -> MG .)
|
|
id reduce using rule 41 (op -> MG .)
|
|
bitANDKeyword reduce using rule 41 (op -> MG .)
|
|
bitORKeyword reduce using rule 41 (op -> MG .)
|
|
|
|
|
|
state 88
|
|
|
|
(37) op -> GT .
|
|
|
|
IPv4 reduce using rule 37 (op -> GT .)
|
|
IPv6 reduce using rule 37 (op -> GT .)
|
|
MAC reduce using rule 37 (op -> GT .)
|
|
int reduce using rule 37 (op -> GT .)
|
|
float reduce using rule 37 (op -> GT .)
|
|
hex reduce using rule 37 (op -> GT .)
|
|
string reduce using rule 37 (op -> GT .)
|
|
id reduce using rule 37 (op -> GT .)
|
|
bitANDKeyword reduce using rule 37 (op -> GT .)
|
|
bitORKeyword reduce using rule 37 (op -> GT .)
|
|
|
|
|
|
state 89
|
|
|
|
(39) op -> GTEQ .
|
|
|
|
IPv4 reduce using rule 39 (op -> GTEQ .)
|
|
IPv6 reduce using rule 39 (op -> GTEQ .)
|
|
MAC reduce using rule 39 (op -> GTEQ .)
|
|
int reduce using rule 39 (op -> GTEQ .)
|
|
float reduce using rule 39 (op -> GTEQ .)
|
|
hex reduce using rule 39 (op -> GTEQ .)
|
|
string reduce using rule 39 (op -> GTEQ .)
|
|
id reduce using rule 39 (op -> GTEQ .)
|
|
bitANDKeyword reduce using rule 39 (op -> GTEQ .)
|
|
bitORKeyword reduce using rule 39 (op -> GTEQ .)
|
|
|
|
|
|
state 90
|
|
|
|
(40) op -> ML .
|
|
|
|
IPv4 reduce using rule 40 (op -> ML .)
|
|
IPv6 reduce using rule 40 (op -> ML .)
|
|
MAC reduce using rule 40 (op -> ML .)
|
|
int reduce using rule 40 (op -> ML .)
|
|
float reduce using rule 40 (op -> ML .)
|
|
hex reduce using rule 40 (op -> ML .)
|
|
string reduce using rule 40 (op -> ML .)
|
|
id reduce using rule 40 (op -> ML .)
|
|
bitANDKeyword reduce using rule 40 (op -> ML .)
|
|
bitORKeyword reduce using rule 40 (op -> ML .)
|
|
|
|
|
|
state 91
|
|
|
|
(38) op -> LTEQ .
|
|
|
|
IPv4 reduce using rule 38 (op -> LTEQ .)
|
|
IPv6 reduce using rule 38 (op -> LTEQ .)
|
|
MAC reduce using rule 38 (op -> LTEQ .)
|
|
int reduce using rule 38 (op -> LTEQ .)
|
|
float reduce using rule 38 (op -> LTEQ .)
|
|
hex reduce using rule 38 (op -> LTEQ .)
|
|
string reduce using rule 38 (op -> LTEQ .)
|
|
id reduce using rule 38 (op -> LTEQ .)
|
|
bitANDKeyword reduce using rule 38 (op -> LTEQ .)
|
|
bitORKeyword reduce using rule 38 (op -> LTEQ .)
|
|
|
|
|
|
state 92
|
|
|
|
(42) op -> inKeyword .
|
|
|
|
IPv4 reduce using rule 42 (op -> inKeyword .)
|
|
IPv6 reduce using rule 42 (op -> inKeyword .)
|
|
MAC reduce using rule 42 (op -> inKeyword .)
|
|
int reduce using rule 42 (op -> inKeyword .)
|
|
float reduce using rule 42 (op -> inKeyword .)
|
|
hex reduce using rule 42 (op -> inKeyword .)
|
|
string reduce using rule 42 (op -> inKeyword .)
|
|
id reduce using rule 42 (op -> inKeyword .)
|
|
bitANDKeyword reduce using rule 42 (op -> inKeyword .)
|
|
bitORKeyword reduce using rule 42 (op -> inKeyword .)
|
|
|
|
|
|
state 93
|
|
|
|
(36) op -> LT .
|
|
|
|
IPv4 reduce using rule 36 (op -> LT .)
|
|
IPv6 reduce using rule 36 (op -> LT .)
|
|
MAC reduce using rule 36 (op -> LT .)
|
|
int reduce using rule 36 (op -> LT .)
|
|
float reduce using rule 36 (op -> LT .)
|
|
hex reduce using rule 36 (op -> LT .)
|
|
string reduce using rule 36 (op -> LT .)
|
|
id reduce using rule 36 (op -> LT .)
|
|
bitANDKeyword reduce using rule 36 (op -> LT .)
|
|
bitORKeyword reduce using rule 36 (op -> LT .)
|
|
|
|
|
|
state 94
|
|
|
|
(43) op -> notinKeyword .
|
|
|
|
IPv4 reduce using rule 43 (op -> notinKeyword .)
|
|
IPv6 reduce using rule 43 (op -> notinKeyword .)
|
|
MAC reduce using rule 43 (op -> notinKeyword .)
|
|
int reduce using rule 43 (op -> notinKeyword .)
|
|
float reduce using rule 43 (op -> notinKeyword .)
|
|
hex reduce using rule 43 (op -> notinKeyword .)
|
|
string reduce using rule 43 (op -> notinKeyword .)
|
|
id reduce using rule 43 (op -> notinKeyword .)
|
|
bitANDKeyword reduce using rule 43 (op -> notinKeyword .)
|
|
bitORKeyword reduce using rule 43 (op -> notinKeyword .)
|
|
|
|
|
|
state 95
|
|
|
|
(35) op -> EQ .
|
|
|
|
IPv4 reduce using rule 35 (op -> EQ .)
|
|
IPv6 reduce using rule 35 (op -> EQ .)
|
|
MAC reduce using rule 35 (op -> EQ .)
|
|
int reduce using rule 35 (op -> EQ .)
|
|
float reduce using rule 35 (op -> EQ .)
|
|
hex reduce using rule 35 (op -> EQ .)
|
|
string reduce using rule 35 (op -> EQ .)
|
|
id reduce using rule 35 (op -> EQ .)
|
|
bitANDKeyword reduce using rule 35 (op -> EQ .)
|
|
bitORKeyword reduce using rule 35 (op -> EQ .)
|
|
|
|
|
|
state 96
|
|
|
|
(34) infix_rule -> arg op . arg
|
|
(50) arg -> . id
|
|
(51) arg -> . IPv4
|
|
(52) arg -> . IPv6
|
|
(53) arg -> . CIDR
|
|
(54) arg -> . MAC
|
|
(55) arg -> . int
|
|
(56) arg -> . float
|
|
(57) arg -> . hex
|
|
(58) arg -> . prefix_rule
|
|
(59) arg -> . string
|
|
(60) CIDR -> . IPv4 / int
|
|
(61) CIDR -> . IPv6 / int
|
|
(44) prefix_rule -> . id ( args )
|
|
(45) prefix_rule -> . bitANDKeyword ( args )
|
|
(46) prefix_rule -> . bitORKeyword ( args )
|
|
|
|
id shift and go to state 136
|
|
IPv4 shift and go to state 70
|
|
IPv6 shift and go to state 71
|
|
MAC shift and go to state 68
|
|
int shift and go to state 51
|
|
float shift and go to state 52
|
|
hex shift and go to state 60
|
|
string shift and go to state 62
|
|
bitANDKeyword shift and go to state 48
|
|
bitORKeyword shift and go to state 58
|
|
|
|
CIDR shift and go to state 65
|
|
prefix_rule shift and go to state 134
|
|
arg shift and go to state 137
|
|
|
|
state 97
|
|
|
|
(44) prefix_rule -> id ( . args )
|
|
(47) args -> . arg , args
|
|
(48) args -> . arg
|
|
(49) args -> .
|
|
(50) arg -> . id
|
|
(51) arg -> . IPv4
|
|
(52) arg -> . IPv6
|
|
(53) arg -> . CIDR
|
|
(54) arg -> . MAC
|
|
(55) arg -> . int
|
|
(56) arg -> . float
|
|
(57) arg -> . hex
|
|
(58) arg -> . prefix_rule
|
|
(59) arg -> . string
|
|
(60) CIDR -> . IPv4 / int
|
|
(61) CIDR -> . IPv6 / int
|
|
(44) prefix_rule -> . id ( args )
|
|
(45) prefix_rule -> . bitANDKeyword ( args )
|
|
(46) prefix_rule -> . bitORKeyword ( args )
|
|
|
|
) reduce using rule 49 (args -> .)
|
|
id shift and go to state 136
|
|
IPv4 shift and go to state 70
|
|
IPv6 shift and go to state 71
|
|
MAC shift and go to state 68
|
|
int shift and go to state 51
|
|
float shift and go to state 52
|
|
hex shift and go to state 60
|
|
string shift and go to state 62
|
|
bitANDKeyword shift and go to state 48
|
|
bitORKeyword shift and go to state 58
|
|
|
|
CIDR shift and go to state 65
|
|
args shift and go to state 138
|
|
prefix_rule shift and go to state 134
|
|
arg shift and go to state 135
|
|
|
|
state 98
|
|
|
|
(31) rule_or_not -> NOTKeyword rule .
|
|
|
|
ORKeyword reduce using rule 31 (rule_or_not -> NOTKeyword rule .)
|
|
NOTKeyword reduce using rule 31 (rule_or_not -> NOTKeyword rule .)
|
|
id reduce using rule 31 (rule_or_not -> NOTKeyword rule .)
|
|
bitANDKeyword reduce using rule 31 (rule_or_not -> NOTKeyword rule .)
|
|
bitORKeyword reduce using rule 31 (rule_or_not -> NOTKeyword rule .)
|
|
IPv4 reduce using rule 31 (rule_or_not -> NOTKeyword rule .)
|
|
IPv6 reduce using rule 31 (rule_or_not -> NOTKeyword rule .)
|
|
MAC reduce using rule 31 (rule_or_not -> NOTKeyword rule .)
|
|
int reduce using rule 31 (rule_or_not -> NOTKeyword rule .)
|
|
float reduce using rule 31 (rule_or_not -> NOTKeyword rule .)
|
|
hex reduce using rule 31 (rule_or_not -> NOTKeyword rule .)
|
|
string reduce using rule 31 (rule_or_not -> NOTKeyword rule .)
|
|
} reduce using rule 31 (rule_or_not -> NOTKeyword rule .)
|
|
|
|
|
|
state 99
|
|
|
|
(25) not_id -> NOTKeyword id .
|
|
(44) prefix_rule -> id . ( args )
|
|
(50) arg -> id .
|
|
|
|
ORKeyword reduce using rule 25 (not_id -> NOTKeyword id .)
|
|
NOTKeyword reduce using rule 25 (not_id -> NOTKeyword id .)
|
|
id reduce using rule 25 (not_id -> NOTKeyword id .)
|
|
} reduce using rule 25 (not_id -> NOTKeyword id .)
|
|
( shift and go to state 97
|
|
EQ reduce using rule 50 (arg -> id .)
|
|
LT reduce using rule 50 (arg -> id .)
|
|
GT reduce using rule 50 (arg -> id .)
|
|
LTEQ reduce using rule 50 (arg -> id .)
|
|
GTEQ reduce using rule 50 (arg -> id .)
|
|
ML reduce using rule 50 (arg -> id .)
|
|
MG reduce using rule 50 (arg -> id .)
|
|
inKeyword reduce using rule 50 (arg -> id .)
|
|
notinKeyword reduce using rule 50 (arg -> id .)
|
|
|
|
|
|
state 100
|
|
|
|
(46) prefix_rule -> bitORKeyword ( . args )
|
|
(47) args -> . arg , args
|
|
(48) args -> . arg
|
|
(49) args -> .
|
|
(50) arg -> . id
|
|
(51) arg -> . IPv4
|
|
(52) arg -> . IPv6
|
|
(53) arg -> . CIDR
|
|
(54) arg -> . MAC
|
|
(55) arg -> . int
|
|
(56) arg -> . float
|
|
(57) arg -> . hex
|
|
(58) arg -> . prefix_rule
|
|
(59) arg -> . string
|
|
(60) CIDR -> . IPv4 / int
|
|
(61) CIDR -> . IPv6 / int
|
|
(44) prefix_rule -> . id ( args )
|
|
(45) prefix_rule -> . bitANDKeyword ( args )
|
|
(46) prefix_rule -> . bitORKeyword ( args )
|
|
|
|
) reduce using rule 49 (args -> .)
|
|
id shift and go to state 136
|
|
IPv4 shift and go to state 70
|
|
IPv6 shift and go to state 71
|
|
MAC shift and go to state 68
|
|
int shift and go to state 51
|
|
float shift and go to state 52
|
|
hex shift and go to state 60
|
|
string shift and go to state 62
|
|
bitANDKeyword shift and go to state 48
|
|
bitORKeyword shift and go to state 58
|
|
|
|
CIDR shift and go to state 65
|
|
args shift and go to state 139
|
|
prefix_rule shift and go to state 134
|
|
arg shift and go to state 135
|
|
|
|
state 101
|
|
|
|
(16) filter_rule_1n -> filter_rule filter_rule_1n .
|
|
|
|
} reduce using rule 16 (filter_rule_1n -> filter_rule filter_rule_1n .)
|
|
|
|
|
|
state 102
|
|
|
|
(25) not_id -> NOTKeyword . id
|
|
|
|
id shift and go to state 140
|
|
|
|
|
|
state 103
|
|
|
|
(19) filter_ref_rule_1n -> filter_ref_rule filter_ref_rule_1n .
|
|
|
|
} reduce using rule 19 (filter_ref_rule_1n -> filter_ref_rule filter_ref_rule_1n .)
|
|
|
|
|
|
state 104
|
|
|
|
(26) not_id -> id .
|
|
|
|
ORKeyword reduce using rule 26 (not_id -> id .)
|
|
NOTKeyword reduce using rule 26 (not_id -> id .)
|
|
id reduce using rule 26 (not_id -> id .)
|
|
} reduce using rule 26 (not_id -> id .)
|
|
|
|
|
|
state 105
|
|
|
|
(13) filter -> filterKeyword id { filter_rule_1n } .
|
|
|
|
splitterKeyword reduce using rule 13 (filter -> filterKeyword id { filter_rule_1n } .)
|
|
filterKeyword reduce using rule 13 (filter -> filterKeyword id { filter_rule_1n } .)
|
|
id reduce using rule 13 (filter -> filterKeyword id { filter_rule_1n } .)
|
|
string reduce using rule 13 (filter -> filterKeyword id { filter_rule_1n } .)
|
|
ungrouperKeyword reduce using rule 13 (filter -> filterKeyword id { filter_rule_1n } .)
|
|
grouperKeyword reduce using rule 13 (filter -> filterKeyword id { filter_rule_1n } .)
|
|
groupFilterKeyword reduce using rule 13 (filter -> filterKeyword id { filter_rule_1n } .)
|
|
mergerKeyword reduce using rule 13 (filter -> filterKeyword id { filter_rule_1n } .)
|
|
$end reduce using rule 13 (filter -> filterKeyword id { filter_rule_1n } .)
|
|
|
|
|
|
state 106
|
|
|
|
(23) opt_or_id -> ORKeyword . not_id opt_or_id
|
|
(25) not_id -> . NOTKeyword id
|
|
(26) not_id -> . id
|
|
|
|
NOTKeyword shift and go to state 102
|
|
id shift and go to state 104
|
|
|
|
not_id shift and go to state 141
|
|
|
|
state 107
|
|
|
|
(22) or_id -> not_id opt_or_id .
|
|
|
|
NOTKeyword reduce using rule 22 (or_id -> not_id opt_or_id .)
|
|
id reduce using rule 22 (or_id -> not_id opt_or_id .)
|
|
} reduce using rule 22 (or_id -> not_id opt_or_id .)
|
|
|
|
|
|
state 108
|
|
|
|
(27) or_rule -> rule_or_not opt_rule .
|
|
|
|
NOTKeyword reduce using rule 27 (or_rule -> rule_or_not opt_rule .)
|
|
id reduce using rule 27 (or_rule -> rule_or_not opt_rule .)
|
|
bitANDKeyword reduce using rule 27 (or_rule -> rule_or_not opt_rule .)
|
|
bitORKeyword reduce using rule 27 (or_rule -> rule_or_not opt_rule .)
|
|
IPv4 reduce using rule 27 (or_rule -> rule_or_not opt_rule .)
|
|
IPv6 reduce using rule 27 (or_rule -> rule_or_not opt_rule .)
|
|
MAC reduce using rule 27 (or_rule -> rule_or_not opt_rule .)
|
|
int reduce using rule 27 (or_rule -> rule_or_not opt_rule .)
|
|
float reduce using rule 27 (or_rule -> rule_or_not opt_rule .)
|
|
hex reduce using rule 27 (or_rule -> rule_or_not opt_rule .)
|
|
string reduce using rule 27 (or_rule -> rule_or_not opt_rule .)
|
|
} reduce using rule 27 (or_rule -> rule_or_not opt_rule .)
|
|
|
|
|
|
state 109
|
|
|
|
(28) opt_rule -> ORKeyword . rule_or_not opt_rule
|
|
(30) rule_or_not -> . rule
|
|
(31) rule_or_not -> . NOTKeyword rule
|
|
(32) rule -> . infix_rule
|
|
(33) rule -> . prefix_rule
|
|
(34) infix_rule -> . arg op arg
|
|
(44) prefix_rule -> . id ( args )
|
|
(45) prefix_rule -> . bitANDKeyword ( args )
|
|
(46) prefix_rule -> . bitORKeyword ( args )
|
|
(50) arg -> . id
|
|
(51) arg -> . IPv4
|
|
(52) arg -> . IPv6
|
|
(53) arg -> . CIDR
|
|
(54) arg -> . MAC
|
|
(55) arg -> . int
|
|
(56) arg -> . float
|
|
(57) arg -> . hex
|
|
(58) arg -> . prefix_rule
|
|
(59) arg -> . string
|
|
(60) CIDR -> . IPv4 / int
|
|
(61) CIDR -> . IPv6 / int
|
|
|
|
NOTKeyword shift and go to state 78
|
|
id shift and go to state 77
|
|
bitANDKeyword shift and go to state 48
|
|
bitORKeyword shift and go to state 58
|
|
IPv4 shift and go to state 70
|
|
IPv6 shift and go to state 71
|
|
MAC shift and go to state 68
|
|
int shift and go to state 51
|
|
float shift and go to state 52
|
|
hex shift and go to state 60
|
|
string shift and go to state 62
|
|
|
|
prefix_rule shift and go to state 54
|
|
infix_rule shift and go to state 53
|
|
rule_or_not shift and go to state 142
|
|
rule shift and go to state 67
|
|
arg shift and go to state 55
|
|
CIDR shift and go to state 65
|
|
|
|
state 110
|
|
|
|
(60) CIDR -> IPv4 / . int
|
|
|
|
int shift and go to state 143
|
|
|
|
|
|
state 111
|
|
|
|
(61) CIDR -> IPv6 / . int
|
|
|
|
int shift and go to state 144
|
|
|
|
|
|
state 112
|
|
|
|
(109) merger_module1_n -> merger_module merger_module1_n .
|
|
|
|
exportKeyword reduce using rule 109 (merger_module1_n -> merger_module merger_module1_n .)
|
|
|
|
|
|
state 113
|
|
|
|
(115) export -> exportKeyword . id
|
|
|
|
id shift and go to state 145
|
|
|
|
|
|
state 114
|
|
|
|
(108) merger -> mergerKeyword id { merger_module1_n export . }
|
|
|
|
} shift and go to state 146
|
|
|
|
|
|
state 115
|
|
|
|
(111) merger_module -> moduleKeyword id . { merger_branches merger_rule1_n }
|
|
|
|
{ shift and go to state 147
|
|
|
|
|
|
state 116
|
|
|
|
(15) group_filter -> groupFilterKeyword id { filter_rule_1n } .
|
|
|
|
splitterKeyword reduce using rule 15 (group_filter -> groupFilterKeyword id { filter_rule_1n } .)
|
|
filterKeyword reduce using rule 15 (group_filter -> groupFilterKeyword id { filter_rule_1n } .)
|
|
id reduce using rule 15 (group_filter -> groupFilterKeyword id { filter_rule_1n } .)
|
|
string reduce using rule 15 (group_filter -> groupFilterKeyword id { filter_rule_1n } .)
|
|
ungrouperKeyword reduce using rule 15 (group_filter -> groupFilterKeyword id { filter_rule_1n } .)
|
|
grouperKeyword reduce using rule 15 (group_filter -> groupFilterKeyword id { filter_rule_1n } .)
|
|
groupFilterKeyword reduce using rule 15 (group_filter -> groupFilterKeyword id { filter_rule_1n } .)
|
|
mergerKeyword reduce using rule 15 (group_filter -> groupFilterKeyword id { filter_rule_1n } .)
|
|
$end reduce using rule 15 (group_filter -> groupFilterKeyword id { filter_rule_1n } .)
|
|
|
|
|
|
state 117
|
|
|
|
(74) module -> moduleKeyword id { . grouper_rule1_n }
|
|
(75) grouper_rule1_n -> . grouper_rule grouper_rule1_n
|
|
(76) grouper_rule1_n -> .
|
|
(77) grouper_rule -> . id grouper_op id
|
|
(78) grouper_rule -> . id grouper_op id deltaKeyword delta_arg
|
|
(79) grouper_rule -> . id grouper_op id rdeltaKeyword delta_arg
|
|
|
|
} reduce using rule 76 (grouper_rule1_n -> .)
|
|
id shift and go to state 150
|
|
|
|
grouper_rule1_n shift and go to state 148
|
|
grouper_rule shift and go to state 149
|
|
|
|
state 118
|
|
|
|
(94) aggr -> aggr_op . ( id_or_qid ) asKeyword id
|
|
|
|
( shift and go to state 151
|
|
|
|
|
|
state 119
|
|
|
|
(106) aggr_op -> bitANDKeyword .
|
|
|
|
( reduce using rule 106 (aggr_op -> bitANDKeyword .)
|
|
|
|
|
|
state 120
|
|
|
|
(101) aggr_op -> maxKeyword .
|
|
|
|
( reduce using rule 101 (aggr_op -> maxKeyword .)
|
|
|
|
|
|
state 121
|
|
|
|
(100) aggr_op -> minKeyword .
|
|
|
|
( reduce using rule 100 (aggr_op -> minKeyword .)
|
|
|
|
|
|
state 122
|
|
|
|
(95) aggr -> id_or_qid . asKeyword id
|
|
(96) aggr -> id_or_qid .
|
|
|
|
asKeyword shift and go to state 152
|
|
, reduce using rule 96 (aggr -> id_or_qid .)
|
|
} reduce using rule 96 (aggr -> id_or_qid .)
|
|
|
|
|
|
state 123
|
|
|
|
(98) id_or_qid -> id .
|
|
(97) qid -> id . . id
|
|
|
|
) reduce using rule 98 (id_or_qid -> id .)
|
|
asKeyword reduce using rule 98 (id_or_qid -> id .)
|
|
, reduce using rule 98 (id_or_qid -> id .)
|
|
} reduce using rule 98 (id_or_qid -> id .)
|
|
. shift and go to state 153
|
|
|
|
|
|
state 124
|
|
|
|
(99) id_or_qid -> qid .
|
|
|
|
) reduce using rule 99 (id_or_qid -> qid .)
|
|
asKeyword reduce using rule 99 (id_or_qid -> qid .)
|
|
, reduce using rule 99 (id_or_qid -> qid .)
|
|
} reduce using rule 99 (id_or_qid -> qid .)
|
|
|
|
|
|
state 125
|
|
|
|
(102) aggr_op -> sumKeyword .
|
|
|
|
( reduce using rule 102 (aggr_op -> sumKeyword .)
|
|
|
|
|
|
state 126
|
|
|
|
(104) aggr_op -> unionKeyword .
|
|
|
|
( reduce using rule 104 (aggr_op -> unionKeyword .)
|
|
|
|
|
|
state 127
|
|
|
|
(103) aggr_op -> avgKeyword .
|
|
|
|
( reduce using rule 103 (aggr_op -> avgKeyword .)
|
|
|
|
|
|
state 128
|
|
|
|
(107) aggr_op -> bitORKeyword .
|
|
|
|
( reduce using rule 107 (aggr_op -> bitORKeyword .)
|
|
|
|
|
|
state 129
|
|
|
|
(91) aggr1_n -> aggr . opt_aggr
|
|
(92) opt_aggr -> . , aggr opt_aggr
|
|
(93) opt_aggr -> .
|
|
|
|
, shift and go to state 154
|
|
} reduce using rule 93 (opt_aggr -> .)
|
|
|
|
opt_aggr shift and go to state 155
|
|
|
|
state 130
|
|
|
|
(105) aggr_op -> countKeyword .
|
|
|
|
( reduce using rule 105 (aggr_op -> countKeyword .)
|
|
|
|
|
|
state 131
|
|
|
|
(90) aggregate -> aggregateKeyword aggr1_n .
|
|
|
|
} reduce using rule 90 (aggregate -> aggregateKeyword aggr1_n .)
|
|
|
|
|
|
state 132
|
|
|
|
(71) grouper -> grouperKeyword id { module1_n aggregate } .
|
|
|
|
splitterKeyword reduce using rule 71 (grouper -> grouperKeyword id { module1_n aggregate } .)
|
|
filterKeyword reduce using rule 71 (grouper -> grouperKeyword id { module1_n aggregate } .)
|
|
id reduce using rule 71 (grouper -> grouperKeyword id { module1_n aggregate } .)
|
|
string reduce using rule 71 (grouper -> grouperKeyword id { module1_n aggregate } .)
|
|
ungrouperKeyword reduce using rule 71 (grouper -> grouperKeyword id { module1_n aggregate } .)
|
|
grouperKeyword reduce using rule 71 (grouper -> grouperKeyword id { module1_n aggregate } .)
|
|
groupFilterKeyword reduce using rule 71 (grouper -> grouperKeyword id { module1_n aggregate } .)
|
|
mergerKeyword reduce using rule 71 (grouper -> grouperKeyword id { module1_n aggregate } .)
|
|
$end reduce using rule 71 (grouper -> grouperKeyword id { module1_n aggregate } .)
|
|
|
|
|
|
state 133
|
|
|
|
(45) prefix_rule -> bitANDKeyword ( args . )
|
|
|
|
) shift and go to state 156
|
|
|
|
|
|
state 134
|
|
|
|
(58) arg -> prefix_rule .
|
|
|
|
, reduce using rule 58 (arg -> prefix_rule .)
|
|
) reduce using rule 58 (arg -> prefix_rule .)
|
|
ORKeyword reduce using rule 58 (arg -> prefix_rule .)
|
|
NOTKeyword reduce using rule 58 (arg -> prefix_rule .)
|
|
id reduce using rule 58 (arg -> prefix_rule .)
|
|
bitANDKeyword reduce using rule 58 (arg -> prefix_rule .)
|
|
bitORKeyword reduce using rule 58 (arg -> prefix_rule .)
|
|
IPv4 reduce using rule 58 (arg -> prefix_rule .)
|
|
IPv6 reduce using rule 58 (arg -> prefix_rule .)
|
|
MAC reduce using rule 58 (arg -> prefix_rule .)
|
|
int reduce using rule 58 (arg -> prefix_rule .)
|
|
float reduce using rule 58 (arg -> prefix_rule .)
|
|
hex reduce using rule 58 (arg -> prefix_rule .)
|
|
string reduce using rule 58 (arg -> prefix_rule .)
|
|
} reduce using rule 58 (arg -> prefix_rule .)
|
|
|
|
|
|
state 135
|
|
|
|
(47) args -> arg . , args
|
|
(48) args -> arg .
|
|
|
|
, shift and go to state 157
|
|
) reduce using rule 48 (args -> arg .)
|
|
|
|
|
|
state 136
|
|
|
|
(50) arg -> id .
|
|
(44) prefix_rule -> id . ( args )
|
|
|
|
, reduce using rule 50 (arg -> id .)
|
|
) reduce using rule 50 (arg -> id .)
|
|
ORKeyword reduce using rule 50 (arg -> id .)
|
|
NOTKeyword reduce using rule 50 (arg -> id .)
|
|
id reduce using rule 50 (arg -> id .)
|
|
bitANDKeyword reduce using rule 50 (arg -> id .)
|
|
bitORKeyword reduce using rule 50 (arg -> id .)
|
|
IPv4 reduce using rule 50 (arg -> id .)
|
|
IPv6 reduce using rule 50 (arg -> id .)
|
|
MAC reduce using rule 50 (arg -> id .)
|
|
int reduce using rule 50 (arg -> id .)
|
|
float reduce using rule 50 (arg -> id .)
|
|
hex reduce using rule 50 (arg -> id .)
|
|
string reduce using rule 50 (arg -> id .)
|
|
} reduce using rule 50 (arg -> id .)
|
|
( shift and go to state 97
|
|
|
|
|
|
state 137
|
|
|
|
(34) infix_rule -> arg op arg .
|
|
|
|
ORKeyword reduce using rule 34 (infix_rule -> arg op arg .)
|
|
NOTKeyword reduce using rule 34 (infix_rule -> arg op arg .)
|
|
id reduce using rule 34 (infix_rule -> arg op arg .)
|
|
bitANDKeyword reduce using rule 34 (infix_rule -> arg op arg .)
|
|
bitORKeyword reduce using rule 34 (infix_rule -> arg op arg .)
|
|
IPv4 reduce using rule 34 (infix_rule -> arg op arg .)
|
|
IPv6 reduce using rule 34 (infix_rule -> arg op arg .)
|
|
MAC reduce using rule 34 (infix_rule -> arg op arg .)
|
|
int reduce using rule 34 (infix_rule -> arg op arg .)
|
|
float reduce using rule 34 (infix_rule -> arg op arg .)
|
|
hex reduce using rule 34 (infix_rule -> arg op arg .)
|
|
string reduce using rule 34 (infix_rule -> arg op arg .)
|
|
} reduce using rule 34 (infix_rule -> arg op arg .)
|
|
|
|
|
|
state 138
|
|
|
|
(44) prefix_rule -> id ( args . )
|
|
|
|
) shift and go to state 158
|
|
|
|
|
|
state 139
|
|
|
|
(46) prefix_rule -> bitORKeyword ( args . )
|
|
|
|
) shift and go to state 159
|
|
|
|
|
|
state 140
|
|
|
|
(25) not_id -> NOTKeyword id .
|
|
|
|
ORKeyword reduce using rule 25 (not_id -> NOTKeyword id .)
|
|
NOTKeyword reduce using rule 25 (not_id -> NOTKeyword id .)
|
|
id reduce using rule 25 (not_id -> NOTKeyword id .)
|
|
} reduce using rule 25 (not_id -> NOTKeyword id .)
|
|
|
|
|
|
state 141
|
|
|
|
(23) opt_or_id -> ORKeyword not_id . opt_or_id
|
|
(23) opt_or_id -> . ORKeyword not_id opt_or_id
|
|
(24) opt_or_id -> .
|
|
|
|
ORKeyword shift and go to state 106
|
|
NOTKeyword reduce using rule 24 (opt_or_id -> .)
|
|
id reduce using rule 24 (opt_or_id -> .)
|
|
} reduce using rule 24 (opt_or_id -> .)
|
|
|
|
opt_or_id shift and go to state 160
|
|
|
|
state 142
|
|
|
|
(28) opt_rule -> ORKeyword rule_or_not . opt_rule
|
|
(28) opt_rule -> . ORKeyword rule_or_not opt_rule
|
|
(29) opt_rule -> .
|
|
|
|
ORKeyword shift and go to state 109
|
|
NOTKeyword reduce using rule 29 (opt_rule -> .)
|
|
id reduce using rule 29 (opt_rule -> .)
|
|
bitANDKeyword reduce using rule 29 (opt_rule -> .)
|
|
bitORKeyword reduce using rule 29 (opt_rule -> .)
|
|
IPv4 reduce using rule 29 (opt_rule -> .)
|
|
IPv6 reduce using rule 29 (opt_rule -> .)
|
|
MAC reduce using rule 29 (opt_rule -> .)
|
|
int reduce using rule 29 (opt_rule -> .)
|
|
float reduce using rule 29 (opt_rule -> .)
|
|
hex reduce using rule 29 (opt_rule -> .)
|
|
string reduce using rule 29 (opt_rule -> .)
|
|
} reduce using rule 29 (opt_rule -> .)
|
|
|
|
opt_rule shift and go to state 161
|
|
|
|
state 143
|
|
|
|
(60) CIDR -> IPv4 / int .
|
|
|
|
EQ reduce using rule 60 (CIDR -> IPv4 / int .)
|
|
LT reduce using rule 60 (CIDR -> IPv4 / int .)
|
|
GT reduce using rule 60 (CIDR -> IPv4 / int .)
|
|
LTEQ reduce using rule 60 (CIDR -> IPv4 / int .)
|
|
GTEQ reduce using rule 60 (CIDR -> IPv4 / int .)
|
|
ML reduce using rule 60 (CIDR -> IPv4 / int .)
|
|
MG reduce using rule 60 (CIDR -> IPv4 / int .)
|
|
inKeyword reduce using rule 60 (CIDR -> IPv4 / int .)
|
|
notinKeyword reduce using rule 60 (CIDR -> IPv4 / int .)
|
|
, reduce using rule 60 (CIDR -> IPv4 / int .)
|
|
) reduce using rule 60 (CIDR -> IPv4 / int .)
|
|
NOTKeyword reduce using rule 60 (CIDR -> IPv4 / int .)
|
|
id reduce using rule 60 (CIDR -> IPv4 / int .)
|
|
IPv4 reduce using rule 60 (CIDR -> IPv4 / int .)
|
|
IPv6 reduce using rule 60 (CIDR -> IPv4 / int .)
|
|
MAC reduce using rule 60 (CIDR -> IPv4 / int .)
|
|
int reduce using rule 60 (CIDR -> IPv4 / int .)
|
|
float reduce using rule 60 (CIDR -> IPv4 / int .)
|
|
hex reduce using rule 60 (CIDR -> IPv4 / int .)
|
|
string reduce using rule 60 (CIDR -> IPv4 / int .)
|
|
} reduce using rule 60 (CIDR -> IPv4 / int .)
|
|
ORKeyword reduce using rule 60 (CIDR -> IPv4 / int .)
|
|
bitANDKeyword reduce using rule 60 (CIDR -> IPv4 / int .)
|
|
bitORKeyword reduce using rule 60 (CIDR -> IPv4 / int .)
|
|
|
|
|
|
state 144
|
|
|
|
(61) CIDR -> IPv6 / int .
|
|
|
|
EQ reduce using rule 61 (CIDR -> IPv6 / int .)
|
|
LT reduce using rule 61 (CIDR -> IPv6 / int .)
|
|
GT reduce using rule 61 (CIDR -> IPv6 / int .)
|
|
LTEQ reduce using rule 61 (CIDR -> IPv6 / int .)
|
|
GTEQ reduce using rule 61 (CIDR -> IPv6 / int .)
|
|
ML reduce using rule 61 (CIDR -> IPv6 / int .)
|
|
MG reduce using rule 61 (CIDR -> IPv6 / int .)
|
|
inKeyword reduce using rule 61 (CIDR -> IPv6 / int .)
|
|
notinKeyword reduce using rule 61 (CIDR -> IPv6 / int .)
|
|
, reduce using rule 61 (CIDR -> IPv6 / int .)
|
|
) reduce using rule 61 (CIDR -> IPv6 / int .)
|
|
NOTKeyword reduce using rule 61 (CIDR -> IPv6 / int .)
|
|
id reduce using rule 61 (CIDR -> IPv6 / int .)
|
|
IPv4 reduce using rule 61 (CIDR -> IPv6 / int .)
|
|
IPv6 reduce using rule 61 (CIDR -> IPv6 / int .)
|
|
MAC reduce using rule 61 (CIDR -> IPv6 / int .)
|
|
int reduce using rule 61 (CIDR -> IPv6 / int .)
|
|
float reduce using rule 61 (CIDR -> IPv6 / int .)
|
|
hex reduce using rule 61 (CIDR -> IPv6 / int .)
|
|
string reduce using rule 61 (CIDR -> IPv6 / int .)
|
|
} reduce using rule 61 (CIDR -> IPv6 / int .)
|
|
ORKeyword reduce using rule 61 (CIDR -> IPv6 / int .)
|
|
bitANDKeyword reduce using rule 61 (CIDR -> IPv6 / int .)
|
|
bitORKeyword reduce using rule 61 (CIDR -> IPv6 / int .)
|
|
|
|
|
|
state 145
|
|
|
|
(115) export -> exportKeyword id .
|
|
|
|
} reduce using rule 115 (export -> exportKeyword id .)
|
|
|
|
|
|
state 146
|
|
|
|
(108) merger -> mergerKeyword id { merger_module1_n export } .
|
|
|
|
splitterKeyword reduce using rule 108 (merger -> mergerKeyword id { merger_module1_n export } .)
|
|
filterKeyword reduce using rule 108 (merger -> mergerKeyword id { merger_module1_n export } .)
|
|
id reduce using rule 108 (merger -> mergerKeyword id { merger_module1_n export } .)
|
|
string reduce using rule 108 (merger -> mergerKeyword id { merger_module1_n export } .)
|
|
ungrouperKeyword reduce using rule 108 (merger -> mergerKeyword id { merger_module1_n export } .)
|
|
grouperKeyword reduce using rule 108 (merger -> mergerKeyword id { merger_module1_n export } .)
|
|
groupFilterKeyword reduce using rule 108 (merger -> mergerKeyword id { merger_module1_n export } .)
|
|
mergerKeyword reduce using rule 108 (merger -> mergerKeyword id { merger_module1_n export } .)
|
|
$end reduce using rule 108 (merger -> mergerKeyword id { merger_module1_n export } .)
|
|
|
|
|
|
state 147
|
|
|
|
(111) merger_module -> moduleKeyword id { . merger_branches merger_rule1_n }
|
|
(112) merger_branches -> . branchesKeyword branches1_n
|
|
|
|
branchesKeyword shift and go to state 163
|
|
|
|
merger_branches shift and go to state 162
|
|
|
|
state 148
|
|
|
|
(74) module -> moduleKeyword id { grouper_rule1_n . }
|
|
|
|
} shift and go to state 164
|
|
|
|
|
|
state 149
|
|
|
|
(75) grouper_rule1_n -> grouper_rule . grouper_rule1_n
|
|
(75) grouper_rule1_n -> . grouper_rule grouper_rule1_n
|
|
(76) grouper_rule1_n -> .
|
|
(77) grouper_rule -> . id grouper_op id
|
|
(78) grouper_rule -> . id grouper_op id deltaKeyword delta_arg
|
|
(79) grouper_rule -> . id grouper_op id rdeltaKeyword delta_arg
|
|
|
|
} reduce using rule 76 (grouper_rule1_n -> .)
|
|
id shift and go to state 150
|
|
|
|
grouper_rule1_n shift and go to state 165
|
|
grouper_rule shift and go to state 149
|
|
|
|
state 150
|
|
|
|
(77) grouper_rule -> id . grouper_op id
|
|
(78) grouper_rule -> id . grouper_op id deltaKeyword delta_arg
|
|
(79) grouper_rule -> id . grouper_op id rdeltaKeyword delta_arg
|
|
(80) grouper_op -> . EQ
|
|
(81) grouper_op -> . LT
|
|
(82) grouper_op -> . GT
|
|
(83) grouper_op -> . GTEQ
|
|
(84) grouper_op -> . LTEQ
|
|
|
|
EQ shift and go to state 171
|
|
LT shift and go to state 170
|
|
GT shift and go to state 166
|
|
GTEQ shift and go to state 167
|
|
LTEQ shift and go to state 169
|
|
|
|
grouper_op shift and go to state 168
|
|
|
|
state 151
|
|
|
|
(94) aggr -> aggr_op ( . id_or_qid ) asKeyword id
|
|
(98) id_or_qid -> . id
|
|
(99) id_or_qid -> . qid
|
|
(97) qid -> . id . id
|
|
|
|
id shift and go to state 123
|
|
|
|
qid shift and go to state 124
|
|
id_or_qid shift and go to state 172
|
|
|
|
state 152
|
|
|
|
(95) aggr -> id_or_qid asKeyword . id
|
|
|
|
id shift and go to state 173
|
|
|
|
|
|
state 153
|
|
|
|
(97) qid -> id . . id
|
|
|
|
id shift and go to state 174
|
|
|
|
|
|
state 154
|
|
|
|
(92) opt_aggr -> , . aggr opt_aggr
|
|
(94) aggr -> . aggr_op ( id_or_qid ) asKeyword id
|
|
(95) aggr -> . id_or_qid asKeyword id
|
|
(96) aggr -> . id_or_qid
|
|
(100) aggr_op -> . minKeyword
|
|
(101) aggr_op -> . maxKeyword
|
|
(102) aggr_op -> . sumKeyword
|
|
(103) aggr_op -> . avgKeyword
|
|
(104) aggr_op -> . unionKeyword
|
|
(105) aggr_op -> . countKeyword
|
|
(106) aggr_op -> . bitANDKeyword
|
|
(107) aggr_op -> . bitORKeyword
|
|
(98) id_or_qid -> . id
|
|
(99) id_or_qid -> . qid
|
|
(97) qid -> . id . id
|
|
|
|
minKeyword shift and go to state 121
|
|
maxKeyword shift and go to state 120
|
|
sumKeyword shift and go to state 125
|
|
avgKeyword shift and go to state 127
|
|
unionKeyword shift and go to state 126
|
|
countKeyword shift and go to state 130
|
|
bitANDKeyword shift and go to state 119
|
|
bitORKeyword shift and go to state 128
|
|
id shift and go to state 123
|
|
|
|
aggr_op shift and go to state 118
|
|
qid shift and go to state 124
|
|
id_or_qid shift and go to state 122
|
|
aggr shift and go to state 175
|
|
|
|
state 155
|
|
|
|
(91) aggr1_n -> aggr opt_aggr .
|
|
|
|
} reduce using rule 91 (aggr1_n -> aggr opt_aggr .)
|
|
|
|
|
|
state 156
|
|
|
|
(45) prefix_rule -> bitANDKeyword ( args ) .
|
|
|
|
ORKeyword reduce using rule 45 (prefix_rule -> bitANDKeyword ( args ) .)
|
|
NOTKeyword reduce using rule 45 (prefix_rule -> bitANDKeyword ( args ) .)
|
|
id reduce using rule 45 (prefix_rule -> bitANDKeyword ( args ) .)
|
|
bitANDKeyword reduce using rule 45 (prefix_rule -> bitANDKeyword ( args ) .)
|
|
bitORKeyword reduce using rule 45 (prefix_rule -> bitANDKeyword ( args ) .)
|
|
IPv4 reduce using rule 45 (prefix_rule -> bitANDKeyword ( args ) .)
|
|
IPv6 reduce using rule 45 (prefix_rule -> bitANDKeyword ( args ) .)
|
|
MAC reduce using rule 45 (prefix_rule -> bitANDKeyword ( args ) .)
|
|
int reduce using rule 45 (prefix_rule -> bitANDKeyword ( args ) .)
|
|
float reduce using rule 45 (prefix_rule -> bitANDKeyword ( args ) .)
|
|
hex reduce using rule 45 (prefix_rule -> bitANDKeyword ( args ) .)
|
|
string reduce using rule 45 (prefix_rule -> bitANDKeyword ( args ) .)
|
|
} reduce using rule 45 (prefix_rule -> bitANDKeyword ( args ) .)
|
|
EQ reduce using rule 45 (prefix_rule -> bitANDKeyword ( args ) .)
|
|
LT reduce using rule 45 (prefix_rule -> bitANDKeyword ( args ) .)
|
|
GT reduce using rule 45 (prefix_rule -> bitANDKeyword ( args ) .)
|
|
LTEQ reduce using rule 45 (prefix_rule -> bitANDKeyword ( args ) .)
|
|
GTEQ reduce using rule 45 (prefix_rule -> bitANDKeyword ( args ) .)
|
|
ML reduce using rule 45 (prefix_rule -> bitANDKeyword ( args ) .)
|
|
MG reduce using rule 45 (prefix_rule -> bitANDKeyword ( args ) .)
|
|
inKeyword reduce using rule 45 (prefix_rule -> bitANDKeyword ( args ) .)
|
|
notinKeyword reduce using rule 45 (prefix_rule -> bitANDKeyword ( args ) .)
|
|
, reduce using rule 45 (prefix_rule -> bitANDKeyword ( args ) .)
|
|
) reduce using rule 45 (prefix_rule -> bitANDKeyword ( args ) .)
|
|
|
|
|
|
state 157
|
|
|
|
(47) args -> arg , . args
|
|
(47) args -> . arg , args
|
|
(48) args -> . arg
|
|
(49) args -> .
|
|
(50) arg -> . id
|
|
(51) arg -> . IPv4
|
|
(52) arg -> . IPv6
|
|
(53) arg -> . CIDR
|
|
(54) arg -> . MAC
|
|
(55) arg -> . int
|
|
(56) arg -> . float
|
|
(57) arg -> . hex
|
|
(58) arg -> . prefix_rule
|
|
(59) arg -> . string
|
|
(60) CIDR -> . IPv4 / int
|
|
(61) CIDR -> . IPv6 / int
|
|
(44) prefix_rule -> . id ( args )
|
|
(45) prefix_rule -> . bitANDKeyword ( args )
|
|
(46) prefix_rule -> . bitORKeyword ( args )
|
|
|
|
) reduce using rule 49 (args -> .)
|
|
id shift and go to state 136
|
|
IPv4 shift and go to state 70
|
|
IPv6 shift and go to state 71
|
|
MAC shift and go to state 68
|
|
int shift and go to state 51
|
|
float shift and go to state 52
|
|
hex shift and go to state 60
|
|
string shift and go to state 62
|
|
bitANDKeyword shift and go to state 48
|
|
bitORKeyword shift and go to state 58
|
|
|
|
CIDR shift and go to state 65
|
|
args shift and go to state 176
|
|
prefix_rule shift and go to state 134
|
|
arg shift and go to state 135
|
|
|
|
state 158
|
|
|
|
(44) prefix_rule -> id ( args ) .
|
|
|
|
ORKeyword reduce using rule 44 (prefix_rule -> id ( args ) .)
|
|
NOTKeyword reduce using rule 44 (prefix_rule -> id ( args ) .)
|
|
id reduce using rule 44 (prefix_rule -> id ( args ) .)
|
|
bitANDKeyword reduce using rule 44 (prefix_rule -> id ( args ) .)
|
|
bitORKeyword reduce using rule 44 (prefix_rule -> id ( args ) .)
|
|
IPv4 reduce using rule 44 (prefix_rule -> id ( args ) .)
|
|
IPv6 reduce using rule 44 (prefix_rule -> id ( args ) .)
|
|
MAC reduce using rule 44 (prefix_rule -> id ( args ) .)
|
|
int reduce using rule 44 (prefix_rule -> id ( args ) .)
|
|
float reduce using rule 44 (prefix_rule -> id ( args ) .)
|
|
hex reduce using rule 44 (prefix_rule -> id ( args ) .)
|
|
string reduce using rule 44 (prefix_rule -> id ( args ) .)
|
|
} reduce using rule 44 (prefix_rule -> id ( args ) .)
|
|
EQ reduce using rule 44 (prefix_rule -> id ( args ) .)
|
|
LT reduce using rule 44 (prefix_rule -> id ( args ) .)
|
|
GT reduce using rule 44 (prefix_rule -> id ( args ) .)
|
|
LTEQ reduce using rule 44 (prefix_rule -> id ( args ) .)
|
|
GTEQ reduce using rule 44 (prefix_rule -> id ( args ) .)
|
|
ML reduce using rule 44 (prefix_rule -> id ( args ) .)
|
|
MG reduce using rule 44 (prefix_rule -> id ( args ) .)
|
|
inKeyword reduce using rule 44 (prefix_rule -> id ( args ) .)
|
|
notinKeyword reduce using rule 44 (prefix_rule -> id ( args ) .)
|
|
, reduce using rule 44 (prefix_rule -> id ( args ) .)
|
|
) reduce using rule 44 (prefix_rule -> id ( args ) .)
|
|
|
|
|
|
state 159
|
|
|
|
(46) prefix_rule -> bitORKeyword ( args ) .
|
|
|
|
ORKeyword reduce using rule 46 (prefix_rule -> bitORKeyword ( args ) .)
|
|
NOTKeyword reduce using rule 46 (prefix_rule -> bitORKeyword ( args ) .)
|
|
id reduce using rule 46 (prefix_rule -> bitORKeyword ( args ) .)
|
|
bitANDKeyword reduce using rule 46 (prefix_rule -> bitORKeyword ( args ) .)
|
|
bitORKeyword reduce using rule 46 (prefix_rule -> bitORKeyword ( args ) .)
|
|
IPv4 reduce using rule 46 (prefix_rule -> bitORKeyword ( args ) .)
|
|
IPv6 reduce using rule 46 (prefix_rule -> bitORKeyword ( args ) .)
|
|
MAC reduce using rule 46 (prefix_rule -> bitORKeyword ( args ) .)
|
|
int reduce using rule 46 (prefix_rule -> bitORKeyword ( args ) .)
|
|
float reduce using rule 46 (prefix_rule -> bitORKeyword ( args ) .)
|
|
hex reduce using rule 46 (prefix_rule -> bitORKeyword ( args ) .)
|
|
string reduce using rule 46 (prefix_rule -> bitORKeyword ( args ) .)
|
|
} reduce using rule 46 (prefix_rule -> bitORKeyword ( args ) .)
|
|
EQ reduce using rule 46 (prefix_rule -> bitORKeyword ( args ) .)
|
|
LT reduce using rule 46 (prefix_rule -> bitORKeyword ( args ) .)
|
|
GT reduce using rule 46 (prefix_rule -> bitORKeyword ( args ) .)
|
|
LTEQ reduce using rule 46 (prefix_rule -> bitORKeyword ( args ) .)
|
|
GTEQ reduce using rule 46 (prefix_rule -> bitORKeyword ( args ) .)
|
|
ML reduce using rule 46 (prefix_rule -> bitORKeyword ( args ) .)
|
|
MG reduce using rule 46 (prefix_rule -> bitORKeyword ( args ) .)
|
|
inKeyword reduce using rule 46 (prefix_rule -> bitORKeyword ( args ) .)
|
|
notinKeyword reduce using rule 46 (prefix_rule -> bitORKeyword ( args ) .)
|
|
, reduce using rule 46 (prefix_rule -> bitORKeyword ( args ) .)
|
|
) reduce using rule 46 (prefix_rule -> bitORKeyword ( args ) .)
|
|
|
|
|
|
state 160
|
|
|
|
(23) opt_or_id -> ORKeyword not_id opt_or_id .
|
|
|
|
NOTKeyword reduce using rule 23 (opt_or_id -> ORKeyword not_id opt_or_id .)
|
|
id reduce using rule 23 (opt_or_id -> ORKeyword not_id opt_or_id .)
|
|
} reduce using rule 23 (opt_or_id -> ORKeyword not_id opt_or_id .)
|
|
|
|
|
|
state 161
|
|
|
|
(28) opt_rule -> ORKeyword rule_or_not opt_rule .
|
|
|
|
NOTKeyword reduce using rule 28 (opt_rule -> ORKeyword rule_or_not opt_rule .)
|
|
id reduce using rule 28 (opt_rule -> ORKeyword rule_or_not opt_rule .)
|
|
bitANDKeyword reduce using rule 28 (opt_rule -> ORKeyword rule_or_not opt_rule .)
|
|
bitORKeyword reduce using rule 28 (opt_rule -> ORKeyword rule_or_not opt_rule .)
|
|
IPv4 reduce using rule 28 (opt_rule -> ORKeyword rule_or_not opt_rule .)
|
|
IPv6 reduce using rule 28 (opt_rule -> ORKeyword rule_or_not opt_rule .)
|
|
MAC reduce using rule 28 (opt_rule -> ORKeyword rule_or_not opt_rule .)
|
|
int reduce using rule 28 (opt_rule -> ORKeyword rule_or_not opt_rule .)
|
|
float reduce using rule 28 (opt_rule -> ORKeyword rule_or_not opt_rule .)
|
|
hex reduce using rule 28 (opt_rule -> ORKeyword rule_or_not opt_rule .)
|
|
string reduce using rule 28 (opt_rule -> ORKeyword rule_or_not opt_rule .)
|
|
} reduce using rule 28 (opt_rule -> ORKeyword rule_or_not opt_rule .)
|
|
|
|
|
|
state 162
|
|
|
|
(111) merger_module -> moduleKeyword id { merger_branches . merger_rule1_n }
|
|
(116) merger_rule1_n -> . merger_rule merger_rule1_n
|
|
(117) merger_rule1_n -> .
|
|
(118) merger_rule -> . merger_prefix_rule
|
|
(119) merger_rule -> . merger_infix_rule
|
|
(120) merger_rule -> . NOTKeyword merger_prefix_rule
|
|
(121) merger_rule -> . NOTKeyword merger_infix_rule
|
|
(137) merger_rule -> . allen_rule opt_or_allen_rule
|
|
(123) merger_prefix_rule -> . id ( qid_args )
|
|
(122) merger_infix_rule -> . qid_arg op qid_arg
|
|
(140) allen_rule -> . id allen_op id opt_allen_delta
|
|
(127) qid_arg -> . qid
|
|
(128) qid_arg -> . IPv4
|
|
(129) qid_arg -> . IPv6
|
|
(130) qid_arg -> . CIDR
|
|
(131) qid_arg -> . MAC
|
|
(132) qid_arg -> . int
|
|
(133) qid_arg -> . float
|
|
(134) qid_arg -> . hex
|
|
(135) qid_arg -> . merger_prefix_rule
|
|
(136) qid_arg -> . string
|
|
(97) qid -> . id . id
|
|
(60) CIDR -> . IPv4 / int
|
|
(61) CIDR -> . IPv6 / int
|
|
|
|
} reduce using rule 117 (merger_rule1_n -> .)
|
|
NOTKeyword shift and go to state 185
|
|
id shift and go to state 183
|
|
IPv4 shift and go to state 192
|
|
IPv6 shift and go to state 193
|
|
MAC shift and go to state 191
|
|
int shift and go to state 177
|
|
float shift and go to state 179
|
|
hex shift and go to state 186
|
|
string shift and go to state 188
|
|
|
|
merger_rule shift and go to state 184
|
|
merger_prefix_rule shift and go to state 178
|
|
merger_rule1_n shift and go to state 180
|
|
qid shift and go to state 187
|
|
allen_rule shift and go to state 189
|
|
CIDR shift and go to state 190
|
|
merger_infix_rule shift and go to state 181
|
|
qid_arg shift and go to state 182
|
|
|
|
state 163
|
|
|
|
(112) merger_branches -> branchesKeyword . branches1_n
|
|
(113) branches1_n -> . id , branches1_n
|
|
(114) branches1_n -> . id
|
|
|
|
id shift and go to state 195
|
|
|
|
branches1_n shift and go to state 194
|
|
|
|
state 164
|
|
|
|
(74) module -> moduleKeyword id { grouper_rule1_n } .
|
|
|
|
moduleKeyword reduce using rule 74 (module -> moduleKeyword id { grouper_rule1_n } .)
|
|
aggregateKeyword reduce using rule 74 (module -> moduleKeyword id { grouper_rule1_n } .)
|
|
|
|
|
|
state 165
|
|
|
|
(75) grouper_rule1_n -> grouper_rule grouper_rule1_n .
|
|
|
|
} reduce using rule 75 (grouper_rule1_n -> grouper_rule grouper_rule1_n .)
|
|
|
|
|
|
state 166
|
|
|
|
(82) grouper_op -> GT .
|
|
|
|
id reduce using rule 82 (grouper_op -> GT .)
|
|
|
|
|
|
state 167
|
|
|
|
(83) grouper_op -> GTEQ .
|
|
|
|
id reduce using rule 83 (grouper_op -> GTEQ .)
|
|
|
|
|
|
state 168
|
|
|
|
(77) grouper_rule -> id grouper_op . id
|
|
(78) grouper_rule -> id grouper_op . id deltaKeyword delta_arg
|
|
(79) grouper_rule -> id grouper_op . id rdeltaKeyword delta_arg
|
|
|
|
id shift and go to state 196
|
|
|
|
|
|
state 169
|
|
|
|
(84) grouper_op -> LTEQ .
|
|
|
|
id reduce using rule 84 (grouper_op -> LTEQ .)
|
|
|
|
|
|
state 170
|
|
|
|
(81) grouper_op -> LT .
|
|
|
|
id reduce using rule 81 (grouper_op -> LT .)
|
|
|
|
|
|
state 171
|
|
|
|
(80) grouper_op -> EQ .
|
|
|
|
id reduce using rule 80 (grouper_op -> EQ .)
|
|
|
|
|
|
state 172
|
|
|
|
(94) aggr -> aggr_op ( id_or_qid . ) asKeyword id
|
|
|
|
) shift and go to state 197
|
|
|
|
|
|
state 173
|
|
|
|
(95) aggr -> id_or_qid asKeyword id .
|
|
|
|
, reduce using rule 95 (aggr -> id_or_qid asKeyword id .)
|
|
} reduce using rule 95 (aggr -> id_or_qid asKeyword id .)
|
|
|
|
|
|
state 174
|
|
|
|
(97) qid -> id . id .
|
|
|
|
EQ reduce using rule 97 (qid -> id . id .)
|
|
LT reduce using rule 97 (qid -> id . id .)
|
|
GT reduce using rule 97 (qid -> id . id .)
|
|
LTEQ reduce using rule 97 (qid -> id . id .)
|
|
GTEQ reduce using rule 97 (qid -> id . id .)
|
|
ML reduce using rule 97 (qid -> id . id .)
|
|
MG reduce using rule 97 (qid -> id . id .)
|
|
inKeyword reduce using rule 97 (qid -> id . id .)
|
|
notinKeyword reduce using rule 97 (qid -> id . id .)
|
|
, reduce using rule 97 (qid -> id . id .)
|
|
) reduce using rule 97 (qid -> id . id .)
|
|
asKeyword reduce using rule 97 (qid -> id . id .)
|
|
} reduce using rule 97 (qid -> id . id .)
|
|
NOTKeyword reduce using rule 97 (qid -> id . id .)
|
|
id reduce using rule 97 (qid -> id . id .)
|
|
IPv4 reduce using rule 97 (qid -> id . id .)
|
|
IPv6 reduce using rule 97 (qid -> id . id .)
|
|
MAC reduce using rule 97 (qid -> id . id .)
|
|
int reduce using rule 97 (qid -> id . id .)
|
|
float reduce using rule 97 (qid -> id . id .)
|
|
hex reduce using rule 97 (qid -> id . id .)
|
|
string reduce using rule 97 (qid -> id . id .)
|
|
|
|
|
|
state 175
|
|
|
|
(92) opt_aggr -> , aggr . opt_aggr
|
|
(92) opt_aggr -> . , aggr opt_aggr
|
|
(93) opt_aggr -> .
|
|
|
|
, shift and go to state 154
|
|
} reduce using rule 93 (opt_aggr -> .)
|
|
|
|
opt_aggr shift and go to state 198
|
|
|
|
state 176
|
|
|
|
(47) args -> arg , args .
|
|
|
|
) reduce using rule 47 (args -> arg , args .)
|
|
|
|
|
|
state 177
|
|
|
|
(132) qid_arg -> int .
|
|
|
|
EQ reduce using rule 132 (qid_arg -> int .)
|
|
LT reduce using rule 132 (qid_arg -> int .)
|
|
GT reduce using rule 132 (qid_arg -> int .)
|
|
LTEQ reduce using rule 132 (qid_arg -> int .)
|
|
GTEQ reduce using rule 132 (qid_arg -> int .)
|
|
ML reduce using rule 132 (qid_arg -> int .)
|
|
MG reduce using rule 132 (qid_arg -> int .)
|
|
inKeyword reduce using rule 132 (qid_arg -> int .)
|
|
notinKeyword reduce using rule 132 (qid_arg -> int .)
|
|
, reduce using rule 132 (qid_arg -> int .)
|
|
) reduce using rule 132 (qid_arg -> int .)
|
|
NOTKeyword reduce using rule 132 (qid_arg -> int .)
|
|
id reduce using rule 132 (qid_arg -> int .)
|
|
IPv4 reduce using rule 132 (qid_arg -> int .)
|
|
IPv6 reduce using rule 132 (qid_arg -> int .)
|
|
MAC reduce using rule 132 (qid_arg -> int .)
|
|
int reduce using rule 132 (qid_arg -> int .)
|
|
float reduce using rule 132 (qid_arg -> int .)
|
|
hex reduce using rule 132 (qid_arg -> int .)
|
|
string reduce using rule 132 (qid_arg -> int .)
|
|
} reduce using rule 132 (qid_arg -> int .)
|
|
|
|
|
|
state 178
|
|
|
|
(118) merger_rule -> merger_prefix_rule .
|
|
(135) qid_arg -> merger_prefix_rule .
|
|
|
|
NOTKeyword reduce using rule 118 (merger_rule -> merger_prefix_rule .)
|
|
id reduce using rule 118 (merger_rule -> merger_prefix_rule .)
|
|
IPv4 reduce using rule 118 (merger_rule -> merger_prefix_rule .)
|
|
IPv6 reduce using rule 118 (merger_rule -> merger_prefix_rule .)
|
|
MAC reduce using rule 118 (merger_rule -> merger_prefix_rule .)
|
|
int reduce using rule 118 (merger_rule -> merger_prefix_rule .)
|
|
float reduce using rule 118 (merger_rule -> merger_prefix_rule .)
|
|
hex reduce using rule 118 (merger_rule -> merger_prefix_rule .)
|
|
string reduce using rule 118 (merger_rule -> merger_prefix_rule .)
|
|
} reduce using rule 118 (merger_rule -> merger_prefix_rule .)
|
|
EQ reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
LT reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
GT reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
LTEQ reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
GTEQ reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
ML reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
MG reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
inKeyword reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
notinKeyword reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
|
|
|
|
state 179
|
|
|
|
(133) qid_arg -> float .
|
|
|
|
EQ reduce using rule 133 (qid_arg -> float .)
|
|
LT reduce using rule 133 (qid_arg -> float .)
|
|
GT reduce using rule 133 (qid_arg -> float .)
|
|
LTEQ reduce using rule 133 (qid_arg -> float .)
|
|
GTEQ reduce using rule 133 (qid_arg -> float .)
|
|
ML reduce using rule 133 (qid_arg -> float .)
|
|
MG reduce using rule 133 (qid_arg -> float .)
|
|
inKeyword reduce using rule 133 (qid_arg -> float .)
|
|
notinKeyword reduce using rule 133 (qid_arg -> float .)
|
|
, reduce using rule 133 (qid_arg -> float .)
|
|
) reduce using rule 133 (qid_arg -> float .)
|
|
NOTKeyword reduce using rule 133 (qid_arg -> float .)
|
|
id reduce using rule 133 (qid_arg -> float .)
|
|
IPv4 reduce using rule 133 (qid_arg -> float .)
|
|
IPv6 reduce using rule 133 (qid_arg -> float .)
|
|
MAC reduce using rule 133 (qid_arg -> float .)
|
|
int reduce using rule 133 (qid_arg -> float .)
|
|
float reduce using rule 133 (qid_arg -> float .)
|
|
hex reduce using rule 133 (qid_arg -> float .)
|
|
string reduce using rule 133 (qid_arg -> float .)
|
|
} reduce using rule 133 (qid_arg -> float .)
|
|
|
|
|
|
state 180
|
|
|
|
(111) merger_module -> moduleKeyword id { merger_branches merger_rule1_n . }
|
|
|
|
} shift and go to state 199
|
|
|
|
|
|
state 181
|
|
|
|
(119) merger_rule -> merger_infix_rule .
|
|
|
|
NOTKeyword reduce using rule 119 (merger_rule -> merger_infix_rule .)
|
|
id reduce using rule 119 (merger_rule -> merger_infix_rule .)
|
|
IPv4 reduce using rule 119 (merger_rule -> merger_infix_rule .)
|
|
IPv6 reduce using rule 119 (merger_rule -> merger_infix_rule .)
|
|
MAC reduce using rule 119 (merger_rule -> merger_infix_rule .)
|
|
int reduce using rule 119 (merger_rule -> merger_infix_rule .)
|
|
float reduce using rule 119 (merger_rule -> merger_infix_rule .)
|
|
hex reduce using rule 119 (merger_rule -> merger_infix_rule .)
|
|
string reduce using rule 119 (merger_rule -> merger_infix_rule .)
|
|
} reduce using rule 119 (merger_rule -> merger_infix_rule .)
|
|
|
|
|
|
state 182
|
|
|
|
(122) merger_infix_rule -> qid_arg . op qid_arg
|
|
(35) op -> . EQ
|
|
(36) op -> . LT
|
|
(37) op -> . GT
|
|
(38) op -> . LTEQ
|
|
(39) op -> . GTEQ
|
|
(40) op -> . ML
|
|
(41) op -> . MG
|
|
(42) op -> . inKeyword
|
|
(43) op -> . notinKeyword
|
|
|
|
EQ shift and go to state 95
|
|
LT shift and go to state 93
|
|
GT shift and go to state 88
|
|
LTEQ shift and go to state 91
|
|
GTEQ shift and go to state 89
|
|
ML shift and go to state 90
|
|
MG shift and go to state 87
|
|
inKeyword shift and go to state 92
|
|
notinKeyword shift and go to state 94
|
|
|
|
op shift and go to state 200
|
|
|
|
state 183
|
|
|
|
(123) merger_prefix_rule -> id . ( qid_args )
|
|
(140) allen_rule -> id . allen_op id opt_allen_delta
|
|
(97) qid -> id . . id
|
|
(143) allen_op -> . LT
|
|
(144) allen_op -> . GT
|
|
(145) allen_op -> . EQ
|
|
(146) allen_op -> . mKeyword
|
|
(147) allen_op -> . miKeyword
|
|
(148) allen_op -> . oKeyword
|
|
(149) allen_op -> . oiKeyword
|
|
(150) allen_op -> . sKeyword
|
|
(151) allen_op -> . siKeyword
|
|
(152) allen_op -> . dKeyword
|
|
(153) allen_op -> . diKeyword
|
|
(154) allen_op -> . fKeyword
|
|
(155) allen_op -> . fiKeyword
|
|
(156) allen_op -> . eqKeyword
|
|
|
|
( shift and go to state 204
|
|
. shift and go to state 153
|
|
LT shift and go to state 206
|
|
GT shift and go to state 203
|
|
EQ shift and go to state 215
|
|
mKeyword shift and go to state 212
|
|
miKeyword shift and go to state 209
|
|
oKeyword shift and go to state 205
|
|
oiKeyword shift and go to state 210
|
|
sKeyword shift and go to state 207
|
|
siKeyword shift and go to state 213
|
|
dKeyword shift and go to state 211
|
|
diKeyword shift and go to state 216
|
|
fKeyword shift and go to state 214
|
|
fiKeyword shift and go to state 201
|
|
eqKeyword shift and go to state 202
|
|
|
|
allen_op shift and go to state 208
|
|
|
|
state 184
|
|
|
|
(116) merger_rule1_n -> merger_rule . merger_rule1_n
|
|
(116) merger_rule1_n -> . merger_rule merger_rule1_n
|
|
(117) merger_rule1_n -> .
|
|
(118) merger_rule -> . merger_prefix_rule
|
|
(119) merger_rule -> . merger_infix_rule
|
|
(120) merger_rule -> . NOTKeyword merger_prefix_rule
|
|
(121) merger_rule -> . NOTKeyword merger_infix_rule
|
|
(137) merger_rule -> . allen_rule opt_or_allen_rule
|
|
(123) merger_prefix_rule -> . id ( qid_args )
|
|
(122) merger_infix_rule -> . qid_arg op qid_arg
|
|
(140) allen_rule -> . id allen_op id opt_allen_delta
|
|
(127) qid_arg -> . qid
|
|
(128) qid_arg -> . IPv4
|
|
(129) qid_arg -> . IPv6
|
|
(130) qid_arg -> . CIDR
|
|
(131) qid_arg -> . MAC
|
|
(132) qid_arg -> . int
|
|
(133) qid_arg -> . float
|
|
(134) qid_arg -> . hex
|
|
(135) qid_arg -> . merger_prefix_rule
|
|
(136) qid_arg -> . string
|
|
(97) qid -> . id . id
|
|
(60) CIDR -> . IPv4 / int
|
|
(61) CIDR -> . IPv6 / int
|
|
|
|
} reduce using rule 117 (merger_rule1_n -> .)
|
|
NOTKeyword shift and go to state 185
|
|
id shift and go to state 183
|
|
IPv4 shift and go to state 192
|
|
IPv6 shift and go to state 193
|
|
MAC shift and go to state 191
|
|
int shift and go to state 177
|
|
float shift and go to state 179
|
|
hex shift and go to state 186
|
|
string shift and go to state 188
|
|
|
|
merger_rule shift and go to state 184
|
|
merger_prefix_rule shift and go to state 178
|
|
merger_rule1_n shift and go to state 217
|
|
qid shift and go to state 187
|
|
allen_rule shift and go to state 189
|
|
CIDR shift and go to state 190
|
|
merger_infix_rule shift and go to state 181
|
|
qid_arg shift and go to state 182
|
|
|
|
state 185
|
|
|
|
(120) merger_rule -> NOTKeyword . merger_prefix_rule
|
|
(121) merger_rule -> NOTKeyword . merger_infix_rule
|
|
(123) merger_prefix_rule -> . id ( qid_args )
|
|
(122) merger_infix_rule -> . qid_arg op qid_arg
|
|
(127) qid_arg -> . qid
|
|
(128) qid_arg -> . IPv4
|
|
(129) qid_arg -> . IPv6
|
|
(130) qid_arg -> . CIDR
|
|
(131) qid_arg -> . MAC
|
|
(132) qid_arg -> . int
|
|
(133) qid_arg -> . float
|
|
(134) qid_arg -> . hex
|
|
(135) qid_arg -> . merger_prefix_rule
|
|
(136) qid_arg -> . string
|
|
(97) qid -> . id . id
|
|
(60) CIDR -> . IPv4 / int
|
|
(61) CIDR -> . IPv6 / int
|
|
|
|
id shift and go to state 220
|
|
IPv4 shift and go to state 192
|
|
IPv6 shift and go to state 193
|
|
MAC shift and go to state 191
|
|
int shift and go to state 177
|
|
float shift and go to state 179
|
|
hex shift and go to state 186
|
|
string shift and go to state 188
|
|
|
|
qid shift and go to state 187
|
|
merger_prefix_rule shift and go to state 218
|
|
CIDR shift and go to state 190
|
|
merger_infix_rule shift and go to state 219
|
|
qid_arg shift and go to state 182
|
|
|
|
state 186
|
|
|
|
(134) qid_arg -> hex .
|
|
|
|
EQ reduce using rule 134 (qid_arg -> hex .)
|
|
LT reduce using rule 134 (qid_arg -> hex .)
|
|
GT reduce using rule 134 (qid_arg -> hex .)
|
|
LTEQ reduce using rule 134 (qid_arg -> hex .)
|
|
GTEQ reduce using rule 134 (qid_arg -> hex .)
|
|
ML reduce using rule 134 (qid_arg -> hex .)
|
|
MG reduce using rule 134 (qid_arg -> hex .)
|
|
inKeyword reduce using rule 134 (qid_arg -> hex .)
|
|
notinKeyword reduce using rule 134 (qid_arg -> hex .)
|
|
, reduce using rule 134 (qid_arg -> hex .)
|
|
) reduce using rule 134 (qid_arg -> hex .)
|
|
NOTKeyword reduce using rule 134 (qid_arg -> hex .)
|
|
id reduce using rule 134 (qid_arg -> hex .)
|
|
IPv4 reduce using rule 134 (qid_arg -> hex .)
|
|
IPv6 reduce using rule 134 (qid_arg -> hex .)
|
|
MAC reduce using rule 134 (qid_arg -> hex .)
|
|
int reduce using rule 134 (qid_arg -> hex .)
|
|
float reduce using rule 134 (qid_arg -> hex .)
|
|
hex reduce using rule 134 (qid_arg -> hex .)
|
|
string reduce using rule 134 (qid_arg -> hex .)
|
|
} reduce using rule 134 (qid_arg -> hex .)
|
|
|
|
|
|
state 187
|
|
|
|
(127) qid_arg -> qid .
|
|
|
|
EQ reduce using rule 127 (qid_arg -> qid .)
|
|
LT reduce using rule 127 (qid_arg -> qid .)
|
|
GT reduce using rule 127 (qid_arg -> qid .)
|
|
LTEQ reduce using rule 127 (qid_arg -> qid .)
|
|
GTEQ reduce using rule 127 (qid_arg -> qid .)
|
|
ML reduce using rule 127 (qid_arg -> qid .)
|
|
MG reduce using rule 127 (qid_arg -> qid .)
|
|
inKeyword reduce using rule 127 (qid_arg -> qid .)
|
|
notinKeyword reduce using rule 127 (qid_arg -> qid .)
|
|
, reduce using rule 127 (qid_arg -> qid .)
|
|
) reduce using rule 127 (qid_arg -> qid .)
|
|
NOTKeyword reduce using rule 127 (qid_arg -> qid .)
|
|
id reduce using rule 127 (qid_arg -> qid .)
|
|
IPv4 reduce using rule 127 (qid_arg -> qid .)
|
|
IPv6 reduce using rule 127 (qid_arg -> qid .)
|
|
MAC reduce using rule 127 (qid_arg -> qid .)
|
|
int reduce using rule 127 (qid_arg -> qid .)
|
|
float reduce using rule 127 (qid_arg -> qid .)
|
|
hex reduce using rule 127 (qid_arg -> qid .)
|
|
string reduce using rule 127 (qid_arg -> qid .)
|
|
} reduce using rule 127 (qid_arg -> qid .)
|
|
|
|
|
|
state 188
|
|
|
|
(136) qid_arg -> string .
|
|
|
|
EQ reduce using rule 136 (qid_arg -> string .)
|
|
LT reduce using rule 136 (qid_arg -> string .)
|
|
GT reduce using rule 136 (qid_arg -> string .)
|
|
LTEQ reduce using rule 136 (qid_arg -> string .)
|
|
GTEQ reduce using rule 136 (qid_arg -> string .)
|
|
ML reduce using rule 136 (qid_arg -> string .)
|
|
MG reduce using rule 136 (qid_arg -> string .)
|
|
inKeyword reduce using rule 136 (qid_arg -> string .)
|
|
notinKeyword reduce using rule 136 (qid_arg -> string .)
|
|
, reduce using rule 136 (qid_arg -> string .)
|
|
) reduce using rule 136 (qid_arg -> string .)
|
|
NOTKeyword reduce using rule 136 (qid_arg -> string .)
|
|
id reduce using rule 136 (qid_arg -> string .)
|
|
IPv4 reduce using rule 136 (qid_arg -> string .)
|
|
IPv6 reduce using rule 136 (qid_arg -> string .)
|
|
MAC reduce using rule 136 (qid_arg -> string .)
|
|
int reduce using rule 136 (qid_arg -> string .)
|
|
float reduce using rule 136 (qid_arg -> string .)
|
|
hex reduce using rule 136 (qid_arg -> string .)
|
|
string reduce using rule 136 (qid_arg -> string .)
|
|
} reduce using rule 136 (qid_arg -> string .)
|
|
|
|
|
|
state 189
|
|
|
|
(137) merger_rule -> allen_rule . opt_or_allen_rule
|
|
(138) opt_or_allen_rule -> . ORKeyword allen_rule opt_or_allen_rule
|
|
(139) opt_or_allen_rule -> .
|
|
|
|
ORKeyword shift and go to state 222
|
|
NOTKeyword reduce using rule 139 (opt_or_allen_rule -> .)
|
|
id reduce using rule 139 (opt_or_allen_rule -> .)
|
|
IPv4 reduce using rule 139 (opt_or_allen_rule -> .)
|
|
IPv6 reduce using rule 139 (opt_or_allen_rule -> .)
|
|
MAC reduce using rule 139 (opt_or_allen_rule -> .)
|
|
int reduce using rule 139 (opt_or_allen_rule -> .)
|
|
float reduce using rule 139 (opt_or_allen_rule -> .)
|
|
hex reduce using rule 139 (opt_or_allen_rule -> .)
|
|
string reduce using rule 139 (opt_or_allen_rule -> .)
|
|
} reduce using rule 139 (opt_or_allen_rule -> .)
|
|
|
|
opt_or_allen_rule shift and go to state 221
|
|
|
|
state 190
|
|
|
|
(130) qid_arg -> CIDR .
|
|
|
|
EQ reduce using rule 130 (qid_arg -> CIDR .)
|
|
LT reduce using rule 130 (qid_arg -> CIDR .)
|
|
GT reduce using rule 130 (qid_arg -> CIDR .)
|
|
LTEQ reduce using rule 130 (qid_arg -> CIDR .)
|
|
GTEQ reduce using rule 130 (qid_arg -> CIDR .)
|
|
ML reduce using rule 130 (qid_arg -> CIDR .)
|
|
MG reduce using rule 130 (qid_arg -> CIDR .)
|
|
inKeyword reduce using rule 130 (qid_arg -> CIDR .)
|
|
notinKeyword reduce using rule 130 (qid_arg -> CIDR .)
|
|
, reduce using rule 130 (qid_arg -> CIDR .)
|
|
) reduce using rule 130 (qid_arg -> CIDR .)
|
|
NOTKeyword reduce using rule 130 (qid_arg -> CIDR .)
|
|
id reduce using rule 130 (qid_arg -> CIDR .)
|
|
IPv4 reduce using rule 130 (qid_arg -> CIDR .)
|
|
IPv6 reduce using rule 130 (qid_arg -> CIDR .)
|
|
MAC reduce using rule 130 (qid_arg -> CIDR .)
|
|
int reduce using rule 130 (qid_arg -> CIDR .)
|
|
float reduce using rule 130 (qid_arg -> CIDR .)
|
|
hex reduce using rule 130 (qid_arg -> CIDR .)
|
|
string reduce using rule 130 (qid_arg -> CIDR .)
|
|
} reduce using rule 130 (qid_arg -> CIDR .)
|
|
|
|
|
|
state 191
|
|
|
|
(131) qid_arg -> MAC .
|
|
|
|
EQ reduce using rule 131 (qid_arg -> MAC .)
|
|
LT reduce using rule 131 (qid_arg -> MAC .)
|
|
GT reduce using rule 131 (qid_arg -> MAC .)
|
|
LTEQ reduce using rule 131 (qid_arg -> MAC .)
|
|
GTEQ reduce using rule 131 (qid_arg -> MAC .)
|
|
ML reduce using rule 131 (qid_arg -> MAC .)
|
|
MG reduce using rule 131 (qid_arg -> MAC .)
|
|
inKeyword reduce using rule 131 (qid_arg -> MAC .)
|
|
notinKeyword reduce using rule 131 (qid_arg -> MAC .)
|
|
, reduce using rule 131 (qid_arg -> MAC .)
|
|
) reduce using rule 131 (qid_arg -> MAC .)
|
|
NOTKeyword reduce using rule 131 (qid_arg -> MAC .)
|
|
id reduce using rule 131 (qid_arg -> MAC .)
|
|
IPv4 reduce using rule 131 (qid_arg -> MAC .)
|
|
IPv6 reduce using rule 131 (qid_arg -> MAC .)
|
|
MAC reduce using rule 131 (qid_arg -> MAC .)
|
|
int reduce using rule 131 (qid_arg -> MAC .)
|
|
float reduce using rule 131 (qid_arg -> MAC .)
|
|
hex reduce using rule 131 (qid_arg -> MAC .)
|
|
string reduce using rule 131 (qid_arg -> MAC .)
|
|
} reduce using rule 131 (qid_arg -> MAC .)
|
|
|
|
|
|
state 192
|
|
|
|
(128) qid_arg -> IPv4 .
|
|
(60) CIDR -> IPv4 . / int
|
|
|
|
EQ reduce using rule 128 (qid_arg -> IPv4 .)
|
|
LT reduce using rule 128 (qid_arg -> IPv4 .)
|
|
GT reduce using rule 128 (qid_arg -> IPv4 .)
|
|
LTEQ reduce using rule 128 (qid_arg -> IPv4 .)
|
|
GTEQ reduce using rule 128 (qid_arg -> IPv4 .)
|
|
ML reduce using rule 128 (qid_arg -> IPv4 .)
|
|
MG reduce using rule 128 (qid_arg -> IPv4 .)
|
|
inKeyword reduce using rule 128 (qid_arg -> IPv4 .)
|
|
notinKeyword reduce using rule 128 (qid_arg -> IPv4 .)
|
|
, reduce using rule 128 (qid_arg -> IPv4 .)
|
|
) reduce using rule 128 (qid_arg -> IPv4 .)
|
|
NOTKeyword reduce using rule 128 (qid_arg -> IPv4 .)
|
|
id reduce using rule 128 (qid_arg -> IPv4 .)
|
|
IPv4 reduce using rule 128 (qid_arg -> IPv4 .)
|
|
IPv6 reduce using rule 128 (qid_arg -> IPv4 .)
|
|
MAC reduce using rule 128 (qid_arg -> IPv4 .)
|
|
int reduce using rule 128 (qid_arg -> IPv4 .)
|
|
float reduce using rule 128 (qid_arg -> IPv4 .)
|
|
hex reduce using rule 128 (qid_arg -> IPv4 .)
|
|
string reduce using rule 128 (qid_arg -> IPv4 .)
|
|
} reduce using rule 128 (qid_arg -> IPv4 .)
|
|
/ shift and go to state 110
|
|
|
|
|
|
state 193
|
|
|
|
(129) qid_arg -> IPv6 .
|
|
(61) CIDR -> IPv6 . / int
|
|
|
|
EQ reduce using rule 129 (qid_arg -> IPv6 .)
|
|
LT reduce using rule 129 (qid_arg -> IPv6 .)
|
|
GT reduce using rule 129 (qid_arg -> IPv6 .)
|
|
LTEQ reduce using rule 129 (qid_arg -> IPv6 .)
|
|
GTEQ reduce using rule 129 (qid_arg -> IPv6 .)
|
|
ML reduce using rule 129 (qid_arg -> IPv6 .)
|
|
MG reduce using rule 129 (qid_arg -> IPv6 .)
|
|
inKeyword reduce using rule 129 (qid_arg -> IPv6 .)
|
|
notinKeyword reduce using rule 129 (qid_arg -> IPv6 .)
|
|
, reduce using rule 129 (qid_arg -> IPv6 .)
|
|
) reduce using rule 129 (qid_arg -> IPv6 .)
|
|
NOTKeyword reduce using rule 129 (qid_arg -> IPv6 .)
|
|
id reduce using rule 129 (qid_arg -> IPv6 .)
|
|
IPv4 reduce using rule 129 (qid_arg -> IPv6 .)
|
|
IPv6 reduce using rule 129 (qid_arg -> IPv6 .)
|
|
MAC reduce using rule 129 (qid_arg -> IPv6 .)
|
|
int reduce using rule 129 (qid_arg -> IPv6 .)
|
|
float reduce using rule 129 (qid_arg -> IPv6 .)
|
|
hex reduce using rule 129 (qid_arg -> IPv6 .)
|
|
string reduce using rule 129 (qid_arg -> IPv6 .)
|
|
} reduce using rule 129 (qid_arg -> IPv6 .)
|
|
/ shift and go to state 111
|
|
|
|
|
|
state 194
|
|
|
|
(112) merger_branches -> branchesKeyword branches1_n .
|
|
|
|
NOTKeyword reduce using rule 112 (merger_branches -> branchesKeyword branches1_n .)
|
|
id reduce using rule 112 (merger_branches -> branchesKeyword branches1_n .)
|
|
IPv4 reduce using rule 112 (merger_branches -> branchesKeyword branches1_n .)
|
|
IPv6 reduce using rule 112 (merger_branches -> branchesKeyword branches1_n .)
|
|
MAC reduce using rule 112 (merger_branches -> branchesKeyword branches1_n .)
|
|
int reduce using rule 112 (merger_branches -> branchesKeyword branches1_n .)
|
|
float reduce using rule 112 (merger_branches -> branchesKeyword branches1_n .)
|
|
hex reduce using rule 112 (merger_branches -> branchesKeyword branches1_n .)
|
|
string reduce using rule 112 (merger_branches -> branchesKeyword branches1_n .)
|
|
} reduce using rule 112 (merger_branches -> branchesKeyword branches1_n .)
|
|
|
|
|
|
state 195
|
|
|
|
(113) branches1_n -> id . , branches1_n
|
|
(114) branches1_n -> id .
|
|
|
|
, shift and go to state 223
|
|
NOTKeyword reduce using rule 114 (branches1_n -> id .)
|
|
id reduce using rule 114 (branches1_n -> id .)
|
|
IPv4 reduce using rule 114 (branches1_n -> id .)
|
|
IPv6 reduce using rule 114 (branches1_n -> id .)
|
|
MAC reduce using rule 114 (branches1_n -> id .)
|
|
int reduce using rule 114 (branches1_n -> id .)
|
|
float reduce using rule 114 (branches1_n -> id .)
|
|
hex reduce using rule 114 (branches1_n -> id .)
|
|
string reduce using rule 114 (branches1_n -> id .)
|
|
} reduce using rule 114 (branches1_n -> id .)
|
|
|
|
|
|
state 196
|
|
|
|
(77) grouper_rule -> id grouper_op id .
|
|
(78) grouper_rule -> id grouper_op id . deltaKeyword delta_arg
|
|
(79) grouper_rule -> id grouper_op id . rdeltaKeyword delta_arg
|
|
|
|
id reduce using rule 77 (grouper_rule -> id grouper_op id .)
|
|
} reduce using rule 77 (grouper_rule -> id grouper_op id .)
|
|
deltaKeyword shift and go to state 225
|
|
rdeltaKeyword shift and go to state 224
|
|
|
|
|
|
state 197
|
|
|
|
(94) aggr -> aggr_op ( id_or_qid ) . asKeyword id
|
|
|
|
asKeyword shift and go to state 226
|
|
|
|
|
|
state 198
|
|
|
|
(92) opt_aggr -> , aggr opt_aggr .
|
|
|
|
} reduce using rule 92 (opt_aggr -> , aggr opt_aggr .)
|
|
|
|
|
|
state 199
|
|
|
|
(111) merger_module -> moduleKeyword id { merger_branches merger_rule1_n } .
|
|
|
|
moduleKeyword reduce using rule 111 (merger_module -> moduleKeyword id { merger_branches merger_rule1_n } .)
|
|
exportKeyword reduce using rule 111 (merger_module -> moduleKeyword id { merger_branches merger_rule1_n } .)
|
|
|
|
|
|
state 200
|
|
|
|
(122) merger_infix_rule -> qid_arg op . qid_arg
|
|
(127) qid_arg -> . qid
|
|
(128) qid_arg -> . IPv4
|
|
(129) qid_arg -> . IPv6
|
|
(130) qid_arg -> . CIDR
|
|
(131) qid_arg -> . MAC
|
|
(132) qid_arg -> . int
|
|
(133) qid_arg -> . float
|
|
(134) qid_arg -> . hex
|
|
(135) qid_arg -> . merger_prefix_rule
|
|
(136) qid_arg -> . string
|
|
(97) qid -> . id . id
|
|
(60) CIDR -> . IPv4 / int
|
|
(61) CIDR -> . IPv6 / int
|
|
(123) merger_prefix_rule -> . id ( qid_args )
|
|
|
|
IPv4 shift and go to state 192
|
|
IPv6 shift and go to state 193
|
|
MAC shift and go to state 191
|
|
int shift and go to state 177
|
|
float shift and go to state 179
|
|
hex shift and go to state 186
|
|
string shift and go to state 188
|
|
id shift and go to state 229
|
|
|
|
qid shift and go to state 187
|
|
merger_prefix_rule shift and go to state 227
|
|
CIDR shift and go to state 190
|
|
qid_arg shift and go to state 228
|
|
|
|
state 201
|
|
|
|
(155) allen_op -> fiKeyword .
|
|
|
|
id reduce using rule 155 (allen_op -> fiKeyword .)
|
|
|
|
|
|
state 202
|
|
|
|
(156) allen_op -> eqKeyword .
|
|
|
|
id reduce using rule 156 (allen_op -> eqKeyword .)
|
|
|
|
|
|
state 203
|
|
|
|
(144) allen_op -> GT .
|
|
|
|
id reduce using rule 144 (allen_op -> GT .)
|
|
|
|
|
|
state 204
|
|
|
|
(123) merger_prefix_rule -> id ( . qid_args )
|
|
(124) qid_args -> . qid_arg , qid_args
|
|
(125) qid_args -> . qid_arg
|
|
(126) qid_args -> .
|
|
(127) qid_arg -> . qid
|
|
(128) qid_arg -> . IPv4
|
|
(129) qid_arg -> . IPv6
|
|
(130) qid_arg -> . CIDR
|
|
(131) qid_arg -> . MAC
|
|
(132) qid_arg -> . int
|
|
(133) qid_arg -> . float
|
|
(134) qid_arg -> . hex
|
|
(135) qid_arg -> . merger_prefix_rule
|
|
(136) qid_arg -> . string
|
|
(97) qid -> . id . id
|
|
(60) CIDR -> . IPv4 / int
|
|
(61) CIDR -> . IPv6 / int
|
|
(123) merger_prefix_rule -> . id ( qid_args )
|
|
|
|
) reduce using rule 126 (qid_args -> .)
|
|
IPv4 shift and go to state 192
|
|
IPv6 shift and go to state 193
|
|
MAC shift and go to state 191
|
|
int shift and go to state 177
|
|
float shift and go to state 179
|
|
hex shift and go to state 186
|
|
string shift and go to state 188
|
|
id shift and go to state 229
|
|
|
|
qid shift and go to state 187
|
|
qid_args shift and go to state 230
|
|
merger_prefix_rule shift and go to state 227
|
|
qid_arg shift and go to state 231
|
|
CIDR shift and go to state 190
|
|
|
|
state 205
|
|
|
|
(148) allen_op -> oKeyword .
|
|
|
|
id reduce using rule 148 (allen_op -> oKeyword .)
|
|
|
|
|
|
state 206
|
|
|
|
(143) allen_op -> LT .
|
|
|
|
id reduce using rule 143 (allen_op -> LT .)
|
|
|
|
|
|
state 207
|
|
|
|
(150) allen_op -> sKeyword .
|
|
|
|
id reduce using rule 150 (allen_op -> sKeyword .)
|
|
|
|
|
|
state 208
|
|
|
|
(140) allen_rule -> id allen_op . id opt_allen_delta
|
|
|
|
id shift and go to state 232
|
|
|
|
|
|
state 209
|
|
|
|
(147) allen_op -> miKeyword .
|
|
|
|
id reduce using rule 147 (allen_op -> miKeyword .)
|
|
|
|
|
|
state 210
|
|
|
|
(149) allen_op -> oiKeyword .
|
|
|
|
id reduce using rule 149 (allen_op -> oiKeyword .)
|
|
|
|
|
|
state 211
|
|
|
|
(152) allen_op -> dKeyword .
|
|
|
|
id reduce using rule 152 (allen_op -> dKeyword .)
|
|
|
|
|
|
state 212
|
|
|
|
(146) allen_op -> mKeyword .
|
|
|
|
id reduce using rule 146 (allen_op -> mKeyword .)
|
|
|
|
|
|
state 213
|
|
|
|
(151) allen_op -> siKeyword .
|
|
|
|
id reduce using rule 151 (allen_op -> siKeyword .)
|
|
|
|
|
|
state 214
|
|
|
|
(154) allen_op -> fKeyword .
|
|
|
|
id reduce using rule 154 (allen_op -> fKeyword .)
|
|
|
|
|
|
state 215
|
|
|
|
(145) allen_op -> EQ .
|
|
|
|
id reduce using rule 145 (allen_op -> EQ .)
|
|
|
|
|
|
state 216
|
|
|
|
(153) allen_op -> diKeyword .
|
|
|
|
id reduce using rule 153 (allen_op -> diKeyword .)
|
|
|
|
|
|
state 217
|
|
|
|
(116) merger_rule1_n -> merger_rule merger_rule1_n .
|
|
|
|
} reduce using rule 116 (merger_rule1_n -> merger_rule merger_rule1_n .)
|
|
|
|
|
|
state 218
|
|
|
|
(120) merger_rule -> NOTKeyword merger_prefix_rule .
|
|
(135) qid_arg -> merger_prefix_rule .
|
|
|
|
NOTKeyword reduce using rule 120 (merger_rule -> NOTKeyword merger_prefix_rule .)
|
|
id reduce using rule 120 (merger_rule -> NOTKeyword merger_prefix_rule .)
|
|
IPv4 reduce using rule 120 (merger_rule -> NOTKeyword merger_prefix_rule .)
|
|
IPv6 reduce using rule 120 (merger_rule -> NOTKeyword merger_prefix_rule .)
|
|
MAC reduce using rule 120 (merger_rule -> NOTKeyword merger_prefix_rule .)
|
|
int reduce using rule 120 (merger_rule -> NOTKeyword merger_prefix_rule .)
|
|
float reduce using rule 120 (merger_rule -> NOTKeyword merger_prefix_rule .)
|
|
hex reduce using rule 120 (merger_rule -> NOTKeyword merger_prefix_rule .)
|
|
string reduce using rule 120 (merger_rule -> NOTKeyword merger_prefix_rule .)
|
|
} reduce using rule 120 (merger_rule -> NOTKeyword merger_prefix_rule .)
|
|
EQ reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
LT reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
GT reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
LTEQ reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
GTEQ reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
ML reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
MG reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
inKeyword reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
notinKeyword reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
|
|
|
|
state 219
|
|
|
|
(121) merger_rule -> NOTKeyword merger_infix_rule .
|
|
|
|
NOTKeyword reduce using rule 121 (merger_rule -> NOTKeyword merger_infix_rule .)
|
|
id reduce using rule 121 (merger_rule -> NOTKeyword merger_infix_rule .)
|
|
IPv4 reduce using rule 121 (merger_rule -> NOTKeyword merger_infix_rule .)
|
|
IPv6 reduce using rule 121 (merger_rule -> NOTKeyword merger_infix_rule .)
|
|
MAC reduce using rule 121 (merger_rule -> NOTKeyword merger_infix_rule .)
|
|
int reduce using rule 121 (merger_rule -> NOTKeyword merger_infix_rule .)
|
|
float reduce using rule 121 (merger_rule -> NOTKeyword merger_infix_rule .)
|
|
hex reduce using rule 121 (merger_rule -> NOTKeyword merger_infix_rule .)
|
|
string reduce using rule 121 (merger_rule -> NOTKeyword merger_infix_rule .)
|
|
} reduce using rule 121 (merger_rule -> NOTKeyword merger_infix_rule .)
|
|
|
|
|
|
state 220
|
|
|
|
(123) merger_prefix_rule -> id . ( qid_args )
|
|
(97) qid -> id . . id
|
|
|
|
( shift and go to state 204
|
|
. shift and go to state 153
|
|
|
|
|
|
state 221
|
|
|
|
(137) merger_rule -> allen_rule opt_or_allen_rule .
|
|
|
|
NOTKeyword reduce using rule 137 (merger_rule -> allen_rule opt_or_allen_rule .)
|
|
id reduce using rule 137 (merger_rule -> allen_rule opt_or_allen_rule .)
|
|
IPv4 reduce using rule 137 (merger_rule -> allen_rule opt_or_allen_rule .)
|
|
IPv6 reduce using rule 137 (merger_rule -> allen_rule opt_or_allen_rule .)
|
|
MAC reduce using rule 137 (merger_rule -> allen_rule opt_or_allen_rule .)
|
|
int reduce using rule 137 (merger_rule -> allen_rule opt_or_allen_rule .)
|
|
float reduce using rule 137 (merger_rule -> allen_rule opt_or_allen_rule .)
|
|
hex reduce using rule 137 (merger_rule -> allen_rule opt_or_allen_rule .)
|
|
string reduce using rule 137 (merger_rule -> allen_rule opt_or_allen_rule .)
|
|
} reduce using rule 137 (merger_rule -> allen_rule opt_or_allen_rule .)
|
|
|
|
|
|
state 222
|
|
|
|
(138) opt_or_allen_rule -> ORKeyword . allen_rule opt_or_allen_rule
|
|
(140) allen_rule -> . id allen_op id opt_allen_delta
|
|
|
|
id shift and go to state 234
|
|
|
|
allen_rule shift and go to state 233
|
|
|
|
state 223
|
|
|
|
(113) branches1_n -> id , . branches1_n
|
|
(113) branches1_n -> . id , branches1_n
|
|
(114) branches1_n -> . id
|
|
|
|
id shift and go to state 195
|
|
|
|
branches1_n shift and go to state 235
|
|
|
|
state 224
|
|
|
|
(79) grouper_rule -> id grouper_op id rdeltaKeyword . delta_arg
|
|
(85) delta_arg -> . time
|
|
(86) delta_arg -> . int
|
|
(87) time -> . int sKeyword
|
|
(88) time -> . int msKeyword
|
|
(89) time -> . int minKeyword
|
|
|
|
int shift and go to state 236
|
|
|
|
delta_arg shift and go to state 238
|
|
time shift and go to state 237
|
|
|
|
state 225
|
|
|
|
(78) grouper_rule -> id grouper_op id deltaKeyword . delta_arg
|
|
(85) delta_arg -> . time
|
|
(86) delta_arg -> . int
|
|
(87) time -> . int sKeyword
|
|
(88) time -> . int msKeyword
|
|
(89) time -> . int minKeyword
|
|
|
|
int shift and go to state 236
|
|
|
|
delta_arg shift and go to state 239
|
|
time shift and go to state 237
|
|
|
|
state 226
|
|
|
|
(94) aggr -> aggr_op ( id_or_qid ) asKeyword . id
|
|
|
|
id shift and go to state 240
|
|
|
|
|
|
state 227
|
|
|
|
(135) qid_arg -> merger_prefix_rule .
|
|
|
|
, reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
) reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
NOTKeyword reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
id reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
IPv4 reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
IPv6 reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
MAC reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
int reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
float reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
hex reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
string reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
} reduce using rule 135 (qid_arg -> merger_prefix_rule .)
|
|
|
|
|
|
state 228
|
|
|
|
(122) merger_infix_rule -> qid_arg op qid_arg .
|
|
|
|
NOTKeyword reduce using rule 122 (merger_infix_rule -> qid_arg op qid_arg .)
|
|
id reduce using rule 122 (merger_infix_rule -> qid_arg op qid_arg .)
|
|
IPv4 reduce using rule 122 (merger_infix_rule -> qid_arg op qid_arg .)
|
|
IPv6 reduce using rule 122 (merger_infix_rule -> qid_arg op qid_arg .)
|
|
MAC reduce using rule 122 (merger_infix_rule -> qid_arg op qid_arg .)
|
|
int reduce using rule 122 (merger_infix_rule -> qid_arg op qid_arg .)
|
|
float reduce using rule 122 (merger_infix_rule -> qid_arg op qid_arg .)
|
|
hex reduce using rule 122 (merger_infix_rule -> qid_arg op qid_arg .)
|
|
string reduce using rule 122 (merger_infix_rule -> qid_arg op qid_arg .)
|
|
} reduce using rule 122 (merger_infix_rule -> qid_arg op qid_arg .)
|
|
|
|
|
|
state 229
|
|
|
|
(97) qid -> id . . id
|
|
(123) merger_prefix_rule -> id . ( qid_args )
|
|
|
|
. shift and go to state 153
|
|
( shift and go to state 204
|
|
|
|
|
|
state 230
|
|
|
|
(123) merger_prefix_rule -> id ( qid_args . )
|
|
|
|
) shift and go to state 241
|
|
|
|
|
|
state 231
|
|
|
|
(124) qid_args -> qid_arg . , qid_args
|
|
(125) qid_args -> qid_arg .
|
|
|
|
, shift and go to state 242
|
|
) reduce using rule 125 (qid_args -> qid_arg .)
|
|
|
|
|
|
state 232
|
|
|
|
(140) allen_rule -> id allen_op id . opt_allen_delta
|
|
(141) opt_allen_delta -> . deltaKeyword time
|
|
(142) opt_allen_delta -> .
|
|
|
|
deltaKeyword shift and go to state 243
|
|
ORKeyword reduce using rule 142 (opt_allen_delta -> .)
|
|
NOTKeyword reduce using rule 142 (opt_allen_delta -> .)
|
|
id reduce using rule 142 (opt_allen_delta -> .)
|
|
IPv4 reduce using rule 142 (opt_allen_delta -> .)
|
|
IPv6 reduce using rule 142 (opt_allen_delta -> .)
|
|
MAC reduce using rule 142 (opt_allen_delta -> .)
|
|
int reduce using rule 142 (opt_allen_delta -> .)
|
|
float reduce using rule 142 (opt_allen_delta -> .)
|
|
hex reduce using rule 142 (opt_allen_delta -> .)
|
|
string reduce using rule 142 (opt_allen_delta -> .)
|
|
} reduce using rule 142 (opt_allen_delta -> .)
|
|
|
|
opt_allen_delta shift and go to state 244
|
|
|
|
state 233
|
|
|
|
(138) opt_or_allen_rule -> ORKeyword allen_rule . opt_or_allen_rule
|
|
(138) opt_or_allen_rule -> . ORKeyword allen_rule opt_or_allen_rule
|
|
(139) opt_or_allen_rule -> .
|
|
|
|
ORKeyword shift and go to state 222
|
|
NOTKeyword reduce using rule 139 (opt_or_allen_rule -> .)
|
|
id reduce using rule 139 (opt_or_allen_rule -> .)
|
|
IPv4 reduce using rule 139 (opt_or_allen_rule -> .)
|
|
IPv6 reduce using rule 139 (opt_or_allen_rule -> .)
|
|
MAC reduce using rule 139 (opt_or_allen_rule -> .)
|
|
int reduce using rule 139 (opt_or_allen_rule -> .)
|
|
float reduce using rule 139 (opt_or_allen_rule -> .)
|
|
hex reduce using rule 139 (opt_or_allen_rule -> .)
|
|
string reduce using rule 139 (opt_or_allen_rule -> .)
|
|
} reduce using rule 139 (opt_or_allen_rule -> .)
|
|
|
|
opt_or_allen_rule shift and go to state 245
|
|
|
|
state 234
|
|
|
|
(140) allen_rule -> id . allen_op id opt_allen_delta
|
|
(143) allen_op -> . LT
|
|
(144) allen_op -> . GT
|
|
(145) allen_op -> . EQ
|
|
(146) allen_op -> . mKeyword
|
|
(147) allen_op -> . miKeyword
|
|
(148) allen_op -> . oKeyword
|
|
(149) allen_op -> . oiKeyword
|
|
(150) allen_op -> . sKeyword
|
|
(151) allen_op -> . siKeyword
|
|
(152) allen_op -> . dKeyword
|
|
(153) allen_op -> . diKeyword
|
|
(154) allen_op -> . fKeyword
|
|
(155) allen_op -> . fiKeyword
|
|
(156) allen_op -> . eqKeyword
|
|
|
|
LT shift and go to state 206
|
|
GT shift and go to state 203
|
|
EQ shift and go to state 215
|
|
mKeyword shift and go to state 212
|
|
miKeyword shift and go to state 209
|
|
oKeyword shift and go to state 205
|
|
oiKeyword shift and go to state 210
|
|
sKeyword shift and go to state 207
|
|
siKeyword shift and go to state 213
|
|
dKeyword shift and go to state 211
|
|
diKeyword shift and go to state 216
|
|
fKeyword shift and go to state 214
|
|
fiKeyword shift and go to state 201
|
|
eqKeyword shift and go to state 202
|
|
|
|
allen_op shift and go to state 208
|
|
|
|
state 235
|
|
|
|
(113) branches1_n -> id , branches1_n .
|
|
|
|
NOTKeyword reduce using rule 113 (branches1_n -> id , branches1_n .)
|
|
id reduce using rule 113 (branches1_n -> id , branches1_n .)
|
|
IPv4 reduce using rule 113 (branches1_n -> id , branches1_n .)
|
|
IPv6 reduce using rule 113 (branches1_n -> id , branches1_n .)
|
|
MAC reduce using rule 113 (branches1_n -> id , branches1_n .)
|
|
int reduce using rule 113 (branches1_n -> id , branches1_n .)
|
|
float reduce using rule 113 (branches1_n -> id , branches1_n .)
|
|
hex reduce using rule 113 (branches1_n -> id , branches1_n .)
|
|
string reduce using rule 113 (branches1_n -> id , branches1_n .)
|
|
} reduce using rule 113 (branches1_n -> id , branches1_n .)
|
|
|
|
|
|
state 236
|
|
|
|
(86) delta_arg -> int .
|
|
(87) time -> int . sKeyword
|
|
(88) time -> int . msKeyword
|
|
(89) time -> int . minKeyword
|
|
|
|
id reduce using rule 86 (delta_arg -> int .)
|
|
} reduce using rule 86 (delta_arg -> int .)
|
|
sKeyword shift and go to state 246
|
|
msKeyword shift and go to state 247
|
|
minKeyword shift and go to state 248
|
|
|
|
|
|
state 237
|
|
|
|
(85) delta_arg -> time .
|
|
|
|
id reduce using rule 85 (delta_arg -> time .)
|
|
} reduce using rule 85 (delta_arg -> time .)
|
|
|
|
|
|
state 238
|
|
|
|
(79) grouper_rule -> id grouper_op id rdeltaKeyword delta_arg .
|
|
|
|
id reduce using rule 79 (grouper_rule -> id grouper_op id rdeltaKeyword delta_arg .)
|
|
} reduce using rule 79 (grouper_rule -> id grouper_op id rdeltaKeyword delta_arg .)
|
|
|
|
|
|
state 239
|
|
|
|
(78) grouper_rule -> id grouper_op id deltaKeyword delta_arg .
|
|
|
|
id reduce using rule 78 (grouper_rule -> id grouper_op id deltaKeyword delta_arg .)
|
|
} reduce using rule 78 (grouper_rule -> id grouper_op id deltaKeyword delta_arg .)
|
|
|
|
|
|
state 240
|
|
|
|
(94) aggr -> aggr_op ( id_or_qid ) asKeyword id .
|
|
|
|
, reduce using rule 94 (aggr -> aggr_op ( id_or_qid ) asKeyword id .)
|
|
} reduce using rule 94 (aggr -> aggr_op ( id_or_qid ) asKeyword id .)
|
|
|
|
|
|
state 241
|
|
|
|
(123) merger_prefix_rule -> id ( qid_args ) .
|
|
|
|
NOTKeyword reduce using rule 123 (merger_prefix_rule -> id ( qid_args ) .)
|
|
id reduce using rule 123 (merger_prefix_rule -> id ( qid_args ) .)
|
|
IPv4 reduce using rule 123 (merger_prefix_rule -> id ( qid_args ) .)
|
|
IPv6 reduce using rule 123 (merger_prefix_rule -> id ( qid_args ) .)
|
|
MAC reduce using rule 123 (merger_prefix_rule -> id ( qid_args ) .)
|
|
int reduce using rule 123 (merger_prefix_rule -> id ( qid_args ) .)
|
|
float reduce using rule 123 (merger_prefix_rule -> id ( qid_args ) .)
|
|
hex reduce using rule 123 (merger_prefix_rule -> id ( qid_args ) .)
|
|
string reduce using rule 123 (merger_prefix_rule -> id ( qid_args ) .)
|
|
} reduce using rule 123 (merger_prefix_rule -> id ( qid_args ) .)
|
|
EQ reduce using rule 123 (merger_prefix_rule -> id ( qid_args ) .)
|
|
LT reduce using rule 123 (merger_prefix_rule -> id ( qid_args ) .)
|
|
GT reduce using rule 123 (merger_prefix_rule -> id ( qid_args ) .)
|
|
LTEQ reduce using rule 123 (merger_prefix_rule -> id ( qid_args ) .)
|
|
GTEQ reduce using rule 123 (merger_prefix_rule -> id ( qid_args ) .)
|
|
ML reduce using rule 123 (merger_prefix_rule -> id ( qid_args ) .)
|
|
MG reduce using rule 123 (merger_prefix_rule -> id ( qid_args ) .)
|
|
inKeyword reduce using rule 123 (merger_prefix_rule -> id ( qid_args ) .)
|
|
notinKeyword reduce using rule 123 (merger_prefix_rule -> id ( qid_args ) .)
|
|
, reduce using rule 123 (merger_prefix_rule -> id ( qid_args ) .)
|
|
) reduce using rule 123 (merger_prefix_rule -> id ( qid_args ) .)
|
|
|
|
|
|
state 242
|
|
|
|
(124) qid_args -> qid_arg , . qid_args
|
|
(124) qid_args -> . qid_arg , qid_args
|
|
(125) qid_args -> . qid_arg
|
|
(126) qid_args -> .
|
|
(127) qid_arg -> . qid
|
|
(128) qid_arg -> . IPv4
|
|
(129) qid_arg -> . IPv6
|
|
(130) qid_arg -> . CIDR
|
|
(131) qid_arg -> . MAC
|
|
(132) qid_arg -> . int
|
|
(133) qid_arg -> . float
|
|
(134) qid_arg -> . hex
|
|
(135) qid_arg -> . merger_prefix_rule
|
|
(136) qid_arg -> . string
|
|
(97) qid -> . id . id
|
|
(60) CIDR -> . IPv4 / int
|
|
(61) CIDR -> . IPv6 / int
|
|
(123) merger_prefix_rule -> . id ( qid_args )
|
|
|
|
) reduce using rule 126 (qid_args -> .)
|
|
IPv4 shift and go to state 192
|
|
IPv6 shift and go to state 193
|
|
MAC shift and go to state 191
|
|
int shift and go to state 177
|
|
float shift and go to state 179
|
|
hex shift and go to state 186
|
|
string shift and go to state 188
|
|
id shift and go to state 229
|
|
|
|
qid shift and go to state 187
|
|
qid_args shift and go to state 249
|
|
merger_prefix_rule shift and go to state 227
|
|
qid_arg shift and go to state 231
|
|
CIDR shift and go to state 190
|
|
|
|
state 243
|
|
|
|
(141) opt_allen_delta -> deltaKeyword . time
|
|
(87) time -> . int sKeyword
|
|
(88) time -> . int msKeyword
|
|
(89) time -> . int minKeyword
|
|
|
|
int shift and go to state 250
|
|
|
|
time shift and go to state 251
|
|
|
|
state 244
|
|
|
|
(140) allen_rule -> id allen_op id opt_allen_delta .
|
|
|
|
ORKeyword reduce using rule 140 (allen_rule -> id allen_op id opt_allen_delta .)
|
|
NOTKeyword reduce using rule 140 (allen_rule -> id allen_op id opt_allen_delta .)
|
|
id reduce using rule 140 (allen_rule -> id allen_op id opt_allen_delta .)
|
|
IPv4 reduce using rule 140 (allen_rule -> id allen_op id opt_allen_delta .)
|
|
IPv6 reduce using rule 140 (allen_rule -> id allen_op id opt_allen_delta .)
|
|
MAC reduce using rule 140 (allen_rule -> id allen_op id opt_allen_delta .)
|
|
int reduce using rule 140 (allen_rule -> id allen_op id opt_allen_delta .)
|
|
float reduce using rule 140 (allen_rule -> id allen_op id opt_allen_delta .)
|
|
hex reduce using rule 140 (allen_rule -> id allen_op id opt_allen_delta .)
|
|
string reduce using rule 140 (allen_rule -> id allen_op id opt_allen_delta .)
|
|
} reduce using rule 140 (allen_rule -> id allen_op id opt_allen_delta .)
|
|
|
|
|
|
state 245
|
|
|
|
(138) opt_or_allen_rule -> ORKeyword allen_rule opt_or_allen_rule .
|
|
|
|
NOTKeyword reduce using rule 138 (opt_or_allen_rule -> ORKeyword allen_rule opt_or_allen_rule .)
|
|
id reduce using rule 138 (opt_or_allen_rule -> ORKeyword allen_rule opt_or_allen_rule .)
|
|
IPv4 reduce using rule 138 (opt_or_allen_rule -> ORKeyword allen_rule opt_or_allen_rule .)
|
|
IPv6 reduce using rule 138 (opt_or_allen_rule -> ORKeyword allen_rule opt_or_allen_rule .)
|
|
MAC reduce using rule 138 (opt_or_allen_rule -> ORKeyword allen_rule opt_or_allen_rule .)
|
|
int reduce using rule 138 (opt_or_allen_rule -> ORKeyword allen_rule opt_or_allen_rule .)
|
|
float reduce using rule 138 (opt_or_allen_rule -> ORKeyword allen_rule opt_or_allen_rule .)
|
|
hex reduce using rule 138 (opt_or_allen_rule -> ORKeyword allen_rule opt_or_allen_rule .)
|
|
string reduce using rule 138 (opt_or_allen_rule -> ORKeyword allen_rule opt_or_allen_rule .)
|
|
} reduce using rule 138 (opt_or_allen_rule -> ORKeyword allen_rule opt_or_allen_rule .)
|
|
|
|
|
|
state 246
|
|
|
|
(87) time -> int sKeyword .
|
|
|
|
id reduce using rule 87 (time -> int sKeyword .)
|
|
} reduce using rule 87 (time -> int sKeyword .)
|
|
ORKeyword reduce using rule 87 (time -> int sKeyword .)
|
|
NOTKeyword reduce using rule 87 (time -> int sKeyword .)
|
|
IPv4 reduce using rule 87 (time -> int sKeyword .)
|
|
IPv6 reduce using rule 87 (time -> int sKeyword .)
|
|
MAC reduce using rule 87 (time -> int sKeyword .)
|
|
int reduce using rule 87 (time -> int sKeyword .)
|
|
float reduce using rule 87 (time -> int sKeyword .)
|
|
hex reduce using rule 87 (time -> int sKeyword .)
|
|
string reduce using rule 87 (time -> int sKeyword .)
|
|
|
|
|
|
state 247
|
|
|
|
(88) time -> int msKeyword .
|
|
|
|
id reduce using rule 88 (time -> int msKeyword .)
|
|
} reduce using rule 88 (time -> int msKeyword .)
|
|
ORKeyword reduce using rule 88 (time -> int msKeyword .)
|
|
NOTKeyword reduce using rule 88 (time -> int msKeyword .)
|
|
IPv4 reduce using rule 88 (time -> int msKeyword .)
|
|
IPv6 reduce using rule 88 (time -> int msKeyword .)
|
|
MAC reduce using rule 88 (time -> int msKeyword .)
|
|
int reduce using rule 88 (time -> int msKeyword .)
|
|
float reduce using rule 88 (time -> int msKeyword .)
|
|
hex reduce using rule 88 (time -> int msKeyword .)
|
|
string reduce using rule 88 (time -> int msKeyword .)
|
|
|
|
|
|
state 248
|
|
|
|
(89) time -> int minKeyword .
|
|
|
|
id reduce using rule 89 (time -> int minKeyword .)
|
|
} reduce using rule 89 (time -> int minKeyword .)
|
|
ORKeyword reduce using rule 89 (time -> int minKeyword .)
|
|
NOTKeyword reduce using rule 89 (time -> int minKeyword .)
|
|
IPv4 reduce using rule 89 (time -> int minKeyword .)
|
|
IPv6 reduce using rule 89 (time -> int minKeyword .)
|
|
MAC reduce using rule 89 (time -> int minKeyword .)
|
|
int reduce using rule 89 (time -> int minKeyword .)
|
|
float reduce using rule 89 (time -> int minKeyword .)
|
|
hex reduce using rule 89 (time -> int minKeyword .)
|
|
string reduce using rule 89 (time -> int minKeyword .)
|
|
|
|
|
|
state 249
|
|
|
|
(124) qid_args -> qid_arg , qid_args .
|
|
|
|
) reduce using rule 124 (qid_args -> qid_arg , qid_args .)
|
|
|
|
|
|
state 250
|
|
|
|
(87) time -> int . sKeyword
|
|
(88) time -> int . msKeyword
|
|
(89) time -> int . minKeyword
|
|
|
|
sKeyword shift and go to state 246
|
|
msKeyword shift and go to state 247
|
|
minKeyword shift and go to state 248
|
|
|
|
|
|
state 251
|
|
|
|
(141) opt_allen_delta -> deltaKeyword time .
|
|
|
|
ORKeyword reduce using rule 141 (opt_allen_delta -> deltaKeyword time .)
|
|
NOTKeyword reduce using rule 141 (opt_allen_delta -> deltaKeyword time .)
|
|
id reduce using rule 141 (opt_allen_delta -> deltaKeyword time .)
|
|
IPv4 reduce using rule 141 (opt_allen_delta -> deltaKeyword time .)
|
|
IPv6 reduce using rule 141 (opt_allen_delta -> deltaKeyword time .)
|
|
MAC reduce using rule 141 (opt_allen_delta -> deltaKeyword time .)
|
|
int reduce using rule 141 (opt_allen_delta -> deltaKeyword time .)
|
|
float reduce using rule 141 (opt_allen_delta -> deltaKeyword time .)
|
|
hex reduce using rule 141 (opt_allen_delta -> deltaKeyword time .)
|
|
string reduce using rule 141 (opt_allen_delta -> deltaKeyword time .)
|
|
} reduce using rule 141 (opt_allen_delta -> deltaKeyword time .)
|
|
|