1 #include "php_phalcon.h"
2 #if PHP_VERSION_ID < 70000
3 /* Driver template for the LEMON parser generator.
4 ** The author disclaims copyright to this source code.
5 */
6 /* First off, code is include which follows the "include" declaration
7 ** in the input file. */
8 #include <stdio.h>
9 // 39 "parser.php5.lemon"
10
11 #include "parser.php5.inc.h"
12
13 // 12 "parser.php5.c"
14 /* Next is all token values, in a form suitable for use by makeheaders.
15 ** This section will be null unless lemon is run with the -m switch.
16 */
17 /*
18 ** These constants (all generated automatically by the parser generator)
19 ** specify the various kinds of tokens (terminals) that the parser
20 ** understands.
21 **
22 ** Each symbol here is a terminal symbol in the grammar.
23 */
24 /* Make sure the INTERFACE macro is defined.
25 */
26 #ifndef INTERFACE
27 # define INTERFACE 1
28 #endif
29 /* The next thing included is series of defines which control
30 ** various aspects of the generated parser.
31 ** PPCODETYPE is the data type used for storing terminal
32 ** and nonterminal numbers. "unsigned char" is
33 ** used if there are fewer than 250 terminals
34 ** and nonterminals. "int" is used otherwise.
35 ** PPNOCODE is a number of type PPCODETYPE which corresponds
36 ** to no legal terminal or nonterminal number. This
37 ** number is used to fill in empty slots of the hash
38 ** table.
39 ** PPFALLBACK If defined, this indicates that one or more tokens
40 ** have fall-back values which should be used if the
41 ** original value of the token will not parse.
42 ** PPACTIONTYPE is the data type used for storing terminal
43 ** and nonterminal numbers. "unsigned char" is
44 ** used if there are fewer than 250 rules and
45 ** states combined. "int" is used otherwise.
46 ** phql_TOKENTYPE is the data type used for minor tokens given
47 ** directly to the parser from the tokenizer.
48 ** PPMINORTYPE is the data type used for all minor tokens.
49 ** This is typically a union of many types, one of
50 ** which is phql_TOKENTYPE. The entry in the union
51 ** for base tokens is called "pp0".
52 ** PPSTACKDEPTH is the maximum depth of the parser's stack.
53 ** phql_ARG_SDECL A static variable declaration for the %extra_argument
54 ** phql_ARG_PDECL A parameter declaration for the %extra_argument
55 ** phql_ARG_STORE Code to store %extra_argument into pppParser
56 ** phql_ARG_FETCH Code to extract %extra_argument from pppParser
57 ** PPNSTATE the combined number of states.
58 ** PPNRULE the number of rules in the grammar
59 ** PPERRORSYMBOL is the code number of the error symbol. If not
60 ** defined, then do no error processing.
61 */
62 #define PPCODETYPE unsigned char
63 #define PPNOCODE 134
64 #define PPACTIONTYPE unsigned short int
65 #define phql_TOKENTYPE phql_parser_token*
66 typedef union {
67 phql_TOKENTYPE pp0;
68 zval* pp162;
69 int pp267;
70 } PPMINORTYPE;
71 #define PPSTACKDEPTH 100
72 #define phql_ARG_SDECL phql_parser_status *status;
73 #define phql_ARG_PDECL ,phql_parser_status *status
74 #define phql_ARG_FETCH phql_parser_status *status = pppParser->status
75 #define phql_ARG_STORE pppParser->status = status
76 #define PPNSTATE 293
77 #define PPNRULE 161
78 #define PPERRORSYMBOL 79
79 #define PPERRSYMDT pp267
80 #define PP_NO_ACTION (PPNSTATE+PPNRULE+2)
81 #define PP_ACCEPT_ACTION (PPNSTATE+PPNRULE+1)
82 #define PP_ERROR_ACTION (PPNSTATE+PPNRULE)
83
84 /* Next are that tables used to determine what action to take based on the
85 ** current state and lookahead token. These tables are used to implement
86 ** functions that take a state number and lookahead value and return an
87 ** action integer.
88 **
89 ** Suppose the action integer is N. Then the action is determined as
90 ** follows
91 **
92 ** 0 <= N < PPNSTATE Shift N. That is, push the lookahead
93 ** token onto the stack and goto state N.
94 **
95 ** PPNSTATE <= N < PPNSTATE+PPNRULE Reduce by rule N-PPNSTATE.
96 **
97 ** N == PPNSTATE+PPNRULE A syntax error has occurred.
98 **
99 ** N == PPNSTATE+PPNRULE+1 The parser accepts its input.
100 **
101 ** N == PPNSTATE+PPNRULE+2 No such action. Denotes unused
102 ** slots in the pp_action[] table.
103 **
104 ** The action table is constructed as a single large table named pp_action[].
105 ** Given state S and lookahead X, the action is computed as
106 **
107 ** pp_action[ pp_shift_ofst[S] + X ]
108 **
109 ** If the index value pp_shift_ofst[S]+X is out of range or if the value
110 ** pp_lookahead[pp_shift_ofst[S]+X] is not equal to X or if pp_shift_ofst[S]
111 ** is equal to PP_SHIFT_USE_DFLT, it means that the action is not in the table
112 ** and that pp_default[S] should be used instead.
113 **
114 ** The formula above is for computing the action when the lookahead is
115 ** a terminal symbol. If the lookahead is a non-terminal (as occurs after
116 ** a reduce action) then the pp_reduce_ofst[] array is used in place of
117 ** the pp_shift_ofst[] array and PP_REDUCE_USE_DFLT is used in place of
118 ** PP_SHIFT_USE_DFLT.
119 **
120 ** The following are the tables generated in this section:
121 **
122 ** pp_action[] A single table containing all actions.
123 ** pp_lookahead[] A table containing the lookahead for each entry in
124 ** pp_action. Used to detect hash collisions.
125 ** pp_shift_ofst[] For each state, the offset into pp_action for
126 ** shifting terminals.
127 ** pp_reduce_ofst[] For each state, the offset into pp_action for
128 ** shifting non-terminals after a reduce.
129 ** pp_default[] Default action for each state.
130 */
131 static PPACTIONTYPE pp_action[] = {
132 /* 0 */ 120, 126, 55, 57, 59, 61, 63, 65, 45, 47,
133 /* 10 */ 67, 72, 49, 51, 53, 41, 39, 43, 37, 34,
134 /* 20 */ 122, 74, 69, 120, 126, 55, 57, 59, 61, 63,
135 /* 30 */ 65, 45, 47, 67, 72, 49, 51, 53, 41, 39,
136 /* 40 */ 43, 37, 34, 122, 74, 69, 37, 34, 122, 74,
137 /* 50 */ 69, 166, 220, 92, 218, 45, 47, 67, 72, 49,
138 /* 60 */ 51, 53, 41, 39, 43, 37, 34, 122, 74, 69,
139 /* 70 */ 154, 429, 186, 91, 120, 126, 55, 57, 59, 61,
140 /* 80 */ 63, 65, 45, 47, 67, 72, 49, 51, 53, 41,
141 /* 90 */ 39, 43, 37, 34, 122, 74, 69, 120, 126, 55,
142 /* 100 */ 57, 59, 61, 63, 65, 45, 47, 67, 72, 49,
143 /* 110 */ 51, 53, 41, 39, 43, 37, 34, 122, 74, 69,
144 /* 120 */ 19, 20, 21, 22, 23, 227, 32, 33, 67, 72,
145 /* 130 */ 49, 51, 53, 41, 39, 43, 37, 34, 122, 74,
146 /* 140 */ 69, 130, 238, 120, 126, 55, 57, 59, 61, 63,
147 /* 150 */ 65, 45, 47, 67, 72, 49, 51, 53, 41, 39,
148 /* 160 */ 43, 37, 34, 122, 74, 69, 41, 39, 43, 37,
149 /* 170 */ 34, 122, 74, 69, 140, 8, 120, 126, 55, 57,
150 /* 180 */ 59, 61, 63, 65, 45, 47, 67, 72, 49, 51,
151 /* 190 */ 53, 41, 39, 43, 37, 34, 122, 74, 69, 120,
152 /* 200 */ 126, 55, 57, 59, 61, 63, 65, 45, 47, 67,
153 /* 210 */ 72, 49, 51, 53, 41, 39, 43, 37, 34, 122,
154 /* 220 */ 74, 69, 120, 126, 55, 57, 59, 61, 63, 65,
155 /* 230 */ 45, 47, 67, 72, 49, 51, 53, 41, 39, 43,
156 /* 240 */ 37, 34, 122, 74, 69, 168, 109, 156, 35, 95,
157 /* 250 */ 99, 169, 171, 26, 76, 151, 188, 81, 159, 160,
158 /* 260 */ 82, 111, 209, 113, 114, 17, 146, 285, 192, 208,
159 /* 270 */ 194, 196, 128, 200, 204, 222, 223, 455, 1, 2,
160 /* 280 */ 3, 4, 5, 6, 199, 173, 284, 197, 174, 175,
161 /* 290 */ 181, 182, 183, 133, 137, 143, 76, 149, 158, 24,
162 /* 300 */ 212, 217, 178, 176, 177, 179, 180, 168, 135, 271,
163 /* 310 */ 35, 249, 6, 169, 171, 287, 276, 110, 290, 173,
164 /* 320 */ 159, 49, 51, 53, 41, 39, 43, 37, 34, 122,
165 /* 330 */ 74, 69, 158, 384, 128, 430, 192, 208, 194, 196,
166 /* 340 */ 80, 200, 204, 292, 210, 122, 74, 69, 84, 84,
167 /* 350 */ 174, 175, 181, 182, 183, 133, 137, 143, 125, 149,
168 /* 360 */ 107, 107, 95, 90, 178, 176, 177, 179, 180, 55,
169 /* 370 */ 57, 59, 61, 63, 65, 45, 47, 67, 72, 49,
170 /* 380 */ 51, 53, 41, 39, 43, 37, 34, 122, 74, 69,
171 /* 390 */ 213, 274, 258, 35, 70, 228, 169, 171, 131, 109,
172 /* 400 */ 245, 265, 6, 214, 259, 230, 279, 286, 282, 234,
173 /* 410 */ 173, 83, 203, 6, 129, 201, 84, 128, 173, 152,
174 /* 420 */ 154, 207, 186, 158, 205, 162, 244, 96, 107, 85,
175 /* 430 */ 219, 158, 173, 174, 175, 181, 182, 183, 133, 137,
176 /* 440 */ 143, 94, 149, 173, 7, 158, 102, 178, 176, 177,
177 /* 450 */ 179, 180, 162, 232, 35, 89, 158, 169, 171, 184,
178 /* 460 */ 76, 112, 113, 114, 159, 211, 215, 79, 94, 78,
179 /* 470 */ 173, 226, 221, 217, 94, 6, 277, 240, 128, 160,
180 /* 480 */ 165, 84, 98, 158, 250, 163, 184, 162, 103, 95,
181 /* 490 */ 104, 173, 94, 107, 174, 175, 181, 182, 183, 133,
182 /* 500 */ 137, 143, 92, 149, 158, 173, 108, 155, 178, 176,
183 /* 510 */ 177, 179, 180, 168, 92, 224, 35, 258, 158, 169,
184 /* 520 */ 171, 184, 100, 27, 258, 173, 159, 166, 216, 257,
185 /* 530 */ 191, 115, 189, 254, 105, 173, 259, 124, 158, 69,
186 /* 540 */ 128, 110, 173, 107, 166, 281, 282, 225, 158, 252,
187 /* 550 */ 260, 31, 253, 10, 251, 158, 174, 175, 181, 182,
188 /* 560 */ 183, 133, 137, 143, 233, 149, 107, 106, 42, 173,
189 /* 570 */ 178, 176, 177, 179, 180, 30, 247, 35, 329, 245,
190 /* 580 */ 169, 171, 158, 147, 31, 229, 173, 159, 123, 328,
191 /* 590 */ 261, 332, 256, 270, 101, 327, 162, 173, 326, 158,
192 /* 600 */ 325, 128, 173, 173, 242, 246, 206, 28, 237, 18,
193 /* 610 */ 158, 50, 255, 202, 173, 158, 158, 174, 175, 181,
194 /* 620 */ 182, 183, 133, 137, 143, 121, 149, 158, 239, 173,
195 /* 630 */ 167, 178, 176, 177, 179, 180, 97, 269, 164, 119,
196 /* 640 */ 148, 263, 158, 173, 324, 264, 173, 71, 15, 132,
197 /* 650 */ 150, 267, 323, 161, 145, 256, 158, 173, 73, 158,
198 /* 660 */ 134, 170, 172, 198, 62, 173, 322, 333, 173, 60,
199 /* 670 */ 158, 262, 173, 66, 93, 266, 173, 195, 158, 173,
200 /* 680 */ 173, 158, 173, 187, 139, 158, 136, 173, 268, 158,
201 /* 690 */ 11, 173, 158, 158, 76, 158, 295, 185, 58, 340,
202 /* 700 */ 158, 173, 173, 56, 158, 272, 236, 36, 321, 54,
203 /* 710 */ 38, 383, 293, 157, 158, 158, 173, 127, 40, 273,
204 /* 720 */ 193, 173, 275, 278, 173, 173, 280, 173, 173, 158,
205 /* 730 */ 190, 173, 68, 52, 158, 173, 173, 158, 158, 138,
206 /* 740 */ 158, 158, 48, 283, 158, 13, 25, 88, 158, 158,
207 /* 750 */ 173, 173, 16, 248, 87, 86, 44, 46, 64, 297,
208 /* 760 */ 173, 294, 141, 158, 158, 296, 142, 288, 153, 289,
209 /* 770 */ 346, 173, 291, 158, 173, 173, 173, 12, 29, 75,
210 /* 780 */ 77, 144, 9, 235, 158, 117, 241, 158, 158, 158,
211 /* 790 */ 118, 231, 243, 296, 116, 14,
212 };
213 static PPCODETYPE pp_lookahead[] = {
214 /* 0 */ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
215 /* 10 */ 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
216 /* 20 */ 21, 22, 23, 1, 2, 3, 4, 5, 6, 7,
217 /* 30 */ 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
218 /* 40 */ 18, 19, 20, 21, 22, 23, 19, 20, 21, 22,
219 /* 50 */ 23, 25, 30, 25, 32, 9, 10, 11, 12, 13,
220 /* 60 */ 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
221 /* 70 */ 71, 45, 73, 45, 1, 2, 3, 4, 5, 6,
222 /* 80 */ 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
223 /* 90 */ 17, 18, 19, 20, 21, 22, 23, 1, 2, 3,
224 /* 100 */ 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
225 /* 110 */ 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
226 /* 120 */ 60, 61, 62, 63, 64, 45, 53, 54, 11, 12,
227 /* 130 */ 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
228 /* 140 */ 23, 45, 56, 1, 2, 3, 4, 5, 6, 7,
229 /* 150 */ 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
230 /* 160 */ 18, 19, 20, 21, 22, 23, 16, 17, 18, 19,
231 /* 170 */ 20, 21, 22, 23, 32, 88, 1, 2, 3, 4,
232 /* 180 */ 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
233 /* 190 */ 15, 16, 17, 18, 19, 20, 21, 22, 23, 1,
234 /* 200 */ 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
235 /* 210 */ 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
236 /* 220 */ 22, 23, 1, 2, 3, 4, 5, 6, 7, 8,
237 /* 230 */ 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
238 /* 240 */ 19, 20, 21, 22, 23, 17, 31, 72, 20, 119,
239 /* 250 */ 120, 23, 24, 51, 26, 127, 128, 96, 30, 44,
240 /* 260 */ 25, 100, 101, 102, 103, 25, 68, 98, 33, 34,
241 /* 270 */ 35, 36, 44, 38, 39, 28, 29, 80, 81, 82,
242 /* 280 */ 83, 84, 85, 86, 34, 116, 117, 37, 60, 61,
243 /* 290 */ 62, 63, 64, 65, 66, 67, 26, 69, 129, 59,
244 /* 300 */ 97, 98, 74, 75, 76, 77, 78, 17, 82, 112,
245 /* 310 */ 20, 41, 86, 23, 24, 118, 46, 30, 48, 116,
246 /* 320 */ 30, 13, 14, 15, 16, 17, 18, 19, 20, 21,
247 /* 330 */ 22, 23, 129, 0, 44, 45, 33, 34, 35, 36,
248 /* 340 */ 95, 38, 39, 99, 99, 21, 22, 23, 104, 104,
249 /* 350 */ 60, 61, 62, 63, 64, 65, 66, 67, 74, 69,
250 /* 360 */ 116, 116, 119, 120, 74, 75, 76, 77, 78, 3,
251 /* 370 */ 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
252 /* 380 */ 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
253 /* 390 */ 17, 58, 98, 20, 11, 12, 23, 24, 82, 31,
254 /* 400 */ 98, 107, 86, 30, 110, 22, 114, 115, 116, 82,
255 /* 410 */ 116, 99, 34, 86, 98, 37, 104, 44, 116, 70,
256 /* 420 */ 71, 34, 73, 129, 37, 98, 124, 30, 116, 32,
257 /* 430 */ 30, 129, 116, 60, 61, 62, 63, 64, 65, 66,
258 /* 440 */ 67, 30, 69, 116, 87, 129, 49, 74, 75, 76,
259 /* 450 */ 77, 78, 98, 126, 20, 44, 129, 23, 24, 132,
260 /* 460 */ 26, 101, 102, 103, 30, 25, 31, 27, 30, 94,
261 /* 470 */ 116, 82, 97, 98, 30, 86, 99, 55, 44, 44,
262 /* 480 */ 126, 104, 44, 129, 42, 131, 132, 98, 44, 119,
263 /* 490 */ 120, 116, 30, 116, 60, 61, 62, 63, 64, 65,
264 /* 500 */ 66, 67, 25, 69, 129, 116, 30, 98, 74, 75,
265 /* 510 */ 76, 77, 78, 17, 25, 126, 20, 98, 129, 23,
266 /* 520 */ 24, 132, 45, 52, 98, 116, 30, 25, 17, 110,
267 /* 530 */ 30, 104, 32, 107, 45, 116, 110, 23, 129, 23,
268 /* 540 */ 44, 30, 116, 116, 25, 115, 116, 45, 129, 43,
269 /* 550 */ 44, 98, 44, 90, 104, 129, 60, 61, 62, 63,
270 /* 560 */ 64, 65, 66, 67, 45, 69, 116, 119, 98, 116,
271 /* 570 */ 74, 75, 76, 77, 78, 122, 50, 20, 30, 98,
272 /* 580 */ 23, 24, 129, 30, 98, 98, 116, 30, 74, 30,
273 /* 590 */ 108, 0, 25, 111, 119, 30, 98, 116, 30, 129,
274 /* 600 */ 30, 44, 116, 116, 123, 124, 34, 121, 122, 125,
275 /* 610 */ 129, 98, 45, 34, 116, 129, 129, 60, 61, 62,
276 /* 620 */ 63, 64, 65, 66, 67, 98, 69, 129, 98, 116,
277 /* 630 */ 132, 74, 75, 76, 77, 78, 49, 30, 45, 98,
278 /* 640 */ 45, 43, 129, 116, 30, 44, 116, 98, 58, 45,
279 /* 650 */ 98, 25, 30, 130, 98, 25, 129, 116, 98, 129,
280 /* 660 */ 44, 98, 98, 34, 98, 116, 30, 0, 116, 98,
281 /* 670 */ 129, 45, 116, 98, 119, 45, 116, 34, 129, 116,
282 /* 680 */ 116, 129, 116, 98, 98, 129, 45, 116, 111, 129,
283 /* 690 */ 91, 116, 129, 129, 26, 129, 0, 28, 98, 0,
284 /* 700 */ 129, 116, 116, 98, 129, 87, 98, 98, 30, 98,
285 /* 710 */ 98, 0, 0, 98, 129, 129, 116, 98, 98, 113,
286 /* 720 */ 34, 116, 125, 47, 116, 116, 25, 116, 116, 129,
287 /* 730 */ 30, 116, 98, 98, 129, 116, 116, 129, 129, 44,
288 /* 740 */ 129, 129, 98, 3, 129, 57, 125, 119, 129, 129,
289 /* 750 */ 116, 116, 125, 98, 49, 30, 98, 98, 98, 0,
290 /* 760 */ 116, 0, 30, 129, 129, 0, 45, 87, 128, 113,
291 /* 770 */ 0, 116, 27, 129, 116, 116, 116, 92, 25, 44,
292 /* 780 */ 93, 44, 89, 45, 129, 106, 52, 129, 129, 129,
293 /* 790 */ 40, 44, 25, 133, 105, 46,
294 };
295 #define PP_SHIFT_USE_DFLT (-2)
296 static short pp_shift_ofst[] = {
297 /* 0 */ 270, 712, 761, 696, 765, 759, 526, 422, 86, 202,
298 /* 10 */ 590, 688, -2, 749, -2, 60, 240, 60, -2, -2,
299 /* 20 */ -2, -2, -2, -2, 60, -2, 471, 557, 753, 557,
300 /* 30 */ -2, 73, -2, -2, 557, 557, 324, 557, 324, 557,
301 /* 40 */ 27, 557, 27, 557, 27, 557, 117, 557, 117, 557,
302 /* 50 */ 150, 557, 150, 557, 150, 557, 46, 557, 46, 557,
303 /* 60 */ 46, 557, 46, 557, 46, 557, 46, 557, 308, 383,
304 /* 70 */ 557, 516, 557, 308, 735, 228, 247, 373, 440, 476,
305 /* 80 */ 235, -2, 476, -2, 397, 725, 705, 411, -2, 462,
306 /* 90 */ 28, -2, 462, -2, -2, -2, 587, 438, 462, 477,
307 /* 100 */ -2, -2, 444, 462, 489, -2, -2, -2, 368, 287,
308 /* 110 */ -2, 303, -2, -2, 476, 500, 750, -2, 557, 221,
309 /* 120 */ 557, 221, 514, -2, 284, -2, 557, 366, 434, 96,
310 /* 130 */ -2, 604, -2, 616, 668, 641, -2, 695, 557, 142,
311 /* 140 */ 732, 721, -2, 737, 557, 198, 553, 595, -2, 557,
312 /* 150 */ -1, 349, -2, -2, 557, 175, 557, 221, -2, 215,
313 /* 160 */ 669, 290, 221, 593, -2, 26, 496, -2, -2, 557,
314 /* 170 */ 516, 557, 516, -2, -2, -2, -2, -2, -2, -2,
315 /* 180 */ -2, -2, -2, -2, -2, -2, 557, 221, -2, 700,
316 /* 190 */ -2, -2, 686, 678, 643, 636, 250, 629, 622, 614,
317 /* 200 */ 378, 579, 570, 568, 387, 572, 565, 559, 548, -2,
318 /* 210 */ -2, 373, -2, -2, 435, 511, -2, 22, 400, -2,
319 /* 220 */ -2, -2, -2, -2, 502, -2, 80, -2, 557, 516,
320 /* 230 */ 747, 228, 519, -2, 738, -2, 324, -2, 557, 221,
321 /* 240 */ 734, 557, 767, 557, -2, 221, -2, 557, 221, 442,
322 /* 250 */ 476, 506, 508, 557, 567, 591, 557, -2, 221, -2,
323 /* 260 */ 607, 626, 598, 601, 557, 630, 667, 607, -2, -2,
324 /* 270 */ -2, 526, 333, 699, 60, 711, 476, 676, 476, 701,
325 /* 280 */ 476, -2, 740, 557, -2, 221, -2, 526, 333, 770,
326 /* 290 */ 745, 476, -2,
327 };
328 #define PP_REDUCE_USE_DFLT (-1)
329 static short pp_reduce_ofst[] = {
330 /* 0 */ 197, -1, -1, -1, -1, -1, 357, 87, 693, 463,
331 /* 10 */ 599, 685, -1, -1, -1, 627, -1, 484, -1, -1,
332 /* 20 */ -1, -1, -1, -1, 621, -1, -1, 486, -1, 453,
333 /* 30 */ -1, -1, -1, -1, 608, 609, -1, 612, -1, 620,
334 /* 40 */ -1, 470, -1, 658, -1, 659, -1, 644, -1, 513,
335 /* 50 */ -1, 635, -1, 611, -1, 605, -1, 600, -1, 571,
336 /* 60 */ -1, 566, -1, 660, -1, 575, -1, 634, -1, -1,
337 /* 70 */ 549, -1, 560, -1, -1, 389, 687, 375, -1, 245,
338 /* 80 */ 161, -1, 312, -1, -1, -1, -1, 628, -1, 243,
339 /* 90 */ -1, -1, 555, -1, -1, -1, -1, 475, 130, -1,
340 /* 100 */ -1, -1, 448, 370, -1, -1, -1, -1, -1, -1,
341 /* 110 */ -1, 360, -1, -1, 427, 689, 679, -1, 541, -1,
342 /* 120 */ 527, -1, -1, -1, -1, -1, 619, -1, 316, -1,
343 /* 130 */ -1, -1, -1, -1, 226, -1, -1, -1, 586, -1,
344 /* 140 */ -1, -1, -1, -1, 556, -1, -1, -1, -1, 552,
345 /* 150 */ 128, 640, -1, -1, 409, -1, 615, -1, -1, -1,
346 /* 160 */ 523, 354, -1, -1, -1, -1, 498, -1, -1, 563,
347 /* 170 */ -1, 564, -1, -1, -1, -1, -1, -1, -1, -1,
348 /* 180 */ -1, -1, -1, -1, -1, -1, 585, -1, -1, -1,
349 /* 190 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
350 /* 200 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
351 /* 210 */ -1, 203, -1, -1, -1, -1, -1, -1, -1, -1,
352 /* 220 */ -1, -1, -1, -1, -1, -1, -1, -1, 487, -1,
353 /* 230 */ -1, 327, -1, -1, -1, -1, -1, -1, 530, -1,
354 /* 240 */ -1, 481, -1, 302, -1, -1, -1, 655, -1, -1,
355 /* 250 */ 450, -1, -1, 426, -1, -1, 419, -1, -1, -1,
356 /* 260 */ 482, -1, -1, -1, 294, -1, -1, 577, -1, -1,
357 /* 270 */ -1, 618, 606, -1, 597, -1, 377, -1, 292, -1,
358 /* 280 */ 430, -1, -1, 169, -1, -1, -1, 680, 656, -1,
359 /* 290 */ -1, 244, -1,
360 };
361 static PPACTIONTYPE pp_default[] = {
362 /* 0 */ 454, 454, 454, 454, 454, 454, 362, 371, 376, 364,
363 /* 10 */ 382, 378, 298, 454, 377, 454, 379, 454, 380, 385,
364 /* 20 */ 386, 387, 388, 389, 454, 381, 454, 454, 363, 454,
365 /* 30 */ 365, 367, 368, 369, 454, 454, 390, 454, 392, 454,
366 /* 40 */ 393, 454, 394, 454, 395, 454, 396, 454, 397, 454,
367 /* 50 */ 398, 454, 399, 454, 400, 454, 401, 454, 402, 454,
368 /* 60 */ 403, 454, 404, 454, 405, 454, 406, 454, 407, 454,
369 /* 70 */ 454, 408, 454, 409, 454, 454, 302, 454, 454, 454,
370 /* 80 */ 313, 299, 454, 310, 350, 454, 348, 454, 351, 454,
371 /* 90 */ 454, 352, 454, 357, 359, 358, 349, 454, 454, 454,
372 /* 100 */ 353, 354, 454, 454, 454, 355, 356, 360, 453, 454,
373 /* 110 */ 452, 312, 314, 316, 454, 320, 331, 317, 454, 330,
374 /* 120 */ 454, 417, 454, 435, 454, 436, 454, 437, 454, 454,
375 /* 130 */ 440, 454, 413, 454, 454, 454, 416, 454, 454, 454,
376 /* 140 */ 454, 454, 418, 454, 454, 454, 454, 454, 419, 454,
377 /* 150 */ 454, 454, 420, 421, 454, 454, 454, 423, 425, 453,
378 /* 160 */ 428, 454, 434, 454, 426, 454, 454, 431, 433, 454,
379 /* 170 */ 438, 454, 439, 441, 442, 443, 444, 445, 446, 447,
380 /* 180 */ 448, 449, 450, 451, 432, 427, 454, 424, 422, 454,
381 /* 190 */ 318, 319, 454, 454, 454, 454, 454, 454, 454, 454,
382 /* 200 */ 454, 454, 454, 454, 454, 454, 454, 454, 454, 315,
383 /* 210 */ 311, 454, 303, 305, 453, 454, 306, 309, 454, 307,
384 /* 220 */ 308, 304, 300, 301, 454, 411, 454, 414, 454, 410,
385 /* 230 */ 454, 454, 454, 412, 454, 415, 391, 366, 454, 375,
386 /* 240 */ 454, 454, 370, 454, 372, 374, 373, 454, 361, 454,
387 /* 250 */ 454, 454, 454, 454, 454, 454, 454, 334, 336, 335,
388 /* 260 */ 454, 454, 454, 454, 454, 454, 454, 454, 337, 339,
389 /* 270 */ 338, 362, 454, 454, 454, 454, 454, 454, 454, 341,
390 /* 280 */ 454, 342, 454, 454, 344, 345, 343, 362, 454, 454,
391 /* 290 */ 454, 454, 347,
392 };
393 #define PP_SZ_ACTTAB (sizeof(pp_action)/sizeof(pp_action[0]))
394
395 /* The next table maps tokens into fallback tokens. If a construct
396 ** like the following:
397 **
398 ** %fallback ID X Y Z.
399 **
400 ** appears in the grammer, then ID becomes a fallback token for X, Y,
401 ** and Z. Whenever one of the tokens X, Y, or Z is input to the parser
402 ** but it does not parse, the type of the token is changed to ID and
403 ** the parse is retried before an error is thrown.
404 */
405 #ifdef PPFALLBACK
406 static const PPCODETYPE ppFallback[] = {
407 };
408 #endif /* PPFALLBACK */
409
410 /* The following structure represents a single element of the
411 ** parser's stack. Information stored includes:
412 **
413 ** + The state number for the parser at this level of the stack.
414 **
415 ** + The value of the token stored at this level of the stack.
416 ** (In other words, the "major" token.)
417 **
418 ** + The semantic value stored at this level of the stack. This is
419 ** the information used by the action routines in the grammar.
420 ** It is sometimes called the "minor" token.
421 */
422 struct ppStackEntry {
423 int stateno; /* The state-number */
424 int major; /* The major token value. This is the code
425 ** number for the token at this stack level */
426 PPMINORTYPE minor; /* The user-supplied minor token value. This
427 ** is the value of the token */
428 };
429 typedef struct ppStackEntry ppStackEntry;
430
431 /* The state of the parser is completely contained in an instance of
432 ** the following structure */
433 struct ppParser {
434 int ppidx; /* Index of top element in stack */
435 int pperrcnt; /* Shifts left before out of the error */
436 phql_ARG_SDECL /* A place to hold %extra_argument */
437 ppStackEntry ppstack[PPSTACKDEPTH]; /* The parser's stack */
438 };
439 typedef struct ppParser ppParser;
440
441 #ifndef NDEBUG
442 #include <stdio.h>
443 static FILE *ppTraceFILE = 0;
444 static char *ppTracePrompt = 0;
445 #endif /* NDEBUG */
446
447 #ifndef NDEBUG
448 /*
449 ** Turn parser tracing on by giving a stream to which to write the trace
450 ** and a prompt to preface each trace message. Tracing is turned off
451 ** by making either argument NULL
452 **
453 ** Inputs:
454 ** <ul>
455 ** <li> A FILE* to which trace output should be written.
456 ** If NULL, then tracing is turned off.
457 ** <li> A prefix string written at the beginning of every
458 ** line of trace output. If NULL, then tracing is
459 ** turned off.
460 ** </ul>
461 **
462 ** Outputs:
463 ** None.
464 */
phql_Trace(FILE * TraceFILE,char * zTracePrompt)465 void phql_Trace(FILE *TraceFILE, char *zTracePrompt){
466 ppTraceFILE = TraceFILE;
467 ppTracePrompt = zTracePrompt;
468 if( ppTraceFILE==0 ) ppTracePrompt = 0;
469 else if( ppTracePrompt==0 ) ppTraceFILE = 0;
470 }
471 #endif /* NDEBUG */
472
473 #ifndef NDEBUG
474 /* For tracing shifts, the names of all terminals and nonterminals
475 ** are required. The following table supplies these names */
476 static const char *ppTokenName[] = {
477 "$", "AGAINST", "BETWEEN", "EQUALS",
478 "NOTEQUALS", "LESS", "GREATER", "GREATEREQUAL",
479 "LESSEQUAL", "AND", "OR", "LIKE",
480 "ILIKE", "BITWISE_AND", "BITWISE_OR", "BITWISE_XOR",
481 "DIVIDE", "TIMES", "MOD", "PLUS",
482 "MINUS", "IS", "IN", "NOT",
483 "BITWISE_NOT", "COMMA", "SELECT", "FROM",
484 "DISTINCT", "ALL", "IDENTIFIER", "DOT",
485 "AS", "INNER", "JOIN", "CROSS",
486 "LEFT", "OUTER", "RIGHT", "FULL",
487 "ON", "INSERT", "INTO", "VALUES",
488 "PARENTHESES_OPEN", "PARENTHESES_CLOSE", "UPDATE", "SET",
489 "DELETE", "WITH", "WHERE", "ORDER",
490 "BY", "ASC", "DESC", "GROUP",
491 "HAVING", "FOR", "LIMIT", "OFFSET",
492 "INTEGER", "HINTEGER", "NPLACEHOLDER", "SPLACEHOLDER",
493 "BPLACEHOLDER", "EXISTS", "CAST", "CONVERT",
494 "USING", "CASE", "END", "WHEN",
495 "THEN", "ELSE", "NULL", "STRING",
496 "DOUBLE", "TRUE", "FALSE", "error",
497 "program", "query_language", "select_statement", "insert_statement",
498 "update_statement", "delete_statement", "select_clause", "where_clause",
499 "group_clause", "having_clause", "order_clause", "select_limit_clause",
500 "for_update_clause", "distinct_all", "column_list", "associated_name_list",
501 "join_list_or_null", "column_item", "expr", "associated_name",
502 "join_list", "join_item", "join_clause", "join_type",
503 "aliased_or_qualified_name", "join_associated_name", "join_conditions", "values_list",
504 "field_list", "value_list", "value_item", "field_item",
505 "update_clause", "limit_clause", "update_item_list", "update_item",
506 "qualified_name", "new_value", "delete_clause", "with_item",
507 "with_list", "order_list", "order_item", "group_list",
508 "group_item", "integer_or_placeholder", "argument_list", "when_clauses",
509 "when_clause", "function_call", "distinct_or_null", "argument_list_or_null",
510 "argument_item",
511 };
512 #endif /* NDEBUG */
513
514 #ifndef NDEBUG
515 /* For tracing reduce actions, the names of all rules are required.
516 */
517 static const char *ppRuleName[] = {
518 /* 0 */ "program ::= query_language",
519 /* 1 */ "query_language ::= select_statement",
520 /* 2 */ "query_language ::= insert_statement",
521 /* 3 */ "query_language ::= update_statement",
522 /* 4 */ "query_language ::= delete_statement",
523 /* 5 */ "select_statement ::= select_clause where_clause group_clause having_clause order_clause select_limit_clause for_update_clause",
524 /* 6 */ "select_clause ::= SELECT distinct_all column_list FROM associated_name_list join_list_or_null",
525 /* 7 */ "distinct_all ::= DISTINCT",
526 /* 8 */ "distinct_all ::= ALL",
527 /* 9 */ "distinct_all ::=",
528 /* 10 */ "column_list ::= column_list COMMA column_item",
529 /* 11 */ "column_list ::= column_item",
530 /* 12 */ "column_item ::= TIMES",
531 /* 13 */ "column_item ::= IDENTIFIER DOT TIMES",
532 /* 14 */ "column_item ::= expr AS IDENTIFIER",
533 /* 15 */ "column_item ::= expr IDENTIFIER",
534 /* 16 */ "column_item ::= expr",
535 /* 17 */ "associated_name_list ::= associated_name_list COMMA associated_name",
536 /* 18 */ "associated_name_list ::= associated_name",
537 /* 19 */ "join_list_or_null ::= join_list",
538 /* 20 */ "join_list_or_null ::=",
539 /* 21 */ "join_list ::= join_list join_item",
540 /* 22 */ "join_list ::= join_item",
541 /* 23 */ "join_item ::= join_clause",
542 /* 24 */ "join_clause ::= join_type aliased_or_qualified_name join_associated_name join_conditions",
543 /* 25 */ "join_associated_name ::= AS IDENTIFIER",
544 /* 26 */ "join_associated_name ::= IDENTIFIER",
545 /* 27 */ "join_associated_name ::=",
546 /* 28 */ "join_type ::= INNER JOIN",
547 /* 29 */ "join_type ::= CROSS JOIN",
548 /* 30 */ "join_type ::= LEFT OUTER JOIN",
549 /* 31 */ "join_type ::= LEFT JOIN",
550 /* 32 */ "join_type ::= RIGHT OUTER JOIN",
551 /* 33 */ "join_type ::= RIGHT JOIN",
552 /* 34 */ "join_type ::= FULL OUTER JOIN",
553 /* 35 */ "join_type ::= FULL JOIN",
554 /* 36 */ "join_type ::= JOIN",
555 /* 37 */ "join_conditions ::= ON expr",
556 /* 38 */ "join_conditions ::=",
557 /* 39 */ "insert_statement ::= INSERT INTO aliased_or_qualified_name VALUES PARENTHESES_OPEN values_list PARENTHESES_CLOSE",
558 /* 40 */ "insert_statement ::= INSERT INTO aliased_or_qualified_name PARENTHESES_OPEN field_list PARENTHESES_CLOSE VALUES PARENTHESES_OPEN values_list PARENTHESES_CLOSE",
559 /* 41 */ "values_list ::= values_list COMMA value_item",
560 /* 42 */ "values_list ::= value_item",
561 /* 43 */ "value_item ::= expr",
562 /* 44 */ "field_list ::= field_list COMMA field_item",
563 /* 45 */ "field_list ::= field_item",
564 /* 46 */ "field_item ::= IDENTIFIER",
565 /* 47 */ "update_statement ::= update_clause where_clause limit_clause",
566 /* 48 */ "update_clause ::= UPDATE associated_name SET update_item_list",
567 /* 49 */ "update_item_list ::= update_item_list COMMA update_item",
568 /* 50 */ "update_item_list ::= update_item",
569 /* 51 */ "update_item ::= qualified_name EQUALS new_value",
570 /* 52 */ "new_value ::= expr",
571 /* 53 */ "delete_statement ::= delete_clause where_clause limit_clause",
572 /* 54 */ "delete_clause ::= DELETE FROM associated_name",
573 /* 55 */ "associated_name ::= aliased_or_qualified_name AS IDENTIFIER",
574 /* 56 */ "associated_name ::= aliased_or_qualified_name IDENTIFIER",
575 /* 57 */ "associated_name ::= aliased_or_qualified_name",
576 /* 58 */ "associated_name ::= aliased_or_qualified_name AS IDENTIFIER WITH with_item",
577 /* 59 */ "associated_name ::= aliased_or_qualified_name AS IDENTIFIER WITH PARENTHESES_OPEN with_list PARENTHESES_CLOSE",
578 /* 60 */ "associated_name ::= aliased_or_qualified_name IDENTIFIER WITH PARENTHESES_OPEN with_list PARENTHESES_CLOSE",
579 /* 61 */ "associated_name ::= aliased_or_qualified_name IDENTIFIER WITH with_item",
580 /* 62 */ "associated_name ::= aliased_or_qualified_name WITH PARENTHESES_OPEN with_list PARENTHESES_CLOSE",
581 /* 63 */ "associated_name ::= aliased_or_qualified_name WITH with_item",
582 /* 64 */ "with_list ::= with_list COMMA with_item",
583 /* 65 */ "with_list ::= with_item",
584 /* 66 */ "with_item ::= IDENTIFIER",
585 /* 67 */ "aliased_or_qualified_name ::= qualified_name",
586 /* 68 */ "where_clause ::= WHERE expr",
587 /* 69 */ "where_clause ::=",
588 /* 70 */ "order_clause ::= ORDER BY order_list",
589 /* 71 */ "order_clause ::=",
590 /* 72 */ "order_list ::= order_list COMMA order_item",
591 /* 73 */ "order_list ::= order_item",
592 /* 74 */ "order_item ::= expr",
593 /* 75 */ "order_item ::= expr ASC",
594 /* 76 */ "order_item ::= expr DESC",
595 /* 77 */ "group_clause ::= GROUP BY group_list",
596 /* 78 */ "group_clause ::=",
597 /* 79 */ "group_list ::= group_list COMMA group_item",
598 /* 80 */ "group_list ::= group_item",
599 /* 81 */ "group_item ::= expr",
600 /* 82 */ "having_clause ::= HAVING expr",
601 /* 83 */ "having_clause ::=",
602 /* 84 */ "for_update_clause ::= FOR UPDATE",
603 /* 85 */ "for_update_clause ::=",
604 /* 86 */ "select_limit_clause ::= LIMIT integer_or_placeholder",
605 /* 87 */ "select_limit_clause ::= LIMIT integer_or_placeholder COMMA integer_or_placeholder",
606 /* 88 */ "select_limit_clause ::= LIMIT integer_or_placeholder OFFSET integer_or_placeholder",
607 /* 89 */ "select_limit_clause ::=",
608 /* 90 */ "limit_clause ::= LIMIT integer_or_placeholder",
609 /* 91 */ "limit_clause ::=",
610 /* 92 */ "integer_or_placeholder ::= INTEGER",
611 /* 93 */ "integer_or_placeholder ::= HINTEGER",
612 /* 94 */ "integer_or_placeholder ::= NPLACEHOLDER",
613 /* 95 */ "integer_or_placeholder ::= SPLACEHOLDER",
614 /* 96 */ "integer_or_placeholder ::= BPLACEHOLDER",
615 /* 97 */ "expr ::= MINUS expr",
616 /* 98 */ "expr ::= expr MINUS expr",
617 /* 99 */ "expr ::= expr PLUS expr",
618 /* 100 */ "expr ::= expr TIMES expr",
619 /* 101 */ "expr ::= expr DIVIDE expr",
620 /* 102 */ "expr ::= expr MOD expr",
621 /* 103 */ "expr ::= expr AND expr",
622 /* 104 */ "expr ::= expr OR expr",
623 /* 105 */ "expr ::= expr BITWISE_AND expr",
624 /* 106 */ "expr ::= expr BITWISE_OR expr",
625 /* 107 */ "expr ::= expr BITWISE_XOR expr",
626 /* 108 */ "expr ::= expr EQUALS expr",
627 /* 109 */ "expr ::= expr NOTEQUALS expr",
628 /* 110 */ "expr ::= expr LESS expr",
629 /* 111 */ "expr ::= expr GREATER expr",
630 /* 112 */ "expr ::= expr GREATEREQUAL expr",
631 /* 113 */ "expr ::= expr LESSEQUAL expr",
632 /* 114 */ "expr ::= expr LIKE expr",
633 /* 115 */ "expr ::= expr NOT LIKE expr",
634 /* 116 */ "expr ::= expr ILIKE expr",
635 /* 117 */ "expr ::= expr NOT ILIKE expr",
636 /* 118 */ "expr ::= expr IN PARENTHESES_OPEN argument_list PARENTHESES_CLOSE",
637 /* 119 */ "expr ::= expr NOT IN PARENTHESES_OPEN argument_list PARENTHESES_CLOSE",
638 /* 120 */ "expr ::= PARENTHESES_OPEN select_statement PARENTHESES_CLOSE",
639 /* 121 */ "expr ::= expr IN PARENTHESES_OPEN select_statement PARENTHESES_CLOSE",
640 /* 122 */ "expr ::= expr NOT IN PARENTHESES_OPEN select_statement PARENTHESES_CLOSE",
641 /* 123 */ "expr ::= EXISTS PARENTHESES_OPEN select_statement PARENTHESES_CLOSE",
642 /* 124 */ "expr ::= expr AGAINST expr",
643 /* 125 */ "expr ::= CAST PARENTHESES_OPEN expr AS IDENTIFIER PARENTHESES_CLOSE",
644 /* 126 */ "expr ::= CONVERT PARENTHESES_OPEN expr USING IDENTIFIER PARENTHESES_CLOSE",
645 /* 127 */ "expr ::= CASE expr when_clauses END",
646 /* 128 */ "when_clauses ::= when_clauses when_clause",
647 /* 129 */ "when_clauses ::= when_clause",
648 /* 130 */ "when_clause ::= WHEN expr THEN expr",
649 /* 131 */ "when_clause ::= ELSE expr",
650 /* 132 */ "expr ::= function_call",
651 /* 133 */ "function_call ::= IDENTIFIER PARENTHESES_OPEN distinct_or_null argument_list_or_null PARENTHESES_CLOSE",
652 /* 134 */ "distinct_or_null ::= DISTINCT",
653 /* 135 */ "distinct_or_null ::=",
654 /* 136 */ "argument_list_or_null ::= argument_list",
655 /* 137 */ "argument_list_or_null ::=",
656 /* 138 */ "argument_list ::= argument_list COMMA argument_item",
657 /* 139 */ "argument_list ::= argument_item",
658 /* 140 */ "argument_item ::= TIMES",
659 /* 141 */ "argument_item ::= expr",
660 /* 142 */ "expr ::= expr IS NULL",
661 /* 143 */ "expr ::= expr IS NOT NULL",
662 /* 144 */ "expr ::= expr BETWEEN expr",
663 /* 145 */ "expr ::= NOT expr",
664 /* 146 */ "expr ::= BITWISE_NOT expr",
665 /* 147 */ "expr ::= PARENTHESES_OPEN expr PARENTHESES_CLOSE",
666 /* 148 */ "expr ::= qualified_name",
667 /* 149 */ "expr ::= INTEGER",
668 /* 150 */ "expr ::= HINTEGER",
669 /* 151 */ "expr ::= STRING",
670 /* 152 */ "expr ::= DOUBLE",
671 /* 153 */ "expr ::= NULL",
672 /* 154 */ "expr ::= TRUE",
673 /* 155 */ "expr ::= FALSE",
674 /* 156 */ "expr ::= NPLACEHOLDER",
675 /* 157 */ "expr ::= SPLACEHOLDER",
676 /* 158 */ "expr ::= BPLACEHOLDER",
677 /* 159 */ "qualified_name ::= IDENTIFIER DOT IDENTIFIER",
678 /* 160 */ "qualified_name ::= IDENTIFIER",
679 };
680 #endif /* NDEBUG */
681
682 /*
683 ** This function returns the symbolic name associated with a token
684 ** value.
685 */
phql_TokenName(int tokenType)686 const char *phql_TokenName(int tokenType){
687 #ifndef NDEBUG
688 if( tokenType>0 && tokenType<(sizeof(ppTokenName)/sizeof(ppTokenName[0])) ){
689 return ppTokenName[tokenType];
690 }else{
691 return "Unknown";
692 }
693 #else
694 return "";
695 #endif
696 }
697
698 /*
699 ** This function allocates a new parser.
700 ** The only argument is a pointer to a function which works like
701 ** malloc.
702 **
703 ** Inputs:
704 ** A pointer to the function used to allocate memory.
705 **
706 ** Outputs:
707 ** A pointer to a parser. This pointer is used in subsequent calls
708 ** to phql_ and phql_Free.
709 */
phql_Alloc(void * (* mallocProc)(size_t))710 void *phql_Alloc(void *(*mallocProc)(size_t)){
711 ppParser *pParser;
712 pParser = (ppParser*)(*mallocProc)( (size_t)sizeof(ppParser) );
713 if( pParser ){
714 pParser->ppidx = -1;
715 }
716 return pParser;
717 }
718
719 /* The following function deletes the value associated with a
720 ** symbol. The symbol can be either a terminal or nonterminal.
721 ** "ppmajor" is the symbol code, and "pppminor" is a pointer to
722 ** the value.
723 */
pp_destructor(PPCODETYPE ppmajor,PPMINORTYPE * pppminor)724 static void pp_destructor(PPCODETYPE ppmajor, PPMINORTYPE *pppminor){
725 switch( ppmajor ){
726 /* Here is inserted the actions which take place when a
727 ** terminal or non-terminal is destroyed. This can happen
728 ** when the symbol is popped from the stack during a
729 ** reduce or during error processing or when a parser is
730 ** being destroyed before it is finished parsing.
731 **
732 ** Note: during a reduce, the only symbols destroyed are those
733 ** which appear on the RHS of the rule, but which are not used
734 ** inside the C code.
735 */
736 case 1:
737 case 2:
738 case 3:
739 case 4:
740 case 5:
741 case 6:
742 case 7:
743 case 8:
744 case 9:
745 case 10:
746 case 11:
747 case 12:
748 case 13:
749 case 14:
750 case 15:
751 case 16:
752 case 17:
753 case 18:
754 case 19:
755 case 20:
756 case 21:
757 case 22:
758 case 23:
759 case 24:
760 case 25:
761 case 26:
762 case 27:
763 case 28:
764 case 29:
765 case 30:
766 case 31:
767 case 32:
768 case 33:
769 case 34:
770 case 35:
771 case 36:
772 case 37:
773 case 38:
774 case 39:
775 case 40:
776 case 41:
777 case 42:
778 case 43:
779 case 44:
780 case 45:
781 case 46:
782 case 47:
783 case 48:
784 case 49:
785 case 50:
786 case 51:
787 case 52:
788 case 53:
789 case 54:
790 case 55:
791 case 56:
792 case 57:
793 case 58:
794 case 59:
795 case 60:
796 case 61:
797 case 62:
798 case 63:
799 case 64:
800 case 65:
801 case 66:
802 case 67:
803 case 68:
804 case 69:
805 case 70:
806 case 71:
807 case 72:
808 case 73:
809 case 74:
810 case 75:
811 case 76:
812 case 77:
813 case 78:
814 // 110 "parser.php5.lemon"
815 {
816 if ((pppminor->pp0)) {
817 if ((pppminor->pp0)->free_flag) {
818 efree((pppminor->pp0)->token);
819 }
820 efree((pppminor->pp0));
821 }
822 }
823 // 822 "parser.php5.c"
824 break;
825 case 81:
826 case 82:
827 case 83:
828 case 84:
829 case 85:
830 case 86:
831 case 88:
832 case 94:
833 case 95:
834 case 97:
835 case 98:
836 case 99:
837 case 100:
838 case 101:
839 case 102:
840 case 103:
841 case 104:
842 case 108:
843 case 109:
844 case 111:
845 case 112:
846 case 114:
847 case 115:
848 case 118:
849 case 119:
850 case 120:
851 case 121:
852 case 122:
853 case 123:
854 // 123 "parser.php5.lemon"
855 {
856 zval_ptr_dtor(&(pppminor->pp162));
857 }
858 // 857 "parser.php5.c"
859 break;
860 case 87:
861 case 89:
862 case 90:
863 case 91:
864 case 92:
865 case 93:
866 case 105:
867 case 106:
868 case 113:
869 case 130:
870 case 131:
871 // 505 "parser.php5.lemon"
872 {
873 zephir_safe_zval_ptr_dtor((pppminor->pp162));
874 }
875 // 874 "parser.php5.c"
876 break;
877 case 116:
878 case 124:
879 case 126:
880 case 129:
881 case 132:
882 // 940 "parser.php5.lemon"
883 {
884 zval_ptr_dtor(&(pppminor->pp162));
885 }
886 // 885 "parser.php5.c"
887 break;
888 default: break; /* If no destructor action specified: do nothing */
889 }
890 }
891
892 /*
893 ** Pop the parser's stack once.
894 **
895 ** If there is a destructor routine associated with the token which
896 ** is popped from the stack, then call it.
897 **
898 ** Return the major token number for the symbol popped.
899 */
pp_pop_parser_stack(ppParser * pParser)900 static int pp_pop_parser_stack(ppParser *pParser){
901 PPCODETYPE ppmajor;
902 ppStackEntry *pptos = &pParser->ppstack[pParser->ppidx];
903
904 if( pParser->ppidx<0 ) return 0;
905 #ifndef NDEBUG
906 if( ppTraceFILE && pParser->ppidx>=0 ){
907 fprintf(ppTraceFILE,"%sPopping %s\n",
908 ppTracePrompt,
909 ppTokenName[pptos->major]);
910 }
911 #endif
912 ppmajor = pptos->major;
913 pp_destructor( ppmajor, &pptos->minor);
914 pParser->ppidx--;
915 return ppmajor;
916 }
917
918 /*
919 ** Deallocate and destroy a parser. Destructors are all called for
920 ** all stack elements before shutting the parser down.
921 **
922 ** Inputs:
923 ** <ul>
924 ** <li> A pointer to the parser. This should be a pointer
925 ** obtained from phql_Alloc.
926 ** <li> A pointer to a function used to reclaim memory obtained
927 ** from malloc.
928 ** </ul>
929 */
phql_Free(void * p,void (* freeProc)(void *))930 void phql_Free(
931 void *p, /* The parser to be deleted */
932 void (*freeProc)(void*) /* Function used to reclaim memory */
933 ){
934 ppParser *pParser = (ppParser*)p;
935 if( pParser==0 ) return;
936 while( pParser->ppidx>=0 ) pp_pop_parser_stack(pParser);
937 (*freeProc)((void*)pParser);
938 }
939
940 /*
941 ** Find the appropriate action for a parser given the terminal
942 ** look-ahead token iLookAhead.
943 **
944 ** If the look-ahead token is PPNOCODE, then check to see if the action is
945 ** independent of the look-ahead. If it is, return the action, otherwise
946 ** return PP_NO_ACTION.
947 */
pp_find_shift_action(ppParser * pParser,int iLookAhead)948 static int pp_find_shift_action(
949 ppParser *pParser, /* The parser */
950 int iLookAhead /* The look-ahead token */
951 ){
952 int i;
953 int stateno = pParser->ppstack[pParser->ppidx].stateno;
954
955 /* if( pParser->ppidx<0 ) return PP_NO_ACTION; */
956 i = pp_shift_ofst[stateno];
957 if( i==PP_SHIFT_USE_DFLT ){
958 return pp_default[stateno];
959 }
960 if( iLookAhead==PPNOCODE ){
961 return PP_NO_ACTION;
962 }
963 i += iLookAhead;
964 if( i<0 || i>=PP_SZ_ACTTAB || pp_lookahead[i]!=iLookAhead ){
965 #ifdef PPFALLBACK
966 int iFallback; /* Fallback token */
967 if( iLookAhead<sizeof(ppFallback)/sizeof(ppFallback[0])
968 && (iFallback = ppFallback[iLookAhead])!=0 ){
969 #ifndef NDEBUG
970 if( ppTraceFILE ){
971 fprintf(ppTraceFILE, "%sFALLBACK %s => %s\n",
972 ppTracePrompt, ppTokenName[iLookAhead], ppTokenName[iFallback]);
973 }
974 #endif
975 return pp_find_shift_action(pParser, iFallback);
976 }
977 #endif
978 return pp_default[stateno];
979 }else{
980 return pp_action[i];
981 }
982 }
983
984 /*
985 ** Find the appropriate action for a parser given the non-terminal
986 ** look-ahead token iLookAhead.
987 **
988 ** If the look-ahead token is PPNOCODE, then check to see if the action is
989 ** independent of the look-ahead. If it is, return the action, otherwise
990 ** return PP_NO_ACTION.
991 */
pp_find_reduce_action(ppParser * pParser,int iLookAhead)992 static int pp_find_reduce_action(
993 ppParser *pParser, /* The parser */
994 int iLookAhead /* The look-ahead token */
995 ){
996 int i;
997 int stateno = pParser->ppstack[pParser->ppidx].stateno;
998
999 i = pp_reduce_ofst[stateno];
1000 if( i==PP_REDUCE_USE_DFLT ){
1001 return pp_default[stateno];
1002 }
1003 if( iLookAhead==PPNOCODE ){
1004 return PP_NO_ACTION;
1005 }
1006 i += iLookAhead;
1007 if( i<0 || i>=PP_SZ_ACTTAB || pp_lookahead[i]!=iLookAhead ){
1008 return pp_default[stateno];
1009 }else{
1010 return pp_action[i];
1011 }
1012 }
1013
1014 /*
1015 ** Perform a shift action.
1016 */
pp_shift(ppParser * pppParser,int ppNewState,int ppMajor,PPMINORTYPE * pppMinor)1017 static void pp_shift(
1018 ppParser *pppParser, /* The parser to be shifted */
1019 int ppNewState, /* The new state to shift in */
1020 int ppMajor, /* The major token to shift in */
1021 PPMINORTYPE *pppMinor /* Pointer ot the minor token to shift in */
1022 ){
1023 ppStackEntry *pptos;
1024 pppParser->ppidx++;
1025 if( pppParser->ppidx>=PPSTACKDEPTH ){
1026 phql_ARG_FETCH;
1027 pppParser->ppidx--;
1028 #ifndef NDEBUG
1029 if( ppTraceFILE ){
1030 fprintf(ppTraceFILE,"%sStack Overflow!\n",ppTracePrompt);
1031 }
1032 #endif
1033 while( pppParser->ppidx>=0 ) pp_pop_parser_stack(pppParser);
1034 /* Here code is inserted which will execute if the parser
1035 ** stack every overflows */
1036 phql_ARG_STORE; /* Suppress warning about unused %extra_argument var */
1037 return;
1038 }
1039 pptos = &pppParser->ppstack[pppParser->ppidx];
1040 pptos->stateno = ppNewState;
1041 pptos->major = ppMajor;
1042 pptos->minor = *pppMinor;
1043 #ifndef NDEBUG
1044 if( ppTraceFILE && pppParser->ppidx>0 ){
1045 int i;
1046 fprintf(ppTraceFILE,"%sShift %d\n",ppTracePrompt,ppNewState);
1047 fprintf(ppTraceFILE,"%sStack:",ppTracePrompt);
1048 for(i=1; i<=pppParser->ppidx; i++)
1049 fprintf(ppTraceFILE," %s",ppTokenName[pppParser->ppstack[i].major]);
1050 fprintf(ppTraceFILE,"\n");
1051 }
1052 #endif
1053 }
1054
1055 /* The following table contains information about every rule that
1056 ** is used during the reduce.
1057 */
1058 static struct {
1059 PPCODETYPE lhs; /* Symbol on the left-hand side of the rule */
1060 unsigned char nrhs; /* Number of right-hand side symbols in the rule */
1061 } ppRuleInfo[] = {
1062 { 80, 1 },
1063 { 81, 1 },
1064 { 81, 1 },
1065 { 81, 1 },
1066 { 81, 1 },
1067 { 82, 7 },
1068 { 86, 6 },
1069 { 93, 1 },
1070 { 93, 1 },
1071 { 93, 0 },
1072 { 94, 3 },
1073 { 94, 1 },
1074 { 97, 1 },
1075 { 97, 3 },
1076 { 97, 3 },
1077 { 97, 2 },
1078 { 97, 1 },
1079 { 95, 3 },
1080 { 95, 1 },
1081 { 96, 1 },
1082 { 96, 0 },
1083 { 100, 2 },
1084 { 100, 1 },
1085 { 101, 1 },
1086 { 102, 4 },
1087 { 105, 2 },
1088 { 105, 1 },
1089 { 105, 0 },
1090 { 103, 2 },
1091 { 103, 2 },
1092 { 103, 3 },
1093 { 103, 2 },
1094 { 103, 3 },
1095 { 103, 2 },
1096 { 103, 3 },
1097 { 103, 2 },
1098 { 103, 1 },
1099 { 106, 2 },
1100 { 106, 0 },
1101 { 83, 7 },
1102 { 83, 10 },
1103 { 107, 3 },
1104 { 107, 1 },
1105 { 110, 1 },
1106 { 108, 3 },
1107 { 108, 1 },
1108 { 111, 1 },
1109 { 84, 3 },
1110 { 112, 4 },
1111 { 114, 3 },
1112 { 114, 1 },
1113 { 115, 3 },
1114 { 117, 1 },
1115 { 85, 3 },
1116 { 118, 3 },
1117 { 99, 3 },
1118 { 99, 2 },
1119 { 99, 1 },
1120 { 99, 5 },
1121 { 99, 7 },
1122 { 99, 6 },
1123 { 99, 4 },
1124 { 99, 5 },
1125 { 99, 3 },
1126 { 120, 3 },
1127 { 120, 1 },
1128 { 119, 1 },
1129 { 104, 1 },
1130 { 87, 2 },
1131 { 87, 0 },
1132 { 90, 3 },
1133 { 90, 0 },
1134 { 121, 3 },
1135 { 121, 1 },
1136 { 122, 1 },
1137 { 122, 2 },
1138 { 122, 2 },
1139 { 88, 3 },
1140 { 88, 0 },
1141 { 123, 3 },
1142 { 123, 1 },
1143 { 124, 1 },
1144 { 89, 2 },
1145 { 89, 0 },
1146 { 92, 2 },
1147 { 92, 0 },
1148 { 91, 2 },
1149 { 91, 4 },
1150 { 91, 4 },
1151 { 91, 0 },
1152 { 113, 2 },
1153 { 113, 0 },
1154 { 125, 1 },
1155 { 125, 1 },
1156 { 125, 1 },
1157 { 125, 1 },
1158 { 125, 1 },
1159 { 98, 2 },
1160 { 98, 3 },
1161 { 98, 3 },
1162 { 98, 3 },
1163 { 98, 3 },
1164 { 98, 3 },
1165 { 98, 3 },
1166 { 98, 3 },
1167 { 98, 3 },
1168 { 98, 3 },
1169 { 98, 3 },
1170 { 98, 3 },
1171 { 98, 3 },
1172 { 98, 3 },
1173 { 98, 3 },
1174 { 98, 3 },
1175 { 98, 3 },
1176 { 98, 3 },
1177 { 98, 4 },
1178 { 98, 3 },
1179 { 98, 4 },
1180 { 98, 5 },
1181 { 98, 6 },
1182 { 98, 3 },
1183 { 98, 5 },
1184 { 98, 6 },
1185 { 98, 4 },
1186 { 98, 3 },
1187 { 98, 6 },
1188 { 98, 6 },
1189 { 98, 4 },
1190 { 127, 2 },
1191 { 127, 1 },
1192 { 128, 4 },
1193 { 128, 2 },
1194 { 98, 1 },
1195 { 129, 5 },
1196 { 130, 1 },
1197 { 130, 0 },
1198 { 131, 1 },
1199 { 131, 0 },
1200 { 126, 3 },
1201 { 126, 1 },
1202 { 132, 1 },
1203 { 132, 1 },
1204 { 98, 3 },
1205 { 98, 4 },
1206 { 98, 3 },
1207 { 98, 2 },
1208 { 98, 2 },
1209 { 98, 3 },
1210 { 98, 1 },
1211 { 98, 1 },
1212 { 98, 1 },
1213 { 98, 1 },
1214 { 98, 1 },
1215 { 98, 1 },
1216 { 98, 1 },
1217 { 98, 1 },
1218 { 98, 1 },
1219 { 98, 1 },
1220 { 98, 1 },
1221 { 116, 3 },
1222 { 116, 1 },
1223 };
1224
1225 static void pp_accept(ppParser*); /* Forward Declaration */
1226
1227 /*
1228 ** Perform a reduce action and the shift that must immediately
1229 ** follow the reduce.
1230 */
pp_reduce(ppParser * pppParser,int ppruleno)1231 static void pp_reduce(
1232 ppParser *pppParser, /* The parser */
1233 int ppruleno /* Number of the rule by which to reduce */
1234 ){
1235 int ppgoto; /* The next state */
1236 int ppact; /* The next action */
1237 PPMINORTYPE ppgotominor; /* The LHS of the rule reduced */
1238 ppStackEntry *ppmsp; /* The top of the parser's stack */
1239 int ppsize; /* Amount to pop the stack */
1240 phql_ARG_FETCH;
1241 ppmsp = &pppParser->ppstack[pppParser->ppidx];
1242 #ifndef NDEBUG
1243 if( ppTraceFILE && ppruleno>=0
1244 && ppruleno<sizeof(ppRuleName)/sizeof(ppRuleName[0]) ){
1245 fprintf(ppTraceFILE, "%sReduce [%s].\n", ppTracePrompt,
1246 ppRuleName[ppruleno]);
1247 }
1248 #endif /* NDEBUG */
1249
1250 switch( ppruleno ){
1251 /* Beginning here are the reduction cases. A typical example
1252 ** follows:
1253 ** case 0:
1254 ** // <lineno> <grammarfile>
1255 ** { ... } // User supplied code
1256 ** // <lineno> <thisfile>
1257 ** break;
1258 */
1259 case 0:
1260 // 119 "parser.php5.lemon"
1261 {
1262 status->ret = ppmsp[0].minor.pp162;
1263 }
1264 // 1263 "parser.php5.c"
1265 break;
1266 case 1:
1267 case 2:
1268 case 3:
1269 case 4:
1270 case 18:
1271 case 19:
1272 case 22:
1273 case 23:
1274 case 43:
1275 case 50:
1276 case 52:
1277 case 65:
1278 case 67:
1279 case 73:
1280 case 80:
1281 case 81:
1282 case 132:
1283 case 136:
1284 case 141:
1285 case 148:
1286 // 127 "parser.php5.lemon"
1287 {
1288 ppgotominor.pp162 = ppmsp[0].minor.pp162;
1289 }
1290 // 1289 "parser.php5.c"
1291 break;
1292 case 5:
1293 // 147 "parser.php5.lemon"
1294 {
1295 ppgotominor.pp162 = phql_ret_select_statement(ppmsp[-6].minor.pp162, ppmsp[-5].minor.pp162, ppmsp[-2].minor.pp162, ppmsp[-4].minor.pp162, ppmsp[-3].minor.pp162, ppmsp[-1].minor.pp162, ppmsp[0].minor.pp162);
1296 }
1297 // 1296 "parser.php5.c"
1298 break;
1299 case 6:
1300 // 155 "parser.php5.lemon"
1301 {
1302 ppgotominor.pp162 = phql_ret_select_clause(ppmsp[-4].minor.pp162, ppmsp[-3].minor.pp162, ppmsp[-1].minor.pp162, ppmsp[0].minor.pp162);
1303 pp_destructor(26,&ppmsp[-5].minor);
1304 pp_destructor(27,&ppmsp[-2].minor);
1305 }
1306 // 1305 "parser.php5.c"
1307 break;
1308 case 7:
1309 // 163 "parser.php5.lemon"
1310 {
1311 ppgotominor.pp162 = phql_ret_distinct_all(1);
1312 pp_destructor(28,&ppmsp[0].minor);
1313 }
1314 // 1313 "parser.php5.c"
1315 break;
1316 case 8:
1317 // 167 "parser.php5.lemon"
1318 {
1319 ppgotominor.pp162 = phql_ret_distinct_all(0);
1320 pp_destructor(29,&ppmsp[0].minor);
1321 }
1322 // 1321 "parser.php5.c"
1323 break;
1324 case 9:
1325 case 20:
1326 case 27:
1327 case 38:
1328 case 69:
1329 case 71:
1330 case 78:
1331 case 83:
1332 case 85:
1333 case 89:
1334 case 91:
1335 case 135:
1336 case 137:
1337 // 171 "parser.php5.lemon"
1338 {
1339 ppgotominor.pp162 = NULL;
1340 }
1341 // 1340 "parser.php5.c"
1342 break;
1343 case 10:
1344 case 17:
1345 case 41:
1346 case 44:
1347 case 49:
1348 case 64:
1349 case 72:
1350 case 79:
1351 case 138:
1352 // 179 "parser.php5.lemon"
1353 {
1354 ppgotominor.pp162 = phql_ret_zval_list(ppmsp[-2].minor.pp162, ppmsp[0].minor.pp162);
1355 pp_destructor(25,&ppmsp[-1].minor);
1356 }
1357 // 1356 "parser.php5.c"
1358 break;
1359 case 11:
1360 case 42:
1361 case 45:
1362 case 129:
1363 case 139:
1364 // 183 "parser.php5.lemon"
1365 {
1366 ppgotominor.pp162 = phql_ret_zval_list(ppmsp[0].minor.pp162, NULL);
1367 }
1368 // 1367 "parser.php5.c"
1369 break;
1370 case 12:
1371 case 140:
1372 // 191 "parser.php5.lemon"
1373 {
1374 ppgotominor.pp162 = phql_ret_column_item(PHQL_T_STARALL, NULL, NULL, NULL);
1375 pp_destructor(17,&ppmsp[0].minor);
1376 }
1377 // 1376 "parser.php5.c"
1378 break;
1379 case 13:
1380 // 195 "parser.php5.lemon"
1381 {
1382 ppgotominor.pp162 = phql_ret_column_item(PHQL_T_DOMAINALL, NULL, ppmsp[-2].minor.pp0, NULL);
1383 pp_destructor(31,&ppmsp[-1].minor);
1384 pp_destructor(17,&ppmsp[0].minor);
1385 }
1386 // 1385 "parser.php5.c"
1387 break;
1388 case 14:
1389 // 199 "parser.php5.lemon"
1390 {
1391 ppgotominor.pp162 = phql_ret_column_item(PHQL_T_EXPR, ppmsp[-2].minor.pp162, NULL, ppmsp[0].minor.pp0);
1392 pp_destructor(32,&ppmsp[-1].minor);
1393 }
1394 // 1393 "parser.php5.c"
1395 break;
1396 case 15:
1397 // 203 "parser.php5.lemon"
1398 {
1399 ppgotominor.pp162 = phql_ret_column_item(PHQL_T_EXPR, ppmsp[-1].minor.pp162, NULL, ppmsp[0].minor.pp0);
1400 }
1401 // 1400 "parser.php5.c"
1402 break;
1403 case 16:
1404 // 207 "parser.php5.lemon"
1405 {
1406 ppgotominor.pp162 = phql_ret_column_item(PHQL_T_EXPR, ppmsp[0].minor.pp162, NULL, NULL);
1407 }
1408 // 1407 "parser.php5.c"
1409 break;
1410 case 21:
1411 case 128:
1412 // 235 "parser.php5.lemon"
1413 {
1414 ppgotominor.pp162 = phql_ret_zval_list(ppmsp[-1].minor.pp162, ppmsp[0].minor.pp162);
1415 }
1416 // 1415 "parser.php5.c"
1417 break;
1418 case 24:
1419 // 256 "parser.php5.lemon"
1420 {
1421 ppgotominor.pp162 = phql_ret_join_item(ppmsp[-3].minor.pp162, ppmsp[-2].minor.pp162, ppmsp[-1].minor.pp162, ppmsp[0].minor.pp162);
1422 }
1423 // 1422 "parser.php5.c"
1424 break;
1425 case 25:
1426 // 264 "parser.php5.lemon"
1427 {
1428 ppgotominor.pp162 = phql_ret_qualified_name(NULL, NULL, ppmsp[0].minor.pp0);
1429 pp_destructor(32,&ppmsp[-1].minor);
1430 }
1431 // 1430 "parser.php5.c"
1432 break;
1433 case 26:
1434 case 46:
1435 case 66:
1436 case 160:
1437 // 268 "parser.php5.lemon"
1438 {
1439 ppgotominor.pp162 = phql_ret_qualified_name(NULL, NULL, ppmsp[0].minor.pp0);
1440 }
1441 // 1440 "parser.php5.c"
1442 break;
1443 case 28:
1444 // 280 "parser.php5.lemon"
1445 {
1446 ppgotominor.pp162 = phql_ret_join_type(PHQL_T_INNERJOIN);
1447 pp_destructor(33,&ppmsp[-1].minor);
1448 pp_destructor(34,&ppmsp[0].minor);
1449 }
1450 // 1449 "parser.php5.c"
1451 break;
1452 case 29:
1453 // 284 "parser.php5.lemon"
1454 {
1455 ppgotominor.pp162 = phql_ret_join_type(PHQL_T_CROSSJOIN);
1456 pp_destructor(35,&ppmsp[-1].minor);
1457 pp_destructor(34,&ppmsp[0].minor);
1458 }
1459 // 1458 "parser.php5.c"
1460 break;
1461 case 30:
1462 // 288 "parser.php5.lemon"
1463 {
1464 ppgotominor.pp162 = phql_ret_join_type(PHQL_T_LEFTJOIN);
1465 pp_destructor(36,&ppmsp[-2].minor);
1466 pp_destructor(37,&ppmsp[-1].minor);
1467 pp_destructor(34,&ppmsp[0].minor);
1468 }
1469 // 1468 "parser.php5.c"
1470 break;
1471 case 31:
1472 // 292 "parser.php5.lemon"
1473 {
1474 ppgotominor.pp162 = phql_ret_join_type(PHQL_T_LEFTJOIN);
1475 pp_destructor(36,&ppmsp[-1].minor);
1476 pp_destructor(34,&ppmsp[0].minor);
1477 }
1478 // 1477 "parser.php5.c"
1479 break;
1480 case 32:
1481 // 296 "parser.php5.lemon"
1482 {
1483 ppgotominor.pp162 = phql_ret_join_type(PHQL_T_RIGHTJOIN);
1484 pp_destructor(38,&ppmsp[-2].minor);
1485 pp_destructor(37,&ppmsp[-1].minor);
1486 pp_destructor(34,&ppmsp[0].minor);
1487 }
1488 // 1487 "parser.php5.c"
1489 break;
1490 case 33:
1491 // 300 "parser.php5.lemon"
1492 {
1493 ppgotominor.pp162 = phql_ret_join_type(PHQL_T_RIGHTJOIN);
1494 pp_destructor(38,&ppmsp[-1].minor);
1495 pp_destructor(34,&ppmsp[0].minor);
1496 }
1497 // 1496 "parser.php5.c"
1498 break;
1499 case 34:
1500 // 304 "parser.php5.lemon"
1501 {
1502 ppgotominor.pp162 = phql_ret_join_type(PHQL_T_FULLJOIN);
1503 pp_destructor(39,&ppmsp[-2].minor);
1504 pp_destructor(37,&ppmsp[-1].minor);
1505 pp_destructor(34,&ppmsp[0].minor);
1506 }
1507 // 1506 "parser.php5.c"
1508 break;
1509 case 35:
1510 // 308 "parser.php5.lemon"
1511 {
1512 ppgotominor.pp162 = phql_ret_join_type(PHQL_T_FULLJOIN);
1513 pp_destructor(39,&ppmsp[-1].minor);
1514 pp_destructor(34,&ppmsp[0].minor);
1515 }
1516 // 1515 "parser.php5.c"
1517 break;
1518 case 36:
1519 // 312 "parser.php5.lemon"
1520 {
1521 ppgotominor.pp162 = phql_ret_join_type(PHQL_T_INNERJOIN);
1522 pp_destructor(34,&ppmsp[0].minor);
1523 }
1524 // 1523 "parser.php5.c"
1525 break;
1526 case 37:
1527 // 320 "parser.php5.lemon"
1528 {
1529 ppgotominor.pp162 = ppmsp[0].minor.pp162;
1530 pp_destructor(40,&ppmsp[-1].minor);
1531 }
1532 // 1531 "parser.php5.c"
1533 break;
1534 case 39:
1535 // 333 "parser.php5.lemon"
1536 {
1537 ppgotominor.pp162 = phql_ret_insert_statement(ppmsp[-4].minor.pp162, NULL, ppmsp[-1].minor.pp162);
1538 pp_destructor(41,&ppmsp[-6].minor);
1539 pp_destructor(42,&ppmsp[-5].minor);
1540 pp_destructor(43,&ppmsp[-3].minor);
1541 pp_destructor(44,&ppmsp[-2].minor);
1542 pp_destructor(45,&ppmsp[0].minor);
1543 }
1544 // 1543 "parser.php5.c"
1545 break;
1546 case 40:
1547 // 337 "parser.php5.lemon"
1548 {
1549 ppgotominor.pp162 = phql_ret_insert_statement(ppmsp[-7].minor.pp162, ppmsp[-5].minor.pp162, ppmsp[-1].minor.pp162);
1550 pp_destructor(41,&ppmsp[-9].minor);
1551 pp_destructor(42,&ppmsp[-8].minor);
1552 pp_destructor(44,&ppmsp[-6].minor);
1553 pp_destructor(45,&ppmsp[-4].minor);
1554 pp_destructor(43,&ppmsp[-3].minor);
1555 pp_destructor(44,&ppmsp[-2].minor);
1556 pp_destructor(45,&ppmsp[0].minor);
1557 }
1558 // 1557 "parser.php5.c"
1559 break;
1560 case 47:
1561 // 383 "parser.php5.lemon"
1562 {
1563 ppgotominor.pp162 = phql_ret_update_statement(ppmsp[-2].minor.pp162, ppmsp[-1].minor.pp162, ppmsp[0].minor.pp162);
1564 }
1565 // 1564 "parser.php5.c"
1566 break;
1567 case 48:
1568 // 391 "parser.php5.lemon"
1569 {
1570 ppgotominor.pp162 = phql_ret_update_clause(ppmsp[-2].minor.pp162, ppmsp[0].minor.pp162);
1571 pp_destructor(46,&ppmsp[-3].minor);
1572 pp_destructor(47,&ppmsp[-1].minor);
1573 }
1574 // 1573 "parser.php5.c"
1575 break;
1576 case 51:
1577 // 411 "parser.php5.lemon"
1578 {
1579 ppgotominor.pp162 = phql_ret_update_item(ppmsp[-2].minor.pp162, ppmsp[0].minor.pp162);
1580 pp_destructor(3,&ppmsp[-1].minor);
1581 }
1582 // 1581 "parser.php5.c"
1583 break;
1584 case 53:
1585 // 425 "parser.php5.lemon"
1586 {
1587 ppgotominor.pp162 = phql_ret_delete_statement(ppmsp[-2].minor.pp162, ppmsp[-1].minor.pp162, ppmsp[0].minor.pp162);
1588 }
1589 // 1588 "parser.php5.c"
1590 break;
1591 case 54:
1592 // 433 "parser.php5.lemon"
1593 {
1594 ppgotominor.pp162 = phql_ret_delete_clause(ppmsp[0].minor.pp162);
1595 pp_destructor(48,&ppmsp[-2].minor);
1596 pp_destructor(27,&ppmsp[-1].minor);
1597 }
1598 // 1597 "parser.php5.c"
1599 break;
1600 case 55:
1601 // 441 "parser.php5.lemon"
1602 {
1603 ppgotominor.pp162 = phql_ret_assoc_name(ppmsp[-2].minor.pp162, ppmsp[0].minor.pp0, NULL);
1604 pp_destructor(32,&ppmsp[-1].minor);
1605 }
1606 // 1605 "parser.php5.c"
1607 break;
1608 case 56:
1609 // 445 "parser.php5.lemon"
1610 {
1611 ppgotominor.pp162 = phql_ret_assoc_name(ppmsp[-1].minor.pp162, ppmsp[0].minor.pp0, NULL);
1612 }
1613 // 1612 "parser.php5.c"
1614 break;
1615 case 57:
1616 // 449 "parser.php5.lemon"
1617 {
1618 ppgotominor.pp162 = phql_ret_assoc_name(ppmsp[0].minor.pp162, NULL, NULL);
1619 }
1620 // 1619 "parser.php5.c"
1621 break;
1622 case 58:
1623 // 453 "parser.php5.lemon"
1624 {
1625 ppgotominor.pp162 = phql_ret_assoc_name(ppmsp[-4].minor.pp162, ppmsp[-2].minor.pp0, ppmsp[0].minor.pp162);
1626 pp_destructor(32,&ppmsp[-3].minor);
1627 pp_destructor(49,&ppmsp[-1].minor);
1628 }
1629 // 1628 "parser.php5.c"
1630 break;
1631 case 59:
1632 // 457 "parser.php5.lemon"
1633 {
1634 ppgotominor.pp162 = phql_ret_assoc_name(ppmsp[-6].minor.pp162, ppmsp[-4].minor.pp0, ppmsp[-1].minor.pp162);
1635 pp_destructor(32,&ppmsp[-5].minor);
1636 pp_destructor(49,&ppmsp[-3].minor);
1637 pp_destructor(44,&ppmsp[-2].minor);
1638 pp_destructor(45,&ppmsp[0].minor);
1639 }
1640 // 1639 "parser.php5.c"
1641 break;
1642 case 60:
1643 // 461 "parser.php5.lemon"
1644 {
1645 ppgotominor.pp162 = phql_ret_assoc_name(ppmsp[-5].minor.pp162, ppmsp[-4].minor.pp0, ppmsp[-1].minor.pp162);
1646 pp_destructor(49,&ppmsp[-3].minor);
1647 pp_destructor(44,&ppmsp[-2].minor);
1648 pp_destructor(45,&ppmsp[0].minor);
1649 }
1650 // 1649 "parser.php5.c"
1651 break;
1652 case 61:
1653 // 465 "parser.php5.lemon"
1654 {
1655 ppgotominor.pp162 = phql_ret_assoc_name(ppmsp[-3].minor.pp162, ppmsp[-2].minor.pp0, ppmsp[0].minor.pp162);
1656 pp_destructor(49,&ppmsp[-1].minor);
1657 }
1658 // 1657 "parser.php5.c"
1659 break;
1660 case 62:
1661 // 469 "parser.php5.lemon"
1662 {
1663 ppgotominor.pp162 = phql_ret_assoc_name(ppmsp[-4].minor.pp162, NULL, ppmsp[-1].minor.pp162);
1664 pp_destructor(49,&ppmsp[-3].minor);
1665 pp_destructor(44,&ppmsp[-2].minor);
1666 pp_destructor(45,&ppmsp[0].minor);
1667 }
1668 // 1667 "parser.php5.c"
1669 break;
1670 case 63:
1671 // 473 "parser.php5.lemon"
1672 {
1673 ppgotominor.pp162 = phql_ret_assoc_name(ppmsp[-2].minor.pp162, NULL, ppmsp[0].minor.pp162);
1674 pp_destructor(49,&ppmsp[-1].minor);
1675 }
1676 // 1675 "parser.php5.c"
1677 break;
1678 case 68:
1679 // 509 "parser.php5.lemon"
1680 {
1681 ppgotominor.pp162 = ppmsp[0].minor.pp162;
1682 pp_destructor(50,&ppmsp[-1].minor);
1683 }
1684 // 1683 "parser.php5.c"
1685 break;
1686 case 70:
1687 // 521 "parser.php5.lemon"
1688 {
1689 ppgotominor.pp162 = ppmsp[0].minor.pp162;
1690 pp_destructor(51,&ppmsp[-2].minor);
1691 pp_destructor(52,&ppmsp[-1].minor);
1692 }
1693 // 1692 "parser.php5.c"
1694 break;
1695 case 74:
1696 // 545 "parser.php5.lemon"
1697 {
1698 ppgotominor.pp162 = phql_ret_order_item(ppmsp[0].minor.pp162, 0);
1699 }
1700 // 1699 "parser.php5.c"
1701 break;
1702 case 75:
1703 // 549 "parser.php5.lemon"
1704 {
1705 ppgotominor.pp162 = phql_ret_order_item(ppmsp[-1].minor.pp162, PHQL_T_ASC);
1706 pp_destructor(53,&ppmsp[0].minor);
1707 }
1708 // 1707 "parser.php5.c"
1709 break;
1710 case 76:
1711 // 553 "parser.php5.lemon"
1712 {
1713 ppgotominor.pp162 = phql_ret_order_item(ppmsp[-1].minor.pp162, PHQL_T_DESC);
1714 pp_destructor(54,&ppmsp[0].minor);
1715 }
1716 // 1715 "parser.php5.c"
1717 break;
1718 case 77:
1719 // 561 "parser.php5.lemon"
1720 {
1721 ppgotominor.pp162 = ppmsp[0].minor.pp162;
1722 pp_destructor(55,&ppmsp[-2].minor);
1723 pp_destructor(52,&ppmsp[-1].minor);
1724 }
1725 // 1724 "parser.php5.c"
1726 break;
1727 case 82:
1728 // 593 "parser.php5.lemon"
1729 {
1730 ppgotominor.pp162 = ppmsp[0].minor.pp162;
1731 pp_destructor(56,&ppmsp[-1].minor);
1732 }
1733 // 1732 "parser.php5.c"
1734 break;
1735 case 84:
1736 // 605 "parser.php5.lemon"
1737 {
1738 ppgotominor.pp162 = phql_ret_for_update_clause();
1739 pp_destructor(57,&ppmsp[-1].minor);
1740 pp_destructor(46,&ppmsp[0].minor);
1741 }
1742 // 1741 "parser.php5.c"
1743 break;
1744 case 86:
1745 case 90:
1746 // 617 "parser.php5.lemon"
1747 {
1748 ppgotominor.pp162 = phql_ret_limit_clause(ppmsp[0].minor.pp162, NULL);
1749 pp_destructor(58,&ppmsp[-1].minor);
1750 }
1751 // 1750 "parser.php5.c"
1752 break;
1753 case 87:
1754 // 621 "parser.php5.lemon"
1755 {
1756 ppgotominor.pp162 = phql_ret_limit_clause(ppmsp[0].minor.pp162, ppmsp[-2].minor.pp162);
1757 pp_destructor(58,&ppmsp[-3].minor);
1758 pp_destructor(25,&ppmsp[-1].minor);
1759 }
1760 // 1759 "parser.php5.c"
1761 break;
1762 case 88:
1763 // 625 "parser.php5.lemon"
1764 {
1765 ppgotominor.pp162 = phql_ret_limit_clause(ppmsp[-2].minor.pp162, ppmsp[0].minor.pp162);
1766 pp_destructor(58,&ppmsp[-3].minor);
1767 pp_destructor(59,&ppmsp[-1].minor);
1768 }
1769 // 1768 "parser.php5.c"
1770 break;
1771 case 92:
1772 case 149:
1773 // 645 "parser.php5.lemon"
1774 {
1775 ppgotominor.pp162 = phql_ret_literal_zval(PHQL_T_INTEGER, ppmsp[0].minor.pp0);
1776 }
1777 // 1776 "parser.php5.c"
1778 break;
1779 case 93:
1780 case 150:
1781 // 649 "parser.php5.lemon"
1782 {
1783 ppgotominor.pp162 = phql_ret_literal_zval(PHQL_T_HINTEGER, ppmsp[0].minor.pp0);
1784 }
1785 // 1784 "parser.php5.c"
1786 break;
1787 case 94:
1788 case 156:
1789 // 653 "parser.php5.lemon"
1790 {
1791 ppgotominor.pp162 = phql_ret_placeholder_zval(PHQL_T_NPLACEHOLDER, ppmsp[0].minor.pp0);
1792 }
1793 // 1792 "parser.php5.c"
1794 break;
1795 case 95:
1796 case 157:
1797 // 657 "parser.php5.lemon"
1798 {
1799 ppgotominor.pp162 = phql_ret_placeholder_zval(PHQL_T_SPLACEHOLDER, ppmsp[0].minor.pp0);
1800 }
1801 // 1800 "parser.php5.c"
1802 break;
1803 case 96:
1804 case 158:
1805 // 661 "parser.php5.lemon"
1806 {
1807 ppgotominor.pp162 = phql_ret_placeholder_zval(PHQL_T_BPLACEHOLDER, ppmsp[0].minor.pp0);
1808 }
1809 // 1808 "parser.php5.c"
1810 break;
1811 case 97:
1812 // 669 "parser.php5.lemon"
1813 {
1814 ppgotominor.pp162 = phql_ret_expr(PHQL_T_MINUS, NULL, ppmsp[0].minor.pp162);
1815 pp_destructor(20,&ppmsp[-1].minor);
1816 }
1817 // 1816 "parser.php5.c"
1818 break;
1819 case 98:
1820 // 673 "parser.php5.lemon"
1821 {
1822 ppgotominor.pp162 = phql_ret_expr(PHQL_T_SUB, ppmsp[-2].minor.pp162, ppmsp[0].minor.pp162);
1823 pp_destructor(20,&ppmsp[-1].minor);
1824 }
1825 // 1824 "parser.php5.c"
1826 break;
1827 case 99:
1828 // 677 "parser.php5.lemon"
1829 {
1830 ppgotominor.pp162 = phql_ret_expr(PHQL_T_ADD, ppmsp[-2].minor.pp162, ppmsp[0].minor.pp162);
1831 pp_destructor(19,&ppmsp[-1].minor);
1832 }
1833 // 1832 "parser.php5.c"
1834 break;
1835 case 100:
1836 // 681 "parser.php5.lemon"
1837 {
1838 ppgotominor.pp162 = phql_ret_expr(PHQL_T_MUL, ppmsp[-2].minor.pp162, ppmsp[0].minor.pp162);
1839 pp_destructor(17,&ppmsp[-1].minor);
1840 }
1841 // 1840 "parser.php5.c"
1842 break;
1843 case 101:
1844 // 685 "parser.php5.lemon"
1845 {
1846 ppgotominor.pp162 = phql_ret_expr(PHQL_T_DIV, ppmsp[-2].minor.pp162, ppmsp[0].minor.pp162);
1847 pp_destructor(16,&ppmsp[-1].minor);
1848 }
1849 // 1848 "parser.php5.c"
1850 break;
1851 case 102:
1852 // 689 "parser.php5.lemon"
1853 {
1854 ppgotominor.pp162 = phql_ret_expr(PHQL_T_MOD, ppmsp[-2].minor.pp162, ppmsp[0].minor.pp162);
1855 pp_destructor(18,&ppmsp[-1].minor);
1856 }
1857 // 1856 "parser.php5.c"
1858 break;
1859 case 103:
1860 // 693 "parser.php5.lemon"
1861 {
1862 ppgotominor.pp162 = phql_ret_expr(PHQL_T_AND, ppmsp[-2].minor.pp162, ppmsp[0].minor.pp162);
1863 pp_destructor(9,&ppmsp[-1].minor);
1864 }
1865 // 1864 "parser.php5.c"
1866 break;
1867 case 104:
1868 // 697 "parser.php5.lemon"
1869 {
1870 ppgotominor.pp162 = phql_ret_expr(PHQL_T_OR, ppmsp[-2].minor.pp162, ppmsp[0].minor.pp162);
1871 pp_destructor(10,&ppmsp[-1].minor);
1872 }
1873 // 1872 "parser.php5.c"
1874 break;
1875 case 105:
1876 // 701 "parser.php5.lemon"
1877 {
1878 ppgotominor.pp162 = phql_ret_expr(PHQL_T_BITWISE_AND, ppmsp[-2].minor.pp162, ppmsp[0].minor.pp162);
1879 pp_destructor(13,&ppmsp[-1].minor);
1880 }
1881 // 1880 "parser.php5.c"
1882 break;
1883 case 106:
1884 // 705 "parser.php5.lemon"
1885 {
1886 ppgotominor.pp162 = phql_ret_expr(PHQL_T_BITWISE_OR, ppmsp[-2].minor.pp162, ppmsp[0].minor.pp162);
1887 pp_destructor(14,&ppmsp[-1].minor);
1888 }
1889 // 1888 "parser.php5.c"
1890 break;
1891 case 107:
1892 // 709 "parser.php5.lemon"
1893 {
1894 ppgotominor.pp162 = phql_ret_expr(PHQL_T_BITWISE_XOR, ppmsp[-2].minor.pp162, ppmsp[0].minor.pp162);
1895 pp_destructor(15,&ppmsp[-1].minor);
1896 }
1897 // 1896 "parser.php5.c"
1898 break;
1899 case 108:
1900 // 713 "parser.php5.lemon"
1901 {
1902 ppgotominor.pp162 = phql_ret_expr(PHQL_T_EQUALS, ppmsp[-2].minor.pp162, ppmsp[0].minor.pp162);
1903 pp_destructor(3,&ppmsp[-1].minor);
1904 }
1905 // 1904 "parser.php5.c"
1906 break;
1907 case 109:
1908 // 717 "parser.php5.lemon"
1909 {
1910 ppgotominor.pp162 = phql_ret_expr(PHQL_T_NOTEQUALS, ppmsp[-2].minor.pp162, ppmsp[0].minor.pp162);
1911 pp_destructor(4,&ppmsp[-1].minor);
1912 }
1913 // 1912 "parser.php5.c"
1914 break;
1915 case 110:
1916 // 721 "parser.php5.lemon"
1917 {
1918 ppgotominor.pp162 = phql_ret_expr(PHQL_T_LESS, ppmsp[-2].minor.pp162, ppmsp[0].minor.pp162);
1919 pp_destructor(5,&ppmsp[-1].minor);
1920 }
1921 // 1920 "parser.php5.c"
1922 break;
1923 case 111:
1924 // 725 "parser.php5.lemon"
1925 {
1926 ppgotominor.pp162 = phql_ret_expr(PHQL_T_GREATER, ppmsp[-2].minor.pp162, ppmsp[0].minor.pp162);
1927 pp_destructor(6,&ppmsp[-1].minor);
1928 }
1929 // 1928 "parser.php5.c"
1930 break;
1931 case 112:
1932 // 729 "parser.php5.lemon"
1933 {
1934 ppgotominor.pp162 = phql_ret_expr(PHQL_T_GREATEREQUAL, ppmsp[-2].minor.pp162, ppmsp[0].minor.pp162);
1935 pp_destructor(7,&ppmsp[-1].minor);
1936 }
1937 // 1936 "parser.php5.c"
1938 break;
1939 case 113:
1940 // 733 "parser.php5.lemon"
1941 {
1942 ppgotominor.pp162 = phql_ret_expr(PHQL_T_LESSEQUAL, ppmsp[-2].minor.pp162, ppmsp[0].minor.pp162);
1943 pp_destructor(8,&ppmsp[-1].minor);
1944 }
1945 // 1944 "parser.php5.c"
1946 break;
1947 case 114:
1948 // 737 "parser.php5.lemon"
1949 {
1950 ppgotominor.pp162 = phql_ret_expr(PHQL_T_LIKE, ppmsp[-2].minor.pp162, ppmsp[0].minor.pp162);
1951 pp_destructor(11,&ppmsp[-1].minor);
1952 }
1953 // 1952 "parser.php5.c"
1954 break;
1955 case 115:
1956 // 741 "parser.php5.lemon"
1957 {
1958 ppgotominor.pp162 = phql_ret_expr(PHQL_T_NLIKE, ppmsp[-3].minor.pp162, ppmsp[0].minor.pp162);
1959 pp_destructor(23,&ppmsp[-2].minor);
1960 pp_destructor(11,&ppmsp[-1].minor);
1961 }
1962 // 1961 "parser.php5.c"
1963 break;
1964 case 116:
1965 // 745 "parser.php5.lemon"
1966 {
1967 ppgotominor.pp162 = phql_ret_expr(PHQL_T_ILIKE, ppmsp[-2].minor.pp162, ppmsp[0].minor.pp162);
1968 pp_destructor(12,&ppmsp[-1].minor);
1969 }
1970 // 1969 "parser.php5.c"
1971 break;
1972 case 117:
1973 // 749 "parser.php5.lemon"
1974 {
1975 ppgotominor.pp162 = phql_ret_expr(PHQL_T_NILIKE, ppmsp[-3].minor.pp162, ppmsp[0].minor.pp162);
1976 pp_destructor(23,&ppmsp[-2].minor);
1977 pp_destructor(12,&ppmsp[-1].minor);
1978 }
1979 // 1978 "parser.php5.c"
1980 break;
1981 case 118:
1982 case 121:
1983 // 753 "parser.php5.lemon"
1984 {
1985 ppgotominor.pp162 = phql_ret_expr(PHQL_T_IN, ppmsp[-4].minor.pp162, ppmsp[-1].minor.pp162);
1986 pp_destructor(22,&ppmsp[-3].minor);
1987 pp_destructor(44,&ppmsp[-2].minor);
1988 pp_destructor(45,&ppmsp[0].minor);
1989 }
1990 // 1989 "parser.php5.c"
1991 break;
1992 case 119:
1993 case 122:
1994 // 757 "parser.php5.lemon"
1995 {
1996 ppgotominor.pp162 = phql_ret_expr(PHQL_T_NOTIN, ppmsp[-5].minor.pp162, ppmsp[-1].minor.pp162);
1997 pp_destructor(23,&ppmsp[-4].minor);
1998 pp_destructor(22,&ppmsp[-3].minor);
1999 pp_destructor(44,&ppmsp[-2].minor);
2000 pp_destructor(45,&ppmsp[0].minor);
2001 }
2002 // 2001 "parser.php5.c"
2003 break;
2004 case 120:
2005 // 761 "parser.php5.lemon"
2006 {
2007 ppgotominor.pp162 = phql_ret_expr(PHQL_T_SUBQUERY, ppmsp[-1].minor.pp162, NULL);
2008 pp_destructor(44,&ppmsp[-2].minor);
2009 pp_destructor(45,&ppmsp[0].minor);
2010 }
2011 // 2010 "parser.php5.c"
2012 break;
2013 case 123:
2014 // 773 "parser.php5.lemon"
2015 {
2016 ppgotominor.pp162 = phql_ret_expr(PHQL_T_EXISTS, NULL, ppmsp[-1].minor.pp162);
2017 pp_destructor(65,&ppmsp[-3].minor);
2018 pp_destructor(44,&ppmsp[-2].minor);
2019 pp_destructor(45,&ppmsp[0].minor);
2020 }
2021 // 2020 "parser.php5.c"
2022 break;
2023 case 124:
2024 // 777 "parser.php5.lemon"
2025 {
2026 ppgotominor.pp162 = phql_ret_expr(PHQL_T_AGAINST, ppmsp[-2].minor.pp162, ppmsp[0].minor.pp162);
2027 pp_destructor(1,&ppmsp[-1].minor);
2028 }
2029 // 2028 "parser.php5.c"
2030 break;
2031 case 125:
2032 // 781 "parser.php5.lemon"
2033 {
2034 ppgotominor.pp162 = phql_ret_expr(PHQL_T_CAST, ppmsp[-3].minor.pp162, phql_ret_raw_qualified_name(ppmsp[-1].minor.pp0, NULL));
2035 pp_destructor(66,&ppmsp[-5].minor);
2036 pp_destructor(44,&ppmsp[-4].minor);
2037 pp_destructor(32,&ppmsp[-2].minor);
2038 pp_destructor(45,&ppmsp[0].minor);
2039 }
2040 // 2039 "parser.php5.c"
2041 break;
2042 case 126:
2043 // 785 "parser.php5.lemon"
2044 {
2045 ppgotominor.pp162 = phql_ret_expr(PHQL_T_CONVERT, ppmsp[-3].minor.pp162, phql_ret_raw_qualified_name(ppmsp[-1].minor.pp0, NULL));
2046 pp_destructor(67,&ppmsp[-5].minor);
2047 pp_destructor(44,&ppmsp[-4].minor);
2048 pp_destructor(68,&ppmsp[-2].minor);
2049 pp_destructor(45,&ppmsp[0].minor);
2050 }
2051 // 2050 "parser.php5.c"
2052 break;
2053 case 127:
2054 // 789 "parser.php5.lemon"
2055 {
2056 ppgotominor.pp162 = phql_ret_expr(PHQL_T_CASE, ppmsp[-2].minor.pp162, ppmsp[-1].minor.pp162);
2057 pp_destructor(69,&ppmsp[-3].minor);
2058 pp_destructor(70,&ppmsp[0].minor);
2059 }
2060 // 2059 "parser.php5.c"
2061 break;
2062 case 130:
2063 // 801 "parser.php5.lemon"
2064 {
2065 ppgotominor.pp162 = phql_ret_expr(PHQL_T_WHEN, ppmsp[-2].minor.pp162, ppmsp[0].minor.pp162);
2066 pp_destructor(71,&ppmsp[-3].minor);
2067 pp_destructor(72,&ppmsp[-1].minor);
2068 }
2069 // 2068 "parser.php5.c"
2070 break;
2071 case 131:
2072 // 805 "parser.php5.lemon"
2073 {
2074 ppgotominor.pp162 = phql_ret_expr(PHQL_T_ELSE, ppmsp[0].minor.pp162, NULL);
2075 pp_destructor(73,&ppmsp[-1].minor);
2076 }
2077 // 2076 "parser.php5.c"
2078 break;
2079 case 133:
2080 // 817 "parser.php5.lemon"
2081 {
2082 ppgotominor.pp162 = phql_ret_func_call(ppmsp[-4].minor.pp0, ppmsp[-1].minor.pp162, ppmsp[-2].minor.pp162);
2083 pp_destructor(44,&ppmsp[-3].minor);
2084 pp_destructor(45,&ppmsp[0].minor);
2085 }
2086 // 2085 "parser.php5.c"
2087 break;
2088 case 134:
2089 // 825 "parser.php5.lemon"
2090 {
2091 ppgotominor.pp162 = phql_ret_distinct();
2092 pp_destructor(28,&ppmsp[0].minor);
2093 }
2094 // 2093 "parser.php5.c"
2095 break;
2096 case 142:
2097 // 869 "parser.php5.lemon"
2098 {
2099 ppgotominor.pp162 = phql_ret_expr(PHQL_T_ISNULL, ppmsp[-2].minor.pp162, NULL);
2100 pp_destructor(21,&ppmsp[-1].minor);
2101 pp_destructor(74,&ppmsp[0].minor);
2102 }
2103 // 2102 "parser.php5.c"
2104 break;
2105 case 143:
2106 // 873 "parser.php5.lemon"
2107 {
2108 ppgotominor.pp162 = phql_ret_expr(PHQL_T_ISNOTNULL, ppmsp[-3].minor.pp162, NULL);
2109 pp_destructor(21,&ppmsp[-2].minor);
2110 pp_destructor(23,&ppmsp[-1].minor);
2111 pp_destructor(74,&ppmsp[0].minor);
2112 }
2113 // 2112 "parser.php5.c"
2114 break;
2115 case 144:
2116 // 877 "parser.php5.lemon"
2117 {
2118 ppgotominor.pp162 = phql_ret_expr(PHQL_T_BETWEEN, ppmsp[-2].minor.pp162, ppmsp[0].minor.pp162);
2119 pp_destructor(2,&ppmsp[-1].minor);
2120 }
2121 // 2120 "parser.php5.c"
2122 break;
2123 case 145:
2124 // 881 "parser.php5.lemon"
2125 {
2126 ppgotominor.pp162 = phql_ret_expr(PHQL_T_NOT, NULL, ppmsp[0].minor.pp162);
2127 pp_destructor(23,&ppmsp[-1].minor);
2128 }
2129 // 2128 "parser.php5.c"
2130 break;
2131 case 146:
2132 // 885 "parser.php5.lemon"
2133 {
2134 ppgotominor.pp162 = phql_ret_expr(PHQL_T_BITWISE_NOT, NULL, ppmsp[0].minor.pp162);
2135 pp_destructor(24,&ppmsp[-1].minor);
2136 }
2137 // 2136 "parser.php5.c"
2138 break;
2139 case 147:
2140 // 889 "parser.php5.lemon"
2141 {
2142 ppgotominor.pp162 = phql_ret_expr(PHQL_T_ENCLOSED, ppmsp[-1].minor.pp162, NULL);
2143 pp_destructor(44,&ppmsp[-2].minor);
2144 pp_destructor(45,&ppmsp[0].minor);
2145 }
2146 // 2145 "parser.php5.c"
2147 break;
2148 case 151:
2149 // 905 "parser.php5.lemon"
2150 {
2151 ppgotominor.pp162 = phql_ret_literal_zval(PHQL_T_STRING, ppmsp[0].minor.pp0);
2152 }
2153 // 2152 "parser.php5.c"
2154 break;
2155 case 152:
2156 // 909 "parser.php5.lemon"
2157 {
2158 ppgotominor.pp162 = phql_ret_literal_zval(PHQL_T_DOUBLE, ppmsp[0].minor.pp0);
2159 }
2160 // 2159 "parser.php5.c"
2161 break;
2162 case 153:
2163 // 913 "parser.php5.lemon"
2164 {
2165 ppgotominor.pp162 = phql_ret_literal_zval(PHQL_T_NULL, NULL);
2166 pp_destructor(74,&ppmsp[0].minor);
2167 }
2168 // 2167 "parser.php5.c"
2169 break;
2170 case 154:
2171 // 917 "parser.php5.lemon"
2172 {
2173 ppgotominor.pp162 = phql_ret_literal_zval(PHQL_T_TRUE, NULL);
2174 pp_destructor(77,&ppmsp[0].minor);
2175 }
2176 // 2175 "parser.php5.c"
2177 break;
2178 case 155:
2179 // 921 "parser.php5.lemon"
2180 {
2181 ppgotominor.pp162 = phql_ret_literal_zval(PHQL_T_FALSE, NULL);
2182 pp_destructor(78,&ppmsp[0].minor);
2183 }
2184 // 2183 "parser.php5.c"
2185 break;
2186 case 159:
2187 // 944 "parser.php5.lemon"
2188 {
2189 ppgotominor.pp162 = phql_ret_qualified_name(NULL, ppmsp[-2].minor.pp0, ppmsp[0].minor.pp0);
2190 pp_destructor(31,&ppmsp[-1].minor);
2191 }
2192 // 2191 "parser.php5.c"
2193 break;
2194 };
2195 ppgoto = ppRuleInfo[ppruleno].lhs;
2196 ppsize = ppRuleInfo[ppruleno].nrhs;
2197 pppParser->ppidx -= ppsize;
2198 ppact = pp_find_reduce_action(pppParser,ppgoto);
2199 if( ppact < PPNSTATE ){
2200 pp_shift(pppParser,ppact,ppgoto,&ppgotominor);
2201 }else if( ppact == PPNSTATE + PPNRULE + 1 ){
2202 pp_accept(pppParser);
2203 }
2204 }
2205
2206 /*
2207 ** The following code executes when the parse fails
2208 */
pp_parse_failed(ppParser * pppParser)2209 static void pp_parse_failed(
2210 ppParser *pppParser /* The parser */
2211 ){
2212 phql_ARG_FETCH;
2213 #ifndef NDEBUG
2214 if( ppTraceFILE ){
2215 fprintf(ppTraceFILE,"%sFail!\n",ppTracePrompt);
2216 }
2217 #endif
2218 while( pppParser->ppidx>=0 ) pp_pop_parser_stack(pppParser);
2219 /* Here code is inserted which will be executed whenever the
2220 ** parser fails */
2221 phql_ARG_STORE; /* Suppress warning about unused %extra_argument variable */
2222 }
2223
2224 /*
2225 ** The following code executes when a syntax error first occurs.
2226 */
pp_syntax_error(ppParser * pppParser,int ppmajor,PPMINORTYPE ppminor)2227 static void pp_syntax_error(
2228 ppParser *pppParser, /* The parser */
2229 int ppmajor, /* The major type of the error token */
2230 PPMINORTYPE ppminor /* The minor type of the error token */
2231 ){
2232 phql_ARG_FETCH;
2233 #define PPTOKEN (ppminor.pp0)
2234 // 43 "parser.php5.lemon"
2235
2236 if (status->scanner_state->start_length) {
2237 {
2238
2239 char *token_name = NULL;
2240 int token_found = 0;
2241 unsigned int token_length;
2242 const phql_token_names *tokens = phql_tokens;
2243 int active_token = status->scanner_state->active_token;
2244 int near_length = status->scanner_state->start_length;
2245
2246 if (active_token) {
2247
2248 do {
2249 if (tokens->code == active_token) {
2250 token_name = tokens->name;
2251 token_length = tokens->length;
2252 token_found = 1;
2253 break;
2254 }
2255 ++tokens;
2256 } while (tokens[0].code != 0);
2257
2258 }
2259
2260 if (!token_name) {
2261 token_length = strlen("UNKNOWN");
2262 token_name = estrndup("UNKNOWN", token_length);
2263 token_found = 0;
2264 }
2265
2266 status->syntax_error_len = 96 + status->token->len + token_length + near_length + status->phql_length;;
2267 status->syntax_error = emalloc(sizeof(char) * status->syntax_error_len);
2268
2269 if (near_length > 0) {
2270 if (status->token->value) {
2271 snprintf(status->syntax_error, status->syntax_error_len, "Syntax error, unexpected token %s(%s), near to '%s', when parsing: %s (%d)", token_name, status->token->value, status->scanner_state->start, status->phql, status->phql_length);
2272 } else {
2273 snprintf(status->syntax_error, status->syntax_error_len, "Syntax error, unexpected token %s, near to '%s', when parsing: %s (%d)", token_name, status->scanner_state->start, status->phql, status->phql_length);
2274 }
2275 } else {
2276 if (active_token != PHQL_T_IGNORE) {
2277 if (status->token->value) {
2278 snprintf(status->syntax_error, status->syntax_error_len, "Syntax error, unexpected token %s(%s), at the end of query, when parsing: %s (%d)", token_name, status->token->value, status->phql, status->phql_length);
2279 } else {
2280 snprintf(status->syntax_error, status->syntax_error_len, "Syntax error, unexpected token %s, at the end of query, when parsing: %s (%d)", token_name, status->phql, status->phql_length);
2281 }
2282 } else {
2283 snprintf(status->syntax_error, status->syntax_error_len, "Syntax error, unexpected EOF, at the end of query");
2284 }
2285 status->syntax_error[status->syntax_error_len - 1] = '\0';
2286 }
2287
2288 if (!token_found) {
2289 if (token_name) {
2290 efree(token_name);
2291 }
2292 }
2293 }
2294 } else {
2295 status->syntax_error_len = strlen("Syntax error, unexpected EOF");
2296 status->syntax_error = estrndup("Syntax error, unexpected EOF", status->syntax_error_len);
2297 }
2298
2299 status->status = PHQL_PARSING_FAILED;
2300
2301 // 2300 "parser.php5.c"
2302 phql_ARG_STORE; /* Suppress warning about unused %extra_argument variable */
2303 }
2304
2305 /*
2306 ** The following is executed when the parser accepts
2307 */
pp_accept(ppParser * pppParser)2308 static void pp_accept(
2309 ppParser *pppParser /* The parser */
2310 ){
2311 phql_ARG_FETCH;
2312 #ifndef NDEBUG
2313 if( ppTraceFILE ){
2314 fprintf(ppTraceFILE,"%sAccept!\n",ppTracePrompt);
2315 }
2316 #endif
2317 while( pppParser->ppidx>=0 ) pp_pop_parser_stack(pppParser);
2318 /* Here code is inserted which will be executed whenever the
2319 ** parser accepts */
2320 phql_ARG_STORE; /* Suppress warning about unused %extra_argument variable */
2321 }
2322
2323 /* The main parser program.
2324 ** The first argument is a pointer to a structure obtained from
2325 ** "phql_Alloc" which describes the current state of the parser.
2326 ** The second argument is the major token number. The third is
2327 ** the minor token. The fourth optional argument is whatever the
2328 ** user wants (and specified in the grammar) and is available for
2329 ** use by the action routines.
2330 **
2331 ** Inputs:
2332 ** <ul>
2333 ** <li> A pointer to the parser (an opaque structure.)
2334 ** <li> The major token number.
2335 ** <li> The minor token number.
2336 ** <li> An option argument of a grammar-specified type.
2337 ** </ul>
2338 **
2339 ** Outputs:
2340 ** None.
2341 */
phql_(void * ppp,int ppmajor,phql_TOKENTYPE ppminor phql_ARG_PDECL)2342 void phql_(
2343 void *ppp, /* The parser */
2344 int ppmajor, /* The major token code number */
2345 phql_TOKENTYPE ppminor /* The value for the token */
2346 phql_ARG_PDECL /* Optional %extra_argument parameter */
2347 ){
2348 PPMINORTYPE ppminorunion;
2349 int ppact; /* The parser action. */
2350 int ppendofinput; /* True if we are at the end of input */
2351 int pperrorhit = 0; /* True if ppmajor has invoked an error */
2352 ppParser *pppParser; /* The parser */
2353
2354 /* (re)initialize the parser, if necessary */
2355 pppParser = (ppParser*)ppp;
2356 if( pppParser->ppidx<0 ){
2357 if( ppmajor==0 ) return;
2358 pppParser->ppidx = 0;
2359 pppParser->pperrcnt = -1;
2360 pppParser->ppstack[0].stateno = 0;
2361 pppParser->ppstack[0].major = 0;
2362 }
2363 ppminorunion.pp0 = ppminor;
2364 ppendofinput = (ppmajor==0);
2365 phql_ARG_STORE;
2366
2367 #ifndef NDEBUG
2368 if( ppTraceFILE ){
2369 fprintf(ppTraceFILE,"%sInput %s\n",ppTracePrompt,ppTokenName[ppmajor]);
2370 }
2371 #endif
2372
2373 do{
2374 ppact = pp_find_shift_action(pppParser,ppmajor);
2375 if( ppact<PPNSTATE ){
2376 pp_shift(pppParser,ppact,ppmajor,&ppminorunion);
2377 pppParser->pperrcnt--;
2378 if( ppendofinput && pppParser->ppidx>=0 ){
2379 ppmajor = 0;
2380 }else{
2381 ppmajor = PPNOCODE;
2382 }
2383 }else if( ppact < PPNSTATE + PPNRULE ){
2384 pp_reduce(pppParser,ppact-PPNSTATE);
2385 }else if( ppact == PP_ERROR_ACTION ){
2386 int ppmx;
2387 #ifndef NDEBUG
2388 if( ppTraceFILE ){
2389 fprintf(ppTraceFILE,"%sSyntax Error!\n",ppTracePrompt);
2390 }
2391 #endif
2392 #ifdef PPERRORSYMBOL
2393 /* A syntax error has occurred.
2394 ** The response to an error depends upon whether or not the
2395 ** grammar defines an error token "ERROR".
2396 **
2397 ** This is what we do if the grammar does define ERROR:
2398 **
2399 ** * Call the %syntax_error function.
2400 **
2401 ** * Begin popping the stack until we enter a state where
2402 ** it is legal to shift the error symbol, then shift
2403 ** the error symbol.
2404 **
2405 ** * Set the error count to three.
2406 **
2407 ** * Begin accepting and shifting new tokens. No new error
2408 ** processing will occur until three tokens have been
2409 ** shifted successfully.
2410 **
2411 */
2412 if( pppParser->pperrcnt<0 ){
2413 pp_syntax_error(pppParser,ppmajor,ppminorunion);
2414 }
2415 ppmx = pppParser->ppstack[pppParser->ppidx].major;
2416 if( ppmx==PPERRORSYMBOL || pperrorhit ){
2417 #ifndef NDEBUG
2418 if( ppTraceFILE ){
2419 fprintf(ppTraceFILE,"%sDiscard input token %s\n",
2420 ppTracePrompt,ppTokenName[ppmajor]);
2421 }
2422 #endif
2423 pp_destructor(ppmajor,&ppminorunion);
2424 ppmajor = PPNOCODE;
2425 }else{
2426 while(
2427 pppParser->ppidx >= 0 &&
2428 ppmx != PPERRORSYMBOL &&
2429 (ppact = pp_find_shift_action(pppParser,PPERRORSYMBOL)) >= PPNSTATE
2430 ){
2431 pp_pop_parser_stack(pppParser);
2432 }
2433 if( pppParser->ppidx < 0 || ppmajor==0 ){
2434 pp_destructor(ppmajor,&ppminorunion);
2435 pp_parse_failed(pppParser);
2436 ppmajor = PPNOCODE;
2437 }else if( ppmx!=PPERRORSYMBOL ){
2438 PPMINORTYPE u2;
2439 u2.PPERRSYMDT = 0;
2440 pp_shift(pppParser,ppact,PPERRORSYMBOL,&u2);
2441 }
2442 }
2443 pppParser->pperrcnt = 3;
2444 pperrorhit = 1;
2445 #else /* PPERRORSYMBOL is not defined */
2446 /* This is what we do if the grammar does not define ERROR:
2447 **
2448 ** * Report an error message, and throw away the input token.
2449 **
2450 ** * If the input token is $, then fail the parse.
2451 **
2452 ** As before, subsequent error messages are suppressed until
2453 ** three input tokens have been successfully shifted.
2454 */
2455 if( pppParser->pperrcnt<=0 ){
2456 pp_syntax_error(pppParser,ppmajor,ppminorunion);
2457 }
2458 pppParser->pperrcnt = 3;
2459 pp_destructor(ppmajor,&ppminorunion);
2460 if( ppendofinput ){
2461 pp_parse_failed(pppParser);
2462 }
2463 ppmajor = PPNOCODE;
2464 #endif
2465 }else{
2466 pp_accept(pppParser);
2467 ppmajor = PPNOCODE;
2468 }
2469 }while( ppmajor!=PPNOCODE && pppParser->ppidx>=0 );
2470 return;
2471 }
2472 #else
2473 /* Driver template for the LEMON parser generator.
2474 ** The author disclaims copyright to this source code.
2475 */
2476 /* First off, code is include which follows the "include" declaration
2477 ** in the input file. */
2478 #include <stdio.h>
2479 // 39 "parser.php7.lemon"
2480
2481 #include "parser.php7.inc.h"
2482
2483 // 12 "parser.php7.c"
2484 /* Next is all token values, in a form suitable for use by makeheaders.
2485 ** This section will be null unless lemon is run with the -m switch.
2486 */
2487 /*
2488 ** These constants (all generated automatically by the parser generator)
2489 ** specify the various kinds of tokens (terminals) that the parser
2490 ** understands.
2491 **
2492 ** Each symbol here is a terminal symbol in the grammar.
2493 */
2494 /* Make sure the INTERFACE macro is defined.
2495 */
2496 #ifndef INTERFACE
2497 # define INTERFACE 1
2498 #endif
2499 /* The next thing included is series of defines which control
2500 ** various aspects of the generated parser.
2501 ** PPCODETYPE is the data type used for storing terminal
2502 ** and nonterminal numbers. "unsigned char" is
2503 ** used if there are fewer than 250 terminals
2504 ** and nonterminals. "int" is used otherwise.
2505 ** PPNOCODE is a number of type PPCODETYPE which corresponds
2506 ** to no legal terminal or nonterminal number. This
2507 ** number is used to fill in empty slots of the hash
2508 ** table.
2509 ** PPFALLBACK If defined, this indicates that one or more tokens
2510 ** have fall-back values which should be used if the
2511 ** original value of the token will not parse.
2512 ** PPACTIONTYPE is the data type used for storing terminal
2513 ** and nonterminal numbers. "unsigned char" is
2514 ** used if there are fewer than 250 rules and
2515 ** states combined. "int" is used otherwise.
2516 ** phql_TOKENTYPE is the data type used for minor tokens given
2517 ** directly to the parser from the tokenizer.
2518 ** PPMINORTYPE is the data type used for all minor tokens.
2519 ** This is typically a union of many types, one of
2520 ** which is phql_TOKENTYPE. The entry in the union
2521 ** for base tokens is called "pp0".
2522 ** PPSTACKDEPTH is the maximum depth of the parser's stack.
2523 ** phql_ARG_SDECL A static variable declaration for the %extra_argument
2524 ** phql_ARG_PDECL A parameter declaration for the %extra_argument
2525 ** phql_ARG_STORE Code to store %extra_argument into pppParser
2526 ** phql_ARG_FETCH Code to extract %extra_argument from pppParser
2527 ** PPNSTATE the combined number of states.
2528 ** PPNRULE the number of rules in the grammar
2529 ** PPERRORSYMBOL is the code number of the error symbol. If not
2530 ** defined, then do no error processing.
2531 */
2532 #define PPCODETYPE unsigned char
2533 #define PPNOCODE 134
2534 #define PPACTIONTYPE unsigned short int
2535 #define phql_TOKENTYPE phql_parser_token*
2536 typedef union {
2537 phql_TOKENTYPE pp0;
2538 zval pp204;
2539 int pp267;
2540 } PPMINORTYPE;
2541 #define PPSTACKDEPTH 100
2542 #define phql_ARG_SDECL phql_parser_status *status;
2543 #define phql_ARG_PDECL ,phql_parser_status *status
2544 #define phql_ARG_FETCH phql_parser_status *status = pppParser->status
2545 #define phql_ARG_STORE pppParser->status = status
2546 #define PPNSTATE 293
2547 #define PPNRULE 161
2548 #define PPERRORSYMBOL 79
2549 #define PPERRSYMDT pp267
2550 #define PP_NO_ACTION (PPNSTATE+PPNRULE+2)
2551 #define PP_ACCEPT_ACTION (PPNSTATE+PPNRULE+1)
2552 #define PP_ERROR_ACTION (PPNSTATE+PPNRULE)
2553
2554 /* Next are that tables used to determine what action to take based on the
2555 ** current state and lookahead token. These tables are used to implement
2556 ** functions that take a state number and lookahead value and return an
2557 ** action integer.
2558 **
2559 ** Suppose the action integer is N. Then the action is determined as
2560 ** follows
2561 **
2562 ** 0 <= N < PPNSTATE Shift N. That is, push the lookahead
2563 ** token onto the stack and goto state N.
2564 **
2565 ** PPNSTATE <= N < PPNSTATE+PPNRULE Reduce by rule N-PPNSTATE.
2566 **
2567 ** N == PPNSTATE+PPNRULE A syntax error has occurred.
2568 **
2569 ** N == PPNSTATE+PPNRULE+1 The parser accepts its input.
2570 **
2571 ** N == PPNSTATE+PPNRULE+2 No such action. Denotes unused
2572 ** slots in the pp_action[] table.
2573 **
2574 ** The action table is constructed as a single large table named pp_action[].
2575 ** Given state S and lookahead X, the action is computed as
2576 **
2577 ** pp_action[ pp_shift_ofst[S] + X ]
2578 **
2579 ** If the index value pp_shift_ofst[S]+X is out of range or if the value
2580 ** pp_lookahead[pp_shift_ofst[S]+X] is not equal to X or if pp_shift_ofst[S]
2581 ** is equal to PP_SHIFT_USE_DFLT, it means that the action is not in the table
2582 ** and that pp_default[S] should be used instead.
2583 **
2584 ** The formula above is for computing the action when the lookahead is
2585 ** a terminal symbol. If the lookahead is a non-terminal (as occurs after
2586 ** a reduce action) then the pp_reduce_ofst[] array is used in place of
2587 ** the pp_shift_ofst[] array and PP_REDUCE_USE_DFLT is used in place of
2588 ** PP_SHIFT_USE_DFLT.
2589 **
2590 ** The following are the tables generated in this section:
2591 **
2592 ** pp_action[] A single table containing all actions.
2593 ** pp_lookahead[] A table containing the lookahead for each entry in
2594 ** pp_action. Used to detect hash collisions.
2595 ** pp_shift_ofst[] For each state, the offset into pp_action for
2596 ** shifting terminals.
2597 ** pp_reduce_ofst[] For each state, the offset into pp_action for
2598 ** shifting non-terminals after a reduce.
2599 ** pp_default[] Default action for each state.
2600 */
2601 static PPACTIONTYPE pp_action[] = {
2602 /* 0 */ 120, 126, 55, 57, 59, 61, 63, 65, 45, 47,
2603 /* 10 */ 67, 72, 49, 51, 53, 41, 39, 43, 37, 34,
2604 /* 20 */ 122, 74, 69, 120, 126, 55, 57, 59, 61, 63,
2605 /* 30 */ 65, 45, 47, 67, 72, 49, 51, 53, 41, 39,
2606 /* 40 */ 43, 37, 34, 122, 74, 69, 37, 34, 122, 74,
2607 /* 50 */ 69, 166, 220, 92, 218, 45, 47, 67, 72, 49,
2608 /* 60 */ 51, 53, 41, 39, 43, 37, 34, 122, 74, 69,
2609 /* 70 */ 154, 429, 186, 91, 120, 126, 55, 57, 59, 61,
2610 /* 80 */ 63, 65, 45, 47, 67, 72, 49, 51, 53, 41,
2611 /* 90 */ 39, 43, 37, 34, 122, 74, 69, 120, 126, 55,
2612 /* 100 */ 57, 59, 61, 63, 65, 45, 47, 67, 72, 49,
2613 /* 110 */ 51, 53, 41, 39, 43, 37, 34, 122, 74, 69,
2614 /* 120 */ 19, 20, 21, 22, 23, 227, 32, 33, 67, 72,
2615 /* 130 */ 49, 51, 53, 41, 39, 43, 37, 34, 122, 74,
2616 /* 140 */ 69, 130, 238, 120, 126, 55, 57, 59, 61, 63,
2617 /* 150 */ 65, 45, 47, 67, 72, 49, 51, 53, 41, 39,
2618 /* 160 */ 43, 37, 34, 122, 74, 69, 41, 39, 43, 37,
2619 /* 170 */ 34, 122, 74, 69, 140, 8, 120, 126, 55, 57,
2620 /* 180 */ 59, 61, 63, 65, 45, 47, 67, 72, 49, 51,
2621 /* 190 */ 53, 41, 39, 43, 37, 34, 122, 74, 69, 120,
2622 /* 200 */ 126, 55, 57, 59, 61, 63, 65, 45, 47, 67,
2623 /* 210 */ 72, 49, 51, 53, 41, 39, 43, 37, 34, 122,
2624 /* 220 */ 74, 69, 120, 126, 55, 57, 59, 61, 63, 65,
2625 /* 230 */ 45, 47, 67, 72, 49, 51, 53, 41, 39, 43,
2626 /* 240 */ 37, 34, 122, 74, 69, 168, 109, 156, 35, 95,
2627 /* 250 */ 99, 169, 171, 26, 76, 151, 188, 81, 159, 160,
2628 /* 260 */ 82, 111, 209, 113, 114, 17, 146, 285, 192, 208,
2629 /* 270 */ 194, 196, 128, 200, 204, 222, 223, 455, 1, 2,
2630 /* 280 */ 3, 4, 5, 6, 199, 173, 284, 197, 174, 175,
2631 /* 290 */ 181, 182, 183, 133, 137, 143, 76, 149, 158, 24,
2632 /* 300 */ 212, 217, 178, 176, 177, 179, 180, 168, 135, 271,
2633 /* 310 */ 35, 249, 6, 169, 171, 287, 276, 110, 290, 173,
2634 /* 320 */ 159, 49, 51, 53, 41, 39, 43, 37, 34, 122,
2635 /* 330 */ 74, 69, 158, 384, 128, 430, 192, 208, 194, 196,
2636 /* 340 */ 80, 200, 204, 292, 210, 122, 74, 69, 84, 84,
2637 /* 350 */ 174, 175, 181, 182, 183, 133, 137, 143, 125, 149,
2638 /* 360 */ 107, 107, 95, 90, 178, 176, 177, 179, 180, 55,
2639 /* 370 */ 57, 59, 61, 63, 65, 45, 47, 67, 72, 49,
2640 /* 380 */ 51, 53, 41, 39, 43, 37, 34, 122, 74, 69,
2641 /* 390 */ 213, 274, 258, 35, 70, 228, 169, 171, 131, 109,
2642 /* 400 */ 245, 265, 6, 214, 259, 230, 279, 286, 282, 234,
2643 /* 410 */ 173, 83, 203, 6, 129, 201, 84, 128, 173, 152,
2644 /* 420 */ 154, 207, 186, 158, 205, 162, 244, 96, 107, 85,
2645 /* 430 */ 219, 158, 173, 174, 175, 181, 182, 183, 133, 137,
2646 /* 440 */ 143, 94, 149, 173, 7, 158, 102, 178, 176, 177,
2647 /* 450 */ 179, 180, 162, 232, 35, 89, 158, 169, 171, 184,
2648 /* 460 */ 76, 112, 113, 114, 159, 211, 215, 79, 94, 78,
2649 /* 470 */ 173, 226, 221, 217, 94, 6, 277, 240, 128, 160,
2650 /* 480 */ 165, 84, 98, 158, 250, 163, 184, 162, 103, 95,
2651 /* 490 */ 104, 173, 94, 107, 174, 175, 181, 182, 183, 133,
2652 /* 500 */ 137, 143, 92, 149, 158, 173, 108, 155, 178, 176,
2653 /* 510 */ 177, 179, 180, 168, 92, 224, 35, 258, 158, 169,
2654 /* 520 */ 171, 184, 100, 27, 258, 173, 159, 166, 216, 257,
2655 /* 530 */ 191, 115, 189, 254, 105, 173, 259, 124, 158, 69,
2656 /* 540 */ 128, 110, 173, 107, 166, 281, 282, 225, 158, 252,
2657 /* 550 */ 260, 31, 253, 10, 251, 158, 174, 175, 181, 182,
2658 /* 560 */ 183, 133, 137, 143, 233, 149, 107, 106, 42, 173,
2659 /* 570 */ 178, 176, 177, 179, 180, 30, 247, 35, 329, 245,
2660 /* 580 */ 169, 171, 158, 147, 31, 229, 173, 159, 123, 328,
2661 /* 590 */ 261, 332, 256, 270, 101, 327, 162, 173, 326, 158,
2662 /* 600 */ 325, 128, 173, 173, 242, 246, 206, 28, 237, 18,
2663 /* 610 */ 158, 50, 255, 202, 173, 158, 158, 174, 175, 181,
2664 /* 620 */ 182, 183, 133, 137, 143, 121, 149, 158, 239, 173,
2665 /* 630 */ 167, 178, 176, 177, 179, 180, 97, 269, 164, 119,
2666 /* 640 */ 148, 263, 158, 173, 324, 264, 173, 71, 15, 132,
2667 /* 650 */ 150, 267, 323, 161, 145, 256, 158, 173, 73, 158,
2668 /* 660 */ 134, 170, 172, 198, 62, 173, 322, 333, 173, 60,
2669 /* 670 */ 158, 262, 173, 66, 93, 266, 173, 195, 158, 173,
2670 /* 680 */ 173, 158, 173, 187, 139, 158, 136, 173, 268, 158,
2671 /* 690 */ 11, 173, 158, 158, 76, 158, 295, 185, 58, 340,
2672 /* 700 */ 158, 173, 173, 56, 158, 272, 236, 36, 321, 54,
2673 /* 710 */ 38, 383, 293, 157, 158, 158, 173, 127, 40, 273,
2674 /* 720 */ 193, 173, 275, 278, 173, 173, 280, 173, 173, 158,
2675 /* 730 */ 190, 173, 68, 52, 158, 173, 173, 158, 158, 138,
2676 /* 740 */ 158, 158, 48, 283, 158, 13, 25, 88, 158, 158,
2677 /* 750 */ 173, 173, 16, 248, 87, 86, 44, 46, 64, 297,
2678 /* 760 */ 173, 294, 141, 158, 158, 296, 142, 288, 153, 289,
2679 /* 770 */ 346, 173, 291, 158, 173, 173, 173, 12, 29, 75,
2680 /* 780 */ 77, 144, 9, 235, 158, 117, 241, 158, 158, 158,
2681 /* 790 */ 118, 231, 243, 296, 116, 14,
2682 };
2683 static PPCODETYPE pp_lookahead[] = {
2684 /* 0 */ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
2685 /* 10 */ 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
2686 /* 20 */ 21, 22, 23, 1, 2, 3, 4, 5, 6, 7,
2687 /* 30 */ 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
2688 /* 40 */ 18, 19, 20, 21, 22, 23, 19, 20, 21, 22,
2689 /* 50 */ 23, 25, 30, 25, 32, 9, 10, 11, 12, 13,
2690 /* 60 */ 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
2691 /* 70 */ 71, 45, 73, 45, 1, 2, 3, 4, 5, 6,
2692 /* 80 */ 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
2693 /* 90 */ 17, 18, 19, 20, 21, 22, 23, 1, 2, 3,
2694 /* 100 */ 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
2695 /* 110 */ 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
2696 /* 120 */ 60, 61, 62, 63, 64, 45, 53, 54, 11, 12,
2697 /* 130 */ 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
2698 /* 140 */ 23, 45, 56, 1, 2, 3, 4, 5, 6, 7,
2699 /* 150 */ 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
2700 /* 160 */ 18, 19, 20, 21, 22, 23, 16, 17, 18, 19,
2701 /* 170 */ 20, 21, 22, 23, 32, 88, 1, 2, 3, 4,
2702 /* 180 */ 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
2703 /* 190 */ 15, 16, 17, 18, 19, 20, 21, 22, 23, 1,
2704 /* 200 */ 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
2705 /* 210 */ 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
2706 /* 220 */ 22, 23, 1, 2, 3, 4, 5, 6, 7, 8,
2707 /* 230 */ 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
2708 /* 240 */ 19, 20, 21, 22, 23, 17, 31, 72, 20, 119,
2709 /* 250 */ 120, 23, 24, 51, 26, 127, 128, 96, 30, 44,
2710 /* 260 */ 25, 100, 101, 102, 103, 25, 68, 98, 33, 34,
2711 /* 270 */ 35, 36, 44, 38, 39, 28, 29, 80, 81, 82,
2712 /* 280 */ 83, 84, 85, 86, 34, 116, 117, 37, 60, 61,
2713 /* 290 */ 62, 63, 64, 65, 66, 67, 26, 69, 129, 59,
2714 /* 300 */ 97, 98, 74, 75, 76, 77, 78, 17, 82, 112,
2715 /* 310 */ 20, 41, 86, 23, 24, 118, 46, 30, 48, 116,
2716 /* 320 */ 30, 13, 14, 15, 16, 17, 18, 19, 20, 21,
2717 /* 330 */ 22, 23, 129, 0, 44, 45, 33, 34, 35, 36,
2718 /* 340 */ 95, 38, 39, 99, 99, 21, 22, 23, 104, 104,
2719 /* 350 */ 60, 61, 62, 63, 64, 65, 66, 67, 74, 69,
2720 /* 360 */ 116, 116, 119, 120, 74, 75, 76, 77, 78, 3,
2721 /* 370 */ 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
2722 /* 380 */ 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
2723 /* 390 */ 17, 58, 98, 20, 11, 12, 23, 24, 82, 31,
2724 /* 400 */ 98, 107, 86, 30, 110, 22, 114, 115, 116, 82,
2725 /* 410 */ 116, 99, 34, 86, 98, 37, 104, 44, 116, 70,
2726 /* 420 */ 71, 34, 73, 129, 37, 98, 124, 30, 116, 32,
2727 /* 430 */ 30, 129, 116, 60, 61, 62, 63, 64, 65, 66,
2728 /* 440 */ 67, 30, 69, 116, 87, 129, 49, 74, 75, 76,
2729 /* 450 */ 77, 78, 98, 126, 20, 44, 129, 23, 24, 132,
2730 /* 460 */ 26, 101, 102, 103, 30, 25, 31, 27, 30, 94,
2731 /* 470 */ 116, 82, 97, 98, 30, 86, 99, 55, 44, 44,
2732 /* 480 */ 126, 104, 44, 129, 42, 131, 132, 98, 44, 119,
2733 /* 490 */ 120, 116, 30, 116, 60, 61, 62, 63, 64, 65,
2734 /* 500 */ 66, 67, 25, 69, 129, 116, 30, 98, 74, 75,
2735 /* 510 */ 76, 77, 78, 17, 25, 126, 20, 98, 129, 23,
2736 /* 520 */ 24, 132, 45, 52, 98, 116, 30, 25, 17, 110,
2737 /* 530 */ 30, 104, 32, 107, 45, 116, 110, 23, 129, 23,
2738 /* 540 */ 44, 30, 116, 116, 25, 115, 116, 45, 129, 43,
2739 /* 550 */ 44, 98, 44, 90, 104, 129, 60, 61, 62, 63,
2740 /* 560 */ 64, 65, 66, 67, 45, 69, 116, 119, 98, 116,
2741 /* 570 */ 74, 75, 76, 77, 78, 122, 50, 20, 30, 98,
2742 /* 580 */ 23, 24, 129, 30, 98, 98, 116, 30, 74, 30,
2743 /* 590 */ 108, 0, 25, 111, 119, 30, 98, 116, 30, 129,
2744 /* 600 */ 30, 44, 116, 116, 123, 124, 34, 121, 122, 125,
2745 /* 610 */ 129, 98, 45, 34, 116, 129, 129, 60, 61, 62,
2746 /* 620 */ 63, 64, 65, 66, 67, 98, 69, 129, 98, 116,
2747 /* 630 */ 132, 74, 75, 76, 77, 78, 49, 30, 45, 98,
2748 /* 640 */ 45, 43, 129, 116, 30, 44, 116, 98, 58, 45,
2749 /* 650 */ 98, 25, 30, 130, 98, 25, 129, 116, 98, 129,
2750 /* 660 */ 44, 98, 98, 34, 98, 116, 30, 0, 116, 98,
2751 /* 670 */ 129, 45, 116, 98, 119, 45, 116, 34, 129, 116,
2752 /* 680 */ 116, 129, 116, 98, 98, 129, 45, 116, 111, 129,
2753 /* 690 */ 91, 116, 129, 129, 26, 129, 0, 28, 98, 0,
2754 /* 700 */ 129, 116, 116, 98, 129, 87, 98, 98, 30, 98,
2755 /* 710 */ 98, 0, 0, 98, 129, 129, 116, 98, 98, 113,
2756 /* 720 */ 34, 116, 125, 47, 116, 116, 25, 116, 116, 129,
2757 /* 730 */ 30, 116, 98, 98, 129, 116, 116, 129, 129, 44,
2758 /* 740 */ 129, 129, 98, 3, 129, 57, 125, 119, 129, 129,
2759 /* 750 */ 116, 116, 125, 98, 49, 30, 98, 98, 98, 0,
2760 /* 760 */ 116, 0, 30, 129, 129, 0, 45, 87, 128, 113,
2761 /* 770 */ 0, 116, 27, 129, 116, 116, 116, 92, 25, 44,
2762 /* 780 */ 93, 44, 89, 45, 129, 106, 52, 129, 129, 129,
2763 /* 790 */ 40, 44, 25, 133, 105, 46,
2764 };
2765 #define PP_SHIFT_USE_DFLT (-2)
2766 static short pp_shift_ofst[] = {
2767 /* 0 */ 270, 712, 761, 696, 765, 759, 526, 422, 86, 202,
2768 /* 10 */ 590, 688, -2, 749, -2, 60, 240, 60, -2, -2,
2769 /* 20 */ -2, -2, -2, -2, 60, -2, 471, 557, 753, 557,
2770 /* 30 */ -2, 73, -2, -2, 557, 557, 324, 557, 324, 557,
2771 /* 40 */ 27, 557, 27, 557, 27, 557, 117, 557, 117, 557,
2772 /* 50 */ 150, 557, 150, 557, 150, 557, 46, 557, 46, 557,
2773 /* 60 */ 46, 557, 46, 557, 46, 557, 46, 557, 308, 383,
2774 /* 70 */ 557, 516, 557, 308, 735, 228, 247, 373, 440, 476,
2775 /* 80 */ 235, -2, 476, -2, 397, 725, 705, 411, -2, 462,
2776 /* 90 */ 28, -2, 462, -2, -2, -2, 587, 438, 462, 477,
2777 /* 100 */ -2, -2, 444, 462, 489, -2, -2, -2, 368, 287,
2778 /* 110 */ -2, 303, -2, -2, 476, 500, 750, -2, 557, 221,
2779 /* 120 */ 557, 221, 514, -2, 284, -2, 557, 366, 434, 96,
2780 /* 130 */ -2, 604, -2, 616, 668, 641, -2, 695, 557, 142,
2781 /* 140 */ 732, 721, -2, 737, 557, 198, 553, 595, -2, 557,
2782 /* 150 */ -1, 349, -2, -2, 557, 175, 557, 221, -2, 215,
2783 /* 160 */ 669, 290, 221, 593, -2, 26, 496, -2, -2, 557,
2784 /* 170 */ 516, 557, 516, -2, -2, -2, -2, -2, -2, -2,
2785 /* 180 */ -2, -2, -2, -2, -2, -2, 557, 221, -2, 700,
2786 /* 190 */ -2, -2, 686, 678, 643, 636, 250, 629, 622, 614,
2787 /* 200 */ 378, 579, 570, 568, 387, 572, 565, 559, 548, -2,
2788 /* 210 */ -2, 373, -2, -2, 435, 511, -2, 22, 400, -2,
2789 /* 220 */ -2, -2, -2, -2, 502, -2, 80, -2, 557, 516,
2790 /* 230 */ 747, 228, 519, -2, 738, -2, 324, -2, 557, 221,
2791 /* 240 */ 734, 557, 767, 557, -2, 221, -2, 557, 221, 442,
2792 /* 250 */ 476, 506, 508, 557, 567, 591, 557, -2, 221, -2,
2793 /* 260 */ 607, 626, 598, 601, 557, 630, 667, 607, -2, -2,
2794 /* 270 */ -2, 526, 333, 699, 60, 711, 476, 676, 476, 701,
2795 /* 280 */ 476, -2, 740, 557, -2, 221, -2, 526, 333, 770,
2796 /* 290 */ 745, 476, -2,
2797 };
2798 #define PP_REDUCE_USE_DFLT (-1)
2799 static short pp_reduce_ofst[] = {
2800 /* 0 */ 197, -1, -1, -1, -1, -1, 357, 87, 693, 463,
2801 /* 10 */ 599, 685, -1, -1, -1, 627, -1, 484, -1, -1,
2802 /* 20 */ -1, -1, -1, -1, 621, -1, -1, 486, -1, 453,
2803 /* 30 */ -1, -1, -1, -1, 608, 609, -1, 612, -1, 620,
2804 /* 40 */ -1, 470, -1, 658, -1, 659, -1, 644, -1, 513,
2805 /* 50 */ -1, 635, -1, 611, -1, 605, -1, 600, -1, 571,
2806 /* 60 */ -1, 566, -1, 660, -1, 575, -1, 634, -1, -1,
2807 /* 70 */ 549, -1, 560, -1, -1, 389, 687, 375, -1, 245,
2808 /* 80 */ 161, -1, 312, -1, -1, -1, -1, 628, -1, 243,
2809 /* 90 */ -1, -1, 555, -1, -1, -1, -1, 475, 130, -1,
2810 /* 100 */ -1, -1, 448, 370, -1, -1, -1, -1, -1, -1,
2811 /* 110 */ -1, 360, -1, -1, 427, 689, 679, -1, 541, -1,
2812 /* 120 */ 527, -1, -1, -1, -1, -1, 619, -1, 316, -1,
2813 /* 130 */ -1, -1, -1, -1, 226, -1, -1, -1, 586, -1,
2814 /* 140 */ -1, -1, -1, -1, 556, -1, -1, -1, -1, 552,
2815 /* 150 */ 128, 640, -1, -1, 409, -1, 615, -1, -1, -1,
2816 /* 160 */ 523, 354, -1, -1, -1, -1, 498, -1, -1, 563,
2817 /* 170 */ -1, 564, -1, -1, -1, -1, -1, -1, -1, -1,
2818 /* 180 */ -1, -1, -1, -1, -1, -1, 585, -1, -1, -1,
2819 /* 190 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2820 /* 200 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
2821 /* 210 */ -1, 203, -1, -1, -1, -1, -1, -1, -1, -1,
2822 /* 220 */ -1, -1, -1, -1, -1, -1, -1, -1, 487, -1,
2823 /* 230 */ -1, 327, -1, -1, -1, -1, -1, -1, 530, -1,
2824 /* 240 */ -1, 481, -1, 302, -1, -1, -1, 655, -1, -1,
2825 /* 250 */ 450, -1, -1, 426, -1, -1, 419, -1, -1, -1,
2826 /* 260 */ 482, -1, -1, -1, 294, -1, -1, 577, -1, -1,
2827 /* 270 */ -1, 618, 606, -1, 597, -1, 377, -1, 292, -1,
2828 /* 280 */ 430, -1, -1, 169, -1, -1, -1, 680, 656, -1,
2829 /* 290 */ -1, 244, -1,
2830 };
2831 static PPACTIONTYPE pp_default[] = {
2832 /* 0 */ 454, 454, 454, 454, 454, 454, 362, 371, 376, 364,
2833 /* 10 */ 382, 378, 298, 454, 377, 454, 379, 454, 380, 385,
2834 /* 20 */ 386, 387, 388, 389, 454, 381, 454, 454, 363, 454,
2835 /* 30 */ 365, 367, 368, 369, 454, 454, 390, 454, 392, 454,
2836 /* 40 */ 393, 454, 394, 454, 395, 454, 396, 454, 397, 454,
2837 /* 50 */ 398, 454, 399, 454, 400, 454, 401, 454, 402, 454,
2838 /* 60 */ 403, 454, 404, 454, 405, 454, 406, 454, 407, 454,
2839 /* 70 */ 454, 408, 454, 409, 454, 454, 302, 454, 454, 454,
2840 /* 80 */ 313, 299, 454, 310, 350, 454, 348, 454, 351, 454,
2841 /* 90 */ 454, 352, 454, 357, 359, 358, 349, 454, 454, 454,
2842 /* 100 */ 353, 354, 454, 454, 454, 355, 356, 360, 453, 454,
2843 /* 110 */ 452, 312, 314, 316, 454, 320, 331, 317, 454, 330,
2844 /* 120 */ 454, 417, 454, 435, 454, 436, 454, 437, 454, 454,
2845 /* 130 */ 440, 454, 413, 454, 454, 454, 416, 454, 454, 454,
2846 /* 140 */ 454, 454, 418, 454, 454, 454, 454, 454, 419, 454,
2847 /* 150 */ 454, 454, 420, 421, 454, 454, 454, 423, 425, 453,
2848 /* 160 */ 428, 454, 434, 454, 426, 454, 454, 431, 433, 454,
2849 /* 170 */ 438, 454, 439, 441, 442, 443, 444, 445, 446, 447,
2850 /* 180 */ 448, 449, 450, 451, 432, 427, 454, 424, 422, 454,
2851 /* 190 */ 318, 319, 454, 454, 454, 454, 454, 454, 454, 454,
2852 /* 200 */ 454, 454, 454, 454, 454, 454, 454, 454, 454, 315,
2853 /* 210 */ 311, 454, 303, 305, 453, 454, 306, 309, 454, 307,
2854 /* 220 */ 308, 304, 300, 301, 454, 411, 454, 414, 454, 410,
2855 /* 230 */ 454, 454, 454, 412, 454, 415, 391, 366, 454, 375,
2856 /* 240 */ 454, 454, 370, 454, 372, 374, 373, 454, 361, 454,
2857 /* 250 */ 454, 454, 454, 454, 454, 454, 454, 334, 336, 335,
2858 /* 260 */ 454, 454, 454, 454, 454, 454, 454, 454, 337, 339,
2859 /* 270 */ 338, 362, 454, 454, 454, 454, 454, 454, 454, 341,
2860 /* 280 */ 454, 342, 454, 454, 344, 345, 343, 362, 454, 454,
2861 /* 290 */ 454, 454, 347,
2862 };
2863 #define PP_SZ_ACTTAB (sizeof(pp_action)/sizeof(pp_action[0]))
2864
2865 /* The next table maps tokens into fallback tokens. If a construct
2866 ** like the following:
2867 **
2868 ** %fallback ID X Y Z.
2869 **
2870 ** appears in the grammer, then ID becomes a fallback token for X, Y,
2871 ** and Z. Whenever one of the tokens X, Y, or Z is input to the parser
2872 ** but it does not parse, the type of the token is changed to ID and
2873 ** the parse is retried before an error is thrown.
2874 */
2875 #ifdef PPFALLBACK
2876 static const PPCODETYPE ppFallback[] = {
2877 };
2878 #endif /* PPFALLBACK */
2879
2880 /* The following structure represents a single element of the
2881 ** parser's stack. Information stored includes:
2882 **
2883 ** + The state number for the parser at this level of the stack.
2884 **
2885 ** + The value of the token stored at this level of the stack.
2886 ** (In other words, the "major" token.)
2887 **
2888 ** + The semantic value stored at this level of the stack. This is
2889 ** the information used by the action routines in the grammar.
2890 ** It is sometimes called the "minor" token.
2891 */
2892 struct ppStackEntry {
2893 int stateno; /* The state-number */
2894 int major; /* The major token value. This is the code
2895 ** number for the token at this stack level */
2896 PPMINORTYPE minor; /* The user-supplied minor token value. This
2897 ** is the value of the token */
2898 };
2899 typedef struct ppStackEntry ppStackEntry;
2900
2901 /* The state of the parser is completely contained in an instance of
2902 ** the following structure */
2903 struct ppParser {
2904 int ppidx; /* Index of top element in stack */
2905 int pperrcnt; /* Shifts left before out of the error */
2906 phql_ARG_SDECL /* A place to hold %extra_argument */
2907 ppStackEntry ppstack[PPSTACKDEPTH]; /* The parser's stack */
2908 };
2909 typedef struct ppParser ppParser;
2910
2911 #ifndef NDEBUG
2912 #include <stdio.h>
2913 static FILE *ppTraceFILE = 0;
2914 static char *ppTracePrompt = 0;
2915 #endif /* NDEBUG */
2916
2917 #ifndef NDEBUG
2918 /*
2919 ** Turn parser tracing on by giving a stream to which to write the trace
2920 ** and a prompt to preface each trace message. Tracing is turned off
2921 ** by making either argument NULL
2922 **
2923 ** Inputs:
2924 ** <ul>
2925 ** <li> A FILE* to which trace output should be written.
2926 ** If NULL, then tracing is turned off.
2927 ** <li> A prefix string written at the beginning of every
2928 ** line of trace output. If NULL, then tracing is
2929 ** turned off.
2930 ** </ul>
2931 **
2932 ** Outputs:
2933 ** None.
2934 */
phql_Trace(FILE * TraceFILE,char * zTracePrompt)2935 void phql_Trace(FILE *TraceFILE, char *zTracePrompt){
2936 ppTraceFILE = TraceFILE;
2937 ppTracePrompt = zTracePrompt;
2938 if( ppTraceFILE==0 ) ppTracePrompt = 0;
2939 else if( ppTracePrompt==0 ) ppTraceFILE = 0;
2940 }
2941 #endif /* NDEBUG */
2942
2943 #ifndef NDEBUG
2944 /* For tracing shifts, the names of all terminals and nonterminals
2945 ** are required. The following table supplies these names */
2946 static const char *ppTokenName[] = {
2947 "$", "AGAINST", "BETWEEN", "EQUALS",
2948 "NOTEQUALS", "LESS", "GREATER", "GREATEREQUAL",
2949 "LESSEQUAL", "AND", "OR", "LIKE",
2950 "ILIKE", "BITWISE_AND", "BITWISE_OR", "BITWISE_XOR",
2951 "DIVIDE", "TIMES", "MOD", "PLUS",
2952 "MINUS", "IS", "IN", "NOT",
2953 "BITWISE_NOT", "COMMA", "SELECT", "FROM",
2954 "DISTINCT", "ALL", "IDENTIFIER", "DOT",
2955 "AS", "INNER", "JOIN", "CROSS",
2956 "LEFT", "OUTER", "RIGHT", "FULL",
2957 "ON", "INSERT", "INTO", "VALUES",
2958 "PARENTHESES_OPEN", "PARENTHESES_CLOSE", "UPDATE", "SET",
2959 "DELETE", "WITH", "WHERE", "ORDER",
2960 "BY", "ASC", "DESC", "GROUP",
2961 "HAVING", "FOR", "LIMIT", "OFFSET",
2962 "INTEGER", "HINTEGER", "NPLACEHOLDER", "SPLACEHOLDER",
2963 "BPLACEHOLDER", "EXISTS", "CAST", "CONVERT",
2964 "USING", "CASE", "END", "WHEN",
2965 "THEN", "ELSE", "NULL", "STRING",
2966 "DOUBLE", "TRUE", "FALSE", "error",
2967 "program", "query_language", "select_statement", "insert_statement",
2968 "update_statement", "delete_statement", "select_clause", "where_clause",
2969 "group_clause", "having_clause", "order_clause", "select_limit_clause",
2970 "for_update_clause", "distinct_all", "column_list", "associated_name_list",
2971 "join_list_or_null", "column_item", "expr", "associated_name",
2972 "join_list", "join_item", "join_clause", "join_type",
2973 "aliased_or_qualified_name", "join_associated_name", "join_conditions", "values_list",
2974 "field_list", "value_list", "value_item", "field_item",
2975 "update_clause", "limit_clause", "update_item_list", "update_item",
2976 "qualified_name", "new_value", "delete_clause", "with_item",
2977 "with_list", "order_list", "order_item", "group_list",
2978 "group_item", "integer_or_placeholder", "argument_list", "when_clauses",
2979 "when_clause", "function_call", "distinct_or_null", "argument_list_or_null",
2980 "argument_item",
2981 };
2982 #endif /* NDEBUG */
2983
2984 #ifndef NDEBUG
2985 /* For tracing reduce actions, the names of all rules are required.
2986 */
2987 static const char *ppRuleName[] = {
2988 /* 0 */ "program ::= query_language",
2989 /* 1 */ "query_language ::= select_statement",
2990 /* 2 */ "query_language ::= insert_statement",
2991 /* 3 */ "query_language ::= update_statement",
2992 /* 4 */ "query_language ::= delete_statement",
2993 /* 5 */ "select_statement ::= select_clause where_clause group_clause having_clause order_clause select_limit_clause for_update_clause",
2994 /* 6 */ "select_clause ::= SELECT distinct_all column_list FROM associated_name_list join_list_or_null",
2995 /* 7 */ "distinct_all ::= DISTINCT",
2996 /* 8 */ "distinct_all ::= ALL",
2997 /* 9 */ "distinct_all ::=",
2998 /* 10 */ "column_list ::= column_list COMMA column_item",
2999 /* 11 */ "column_list ::= column_item",
3000 /* 12 */ "column_item ::= TIMES",
3001 /* 13 */ "column_item ::= IDENTIFIER DOT TIMES",
3002 /* 14 */ "column_item ::= expr AS IDENTIFIER",
3003 /* 15 */ "column_item ::= expr IDENTIFIER",
3004 /* 16 */ "column_item ::= expr",
3005 /* 17 */ "associated_name_list ::= associated_name_list COMMA associated_name",
3006 /* 18 */ "associated_name_list ::= associated_name",
3007 /* 19 */ "join_list_or_null ::= join_list",
3008 /* 20 */ "join_list_or_null ::=",
3009 /* 21 */ "join_list ::= join_list join_item",
3010 /* 22 */ "join_list ::= join_item",
3011 /* 23 */ "join_item ::= join_clause",
3012 /* 24 */ "join_clause ::= join_type aliased_or_qualified_name join_associated_name join_conditions",
3013 /* 25 */ "join_associated_name ::= AS IDENTIFIER",
3014 /* 26 */ "join_associated_name ::= IDENTIFIER",
3015 /* 27 */ "join_associated_name ::=",
3016 /* 28 */ "join_type ::= INNER JOIN",
3017 /* 29 */ "join_type ::= CROSS JOIN",
3018 /* 30 */ "join_type ::= LEFT OUTER JOIN",
3019 /* 31 */ "join_type ::= LEFT JOIN",
3020 /* 32 */ "join_type ::= RIGHT OUTER JOIN",
3021 /* 33 */ "join_type ::= RIGHT JOIN",
3022 /* 34 */ "join_type ::= FULL OUTER JOIN",
3023 /* 35 */ "join_type ::= FULL JOIN",
3024 /* 36 */ "join_type ::= JOIN",
3025 /* 37 */ "join_conditions ::= ON expr",
3026 /* 38 */ "join_conditions ::=",
3027 /* 39 */ "insert_statement ::= INSERT INTO aliased_or_qualified_name VALUES PARENTHESES_OPEN values_list PARENTHESES_CLOSE",
3028 /* 40 */ "insert_statement ::= INSERT INTO aliased_or_qualified_name PARENTHESES_OPEN field_list PARENTHESES_CLOSE VALUES PARENTHESES_OPEN values_list PARENTHESES_CLOSE",
3029 /* 41 */ "values_list ::= values_list COMMA value_item",
3030 /* 42 */ "values_list ::= value_item",
3031 /* 43 */ "value_item ::= expr",
3032 /* 44 */ "field_list ::= field_list COMMA field_item",
3033 /* 45 */ "field_list ::= field_item",
3034 /* 46 */ "field_item ::= IDENTIFIER",
3035 /* 47 */ "update_statement ::= update_clause where_clause limit_clause",
3036 /* 48 */ "update_clause ::= UPDATE associated_name SET update_item_list",
3037 /* 49 */ "update_item_list ::= update_item_list COMMA update_item",
3038 /* 50 */ "update_item_list ::= update_item",
3039 /* 51 */ "update_item ::= qualified_name EQUALS new_value",
3040 /* 52 */ "new_value ::= expr",
3041 /* 53 */ "delete_statement ::= delete_clause where_clause limit_clause",
3042 /* 54 */ "delete_clause ::= DELETE FROM associated_name",
3043 /* 55 */ "associated_name ::= aliased_or_qualified_name AS IDENTIFIER",
3044 /* 56 */ "associated_name ::= aliased_or_qualified_name IDENTIFIER",
3045 /* 57 */ "associated_name ::= aliased_or_qualified_name",
3046 /* 58 */ "associated_name ::= aliased_or_qualified_name AS IDENTIFIER WITH with_item",
3047 /* 59 */ "associated_name ::= aliased_or_qualified_name AS IDENTIFIER WITH PARENTHESES_OPEN with_list PARENTHESES_CLOSE",
3048 /* 60 */ "associated_name ::= aliased_or_qualified_name IDENTIFIER WITH PARENTHESES_OPEN with_list PARENTHESES_CLOSE",
3049 /* 61 */ "associated_name ::= aliased_or_qualified_name IDENTIFIER WITH with_item",
3050 /* 62 */ "associated_name ::= aliased_or_qualified_name WITH PARENTHESES_OPEN with_list PARENTHESES_CLOSE",
3051 /* 63 */ "associated_name ::= aliased_or_qualified_name WITH with_item",
3052 /* 64 */ "with_list ::= with_list COMMA with_item",
3053 /* 65 */ "with_list ::= with_item",
3054 /* 66 */ "with_item ::= IDENTIFIER",
3055 /* 67 */ "aliased_or_qualified_name ::= qualified_name",
3056 /* 68 */ "where_clause ::= WHERE expr",
3057 /* 69 */ "where_clause ::=",
3058 /* 70 */ "order_clause ::= ORDER BY order_list",
3059 /* 71 */ "order_clause ::=",
3060 /* 72 */ "order_list ::= order_list COMMA order_item",
3061 /* 73 */ "order_list ::= order_item",
3062 /* 74 */ "order_item ::= expr",
3063 /* 75 */ "order_item ::= expr ASC",
3064 /* 76 */ "order_item ::= expr DESC",
3065 /* 77 */ "group_clause ::= GROUP BY group_list",
3066 /* 78 */ "group_clause ::=",
3067 /* 79 */ "group_list ::= group_list COMMA group_item",
3068 /* 80 */ "group_list ::= group_item",
3069 /* 81 */ "group_item ::= expr",
3070 /* 82 */ "having_clause ::= HAVING expr",
3071 /* 83 */ "having_clause ::=",
3072 /* 84 */ "for_update_clause ::= FOR UPDATE",
3073 /* 85 */ "for_update_clause ::=",
3074 /* 86 */ "select_limit_clause ::= LIMIT integer_or_placeholder",
3075 /* 87 */ "select_limit_clause ::= LIMIT integer_or_placeholder COMMA integer_or_placeholder",
3076 /* 88 */ "select_limit_clause ::= LIMIT integer_or_placeholder OFFSET integer_or_placeholder",
3077 /* 89 */ "select_limit_clause ::=",
3078 /* 90 */ "limit_clause ::= LIMIT integer_or_placeholder",
3079 /* 91 */ "limit_clause ::=",
3080 /* 92 */ "integer_or_placeholder ::= INTEGER",
3081 /* 93 */ "integer_or_placeholder ::= HINTEGER",
3082 /* 94 */ "integer_or_placeholder ::= NPLACEHOLDER",
3083 /* 95 */ "integer_or_placeholder ::= SPLACEHOLDER",
3084 /* 96 */ "integer_or_placeholder ::= BPLACEHOLDER",
3085 /* 97 */ "expr ::= MINUS expr",
3086 /* 98 */ "expr ::= expr MINUS expr",
3087 /* 99 */ "expr ::= expr PLUS expr",
3088 /* 100 */ "expr ::= expr TIMES expr",
3089 /* 101 */ "expr ::= expr DIVIDE expr",
3090 /* 102 */ "expr ::= expr MOD expr",
3091 /* 103 */ "expr ::= expr AND expr",
3092 /* 104 */ "expr ::= expr OR expr",
3093 /* 105 */ "expr ::= expr BITWISE_AND expr",
3094 /* 106 */ "expr ::= expr BITWISE_OR expr",
3095 /* 107 */ "expr ::= expr BITWISE_XOR expr",
3096 /* 108 */ "expr ::= expr EQUALS expr",
3097 /* 109 */ "expr ::= expr NOTEQUALS expr",
3098 /* 110 */ "expr ::= expr LESS expr",
3099 /* 111 */ "expr ::= expr GREATER expr",
3100 /* 112 */ "expr ::= expr GREATEREQUAL expr",
3101 /* 113 */ "expr ::= expr LESSEQUAL expr",
3102 /* 114 */ "expr ::= expr LIKE expr",
3103 /* 115 */ "expr ::= expr NOT LIKE expr",
3104 /* 116 */ "expr ::= expr ILIKE expr",
3105 /* 117 */ "expr ::= expr NOT ILIKE expr",
3106 /* 118 */ "expr ::= expr IN PARENTHESES_OPEN argument_list PARENTHESES_CLOSE",
3107 /* 119 */ "expr ::= expr NOT IN PARENTHESES_OPEN argument_list PARENTHESES_CLOSE",
3108 /* 120 */ "expr ::= PARENTHESES_OPEN select_statement PARENTHESES_CLOSE",
3109 /* 121 */ "expr ::= expr IN PARENTHESES_OPEN select_statement PARENTHESES_CLOSE",
3110 /* 122 */ "expr ::= expr NOT IN PARENTHESES_OPEN select_statement PARENTHESES_CLOSE",
3111 /* 123 */ "expr ::= EXISTS PARENTHESES_OPEN select_statement PARENTHESES_CLOSE",
3112 /* 124 */ "expr ::= expr AGAINST expr",
3113 /* 125 */ "expr ::= CAST PARENTHESES_OPEN expr AS IDENTIFIER PARENTHESES_CLOSE",
3114 /* 126 */ "expr ::= CONVERT PARENTHESES_OPEN expr USING IDENTIFIER PARENTHESES_CLOSE",
3115 /* 127 */ "expr ::= CASE expr when_clauses END",
3116 /* 128 */ "when_clauses ::= when_clauses when_clause",
3117 /* 129 */ "when_clauses ::= when_clause",
3118 /* 130 */ "when_clause ::= WHEN expr THEN expr",
3119 /* 131 */ "when_clause ::= ELSE expr",
3120 /* 132 */ "expr ::= function_call",
3121 /* 133 */ "function_call ::= IDENTIFIER PARENTHESES_OPEN distinct_or_null argument_list_or_null PARENTHESES_CLOSE",
3122 /* 134 */ "distinct_or_null ::= DISTINCT",
3123 /* 135 */ "distinct_or_null ::=",
3124 /* 136 */ "argument_list_or_null ::= argument_list",
3125 /* 137 */ "argument_list_or_null ::=",
3126 /* 138 */ "argument_list ::= argument_list COMMA argument_item",
3127 /* 139 */ "argument_list ::= argument_item",
3128 /* 140 */ "argument_item ::= TIMES",
3129 /* 141 */ "argument_item ::= expr",
3130 /* 142 */ "expr ::= expr IS NULL",
3131 /* 143 */ "expr ::= expr IS NOT NULL",
3132 /* 144 */ "expr ::= expr BETWEEN expr",
3133 /* 145 */ "expr ::= NOT expr",
3134 /* 146 */ "expr ::= BITWISE_NOT expr",
3135 /* 147 */ "expr ::= PARENTHESES_OPEN expr PARENTHESES_CLOSE",
3136 /* 148 */ "expr ::= qualified_name",
3137 /* 149 */ "expr ::= INTEGER",
3138 /* 150 */ "expr ::= HINTEGER",
3139 /* 151 */ "expr ::= STRING",
3140 /* 152 */ "expr ::= DOUBLE",
3141 /* 153 */ "expr ::= NULL",
3142 /* 154 */ "expr ::= TRUE",
3143 /* 155 */ "expr ::= FALSE",
3144 /* 156 */ "expr ::= NPLACEHOLDER",
3145 /* 157 */ "expr ::= SPLACEHOLDER",
3146 /* 158 */ "expr ::= BPLACEHOLDER",
3147 /* 159 */ "qualified_name ::= IDENTIFIER DOT IDENTIFIER",
3148 /* 160 */ "qualified_name ::= IDENTIFIER",
3149 };
3150 #endif /* NDEBUG */
3151
3152 /*
3153 ** This function returns the symbolic name associated with a token
3154 ** value.
3155 */
phql_TokenName(int tokenType)3156 const char *phql_TokenName(int tokenType){
3157 #ifndef NDEBUG
3158 if( tokenType>0 && tokenType<(sizeof(ppTokenName)/sizeof(ppTokenName[0])) ){
3159 return ppTokenName[tokenType];
3160 }else{
3161 return "Unknown";
3162 }
3163 #else
3164 return "";
3165 #endif
3166 }
3167
3168 /*
3169 ** This function allocates a new parser.
3170 ** The only argument is a pointer to a function which works like
3171 ** malloc.
3172 **
3173 ** Inputs:
3174 ** A pointer to the function used to allocate memory.
3175 **
3176 ** Outputs:
3177 ** A pointer to a parser. This pointer is used in subsequent calls
3178 ** to phql_ and phql_Free.
3179 */
phql_Alloc(void * (* mallocProc)(size_t))3180 void *phql_Alloc(void *(*mallocProc)(size_t)){
3181 ppParser *pParser;
3182 pParser = (ppParser*)(*mallocProc)( (size_t)sizeof(ppParser) );
3183 if( pParser ){
3184 pParser->ppidx = -1;
3185 }
3186 return pParser;
3187 }
3188
3189 /* The following function deletes the value associated with a
3190 ** symbol. The symbol can be either a terminal or nonterminal.
3191 ** "ppmajor" is the symbol code, and "pppminor" is a pointer to
3192 ** the value.
3193 */
pp_destructor(PPCODETYPE ppmajor,PPMINORTYPE * pppminor)3194 static void pp_destructor(PPCODETYPE ppmajor, PPMINORTYPE *pppminor){
3195 switch( ppmajor ){
3196 /* Here is inserted the actions which take place when a
3197 ** terminal or non-terminal is destroyed. This can happen
3198 ** when the symbol is popped from the stack during a
3199 ** reduce or during error processing or when a parser is
3200 ** being destroyed before it is finished parsing.
3201 **
3202 ** Note: during a reduce, the only symbols destroyed are those
3203 ** which appear on the RHS of the rule, but which are not used
3204 ** inside the C code.
3205 */
3206 case 1:
3207 case 2:
3208 case 3:
3209 case 4:
3210 case 5:
3211 case 6:
3212 case 7:
3213 case 8:
3214 case 9:
3215 case 10:
3216 case 11:
3217 case 12:
3218 case 13:
3219 case 14:
3220 case 15:
3221 case 16:
3222 case 17:
3223 case 18:
3224 case 19:
3225 case 20:
3226 case 21:
3227 case 22:
3228 case 23:
3229 case 24:
3230 case 25:
3231 case 26:
3232 case 27:
3233 case 28:
3234 case 29:
3235 case 30:
3236 case 31:
3237 case 32:
3238 case 33:
3239 case 34:
3240 case 35:
3241 case 36:
3242 case 37:
3243 case 38:
3244 case 39:
3245 case 40:
3246 case 41:
3247 case 42:
3248 case 43:
3249 case 44:
3250 case 45:
3251 case 46:
3252 case 47:
3253 case 48:
3254 case 49:
3255 case 50:
3256 case 51:
3257 case 52:
3258 case 53:
3259 case 54:
3260 case 55:
3261 case 56:
3262 case 57:
3263 case 58:
3264 case 59:
3265 case 60:
3266 case 61:
3267 case 62:
3268 case 63:
3269 case 64:
3270 case 65:
3271 case 66:
3272 case 67:
3273 case 68:
3274 case 69:
3275 case 70:
3276 case 71:
3277 case 72:
3278 case 73:
3279 case 74:
3280 case 75:
3281 case 76:
3282 case 77:
3283 case 78:
3284 // 110 "parser.php7.lemon"
3285 {
3286 if ((pppminor->pp0)) {
3287 if ((pppminor->pp0)->free_flag) {
3288 efree((pppminor->pp0)->token);
3289 }
3290 efree((pppminor->pp0));
3291 }
3292 }
3293 // 822 "parser.php7.c"
3294 break;
3295 case 81:
3296 case 82:
3297 case 83:
3298 case 84:
3299 case 85:
3300 case 86:
3301 case 88:
3302 case 94:
3303 case 95:
3304 case 97:
3305 case 98:
3306 case 99:
3307 case 100:
3308 case 101:
3309 case 102:
3310 case 103:
3311 case 104:
3312 case 108:
3313 case 109:
3314 case 111:
3315 case 112:
3316 case 114:
3317 case 115:
3318 case 118:
3319 case 119:
3320 case 120:
3321 case 121:
3322 case 122:
3323 case 123:
3324 // 123 "parser.php7.lemon"
3325 {
3326 zval_ptr_dtor(&(pppminor->pp204));
3327 }
3328 // 857 "parser.php7.c"
3329 break;
3330 case 87:
3331 case 89:
3332 case 90:
3333 case 91:
3334 case 92:
3335 case 93:
3336 case 105:
3337 case 106:
3338 case 113:
3339 case 130:
3340 case 131:
3341 // 505 "parser.php7.lemon"
3342 {
3343 zephir_safe_zval_ptr_dtor((pppminor->pp204));
3344 }
3345 // 874 "parser.php7.c"
3346 break;
3347 case 116:
3348 case 124:
3349 case 126:
3350 case 129:
3351 case 132:
3352 // 948 "parser.php7.lemon"
3353 {
3354 zval_ptr_dtor(&(pppminor->pp204));
3355 }
3356 // 885 "parser.php7.c"
3357 break;
3358 default: break; /* If no destructor action specified: do nothing */
3359 }
3360 }
3361
3362 /*
3363 ** Pop the parser's stack once.
3364 **
3365 ** If there is a destructor routine associated with the token which
3366 ** is popped from the stack, then call it.
3367 **
3368 ** Return the major token number for the symbol popped.
3369 */
pp_pop_parser_stack(ppParser * pParser)3370 static int pp_pop_parser_stack(ppParser *pParser){
3371 PPCODETYPE ppmajor;
3372 ppStackEntry *pptos = &pParser->ppstack[pParser->ppidx];
3373
3374 if( pParser->ppidx<0 ) return 0;
3375 #ifndef NDEBUG
3376 if( ppTraceFILE && pParser->ppidx>=0 ){
3377 fprintf(ppTraceFILE,"%sPopping %s\n",
3378 ppTracePrompt,
3379 ppTokenName[pptos->major]);
3380 }
3381 #endif
3382 ppmajor = pptos->major;
3383 pp_destructor( ppmajor, &pptos->minor);
3384 pParser->ppidx--;
3385 return ppmajor;
3386 }
3387
3388 /*
3389 ** Deallocate and destroy a parser. Destructors are all called for
3390 ** all stack elements before shutting the parser down.
3391 **
3392 ** Inputs:
3393 ** <ul>
3394 ** <li> A pointer to the parser. This should be a pointer
3395 ** obtained from phql_Alloc.
3396 ** <li> A pointer to a function used to reclaim memory obtained
3397 ** from malloc.
3398 ** </ul>
3399 */
phql_Free(void * p,void (* freeProc)(void *))3400 void phql_Free(
3401 void *p, /* The parser to be deleted */
3402 void (*freeProc)(void*) /* Function used to reclaim memory */
3403 ){
3404 ppParser *pParser = (ppParser*)p;
3405 if( pParser==0 ) return;
3406 while( pParser->ppidx>=0 ) pp_pop_parser_stack(pParser);
3407 (*freeProc)((void*)pParser);
3408 }
3409
3410 /*
3411 ** Find the appropriate action for a parser given the terminal
3412 ** look-ahead token iLookAhead.
3413 **
3414 ** If the look-ahead token is PPNOCODE, then check to see if the action is
3415 ** independent of the look-ahead. If it is, return the action, otherwise
3416 ** return PP_NO_ACTION.
3417 */
pp_find_shift_action(ppParser * pParser,int iLookAhead)3418 static int pp_find_shift_action(
3419 ppParser *pParser, /* The parser */
3420 int iLookAhead /* The look-ahead token */
3421 ){
3422 int i;
3423 int stateno = pParser->ppstack[pParser->ppidx].stateno;
3424
3425 /* if( pParser->ppidx<0 ) return PP_NO_ACTION; */
3426 i = pp_shift_ofst[stateno];
3427 if( i==PP_SHIFT_USE_DFLT ){
3428 return pp_default[stateno];
3429 }
3430 if( iLookAhead==PPNOCODE ){
3431 return PP_NO_ACTION;
3432 }
3433 i += iLookAhead;
3434 if( i<0 || i>=PP_SZ_ACTTAB || pp_lookahead[i]!=iLookAhead ){
3435 #ifdef PPFALLBACK
3436 int iFallback; /* Fallback token */
3437 if( iLookAhead<sizeof(ppFallback)/sizeof(ppFallback[0])
3438 && (iFallback = ppFallback[iLookAhead])!=0 ){
3439 #ifndef NDEBUG
3440 if( ppTraceFILE ){
3441 fprintf(ppTraceFILE, "%sFALLBACK %s => %s\n",
3442 ppTracePrompt, ppTokenName[iLookAhead], ppTokenName[iFallback]);
3443 }
3444 #endif
3445 return pp_find_shift_action(pParser, iFallback);
3446 }
3447 #endif
3448 return pp_default[stateno];
3449 }else{
3450 return pp_action[i];
3451 }
3452 }
3453
3454 /*
3455 ** Find the appropriate action for a parser given the non-terminal
3456 ** look-ahead token iLookAhead.
3457 **
3458 ** If the look-ahead token is PPNOCODE, then check to see if the action is
3459 ** independent of the look-ahead. If it is, return the action, otherwise
3460 ** return PP_NO_ACTION.
3461 */
pp_find_reduce_action(ppParser * pParser,int iLookAhead)3462 static int pp_find_reduce_action(
3463 ppParser *pParser, /* The parser */
3464 int iLookAhead /* The look-ahead token */
3465 ){
3466 int i;
3467 int stateno = pParser->ppstack[pParser->ppidx].stateno;
3468
3469 i = pp_reduce_ofst[stateno];
3470 if( i==PP_REDUCE_USE_DFLT ){
3471 return pp_default[stateno];
3472 }
3473 if( iLookAhead==PPNOCODE ){
3474 return PP_NO_ACTION;
3475 }
3476 i += iLookAhead;
3477 if( i<0 || i>=PP_SZ_ACTTAB || pp_lookahead[i]!=iLookAhead ){
3478 return pp_default[stateno];
3479 }else{
3480 return pp_action[i];
3481 }
3482 }
3483
3484 /*
3485 ** Perform a shift action.
3486 */
pp_shift(ppParser * pppParser,int ppNewState,int ppMajor,PPMINORTYPE * pppMinor)3487 static void pp_shift(
3488 ppParser *pppParser, /* The parser to be shifted */
3489 int ppNewState, /* The new state to shift in */
3490 int ppMajor, /* The major token to shift in */
3491 PPMINORTYPE *pppMinor /* Pointer ot the minor token to shift in */
3492 ){
3493 ppStackEntry *pptos;
3494 pppParser->ppidx++;
3495 if( pppParser->ppidx>=PPSTACKDEPTH ){
3496 phql_ARG_FETCH;
3497 pppParser->ppidx--;
3498 #ifndef NDEBUG
3499 if( ppTraceFILE ){
3500 fprintf(ppTraceFILE,"%sStack Overflow!\n",ppTracePrompt);
3501 }
3502 #endif
3503 while( pppParser->ppidx>=0 ) pp_pop_parser_stack(pppParser);
3504 /* Here code is inserted which will execute if the parser
3505 ** stack every overflows */
3506 phql_ARG_STORE; /* Suppress warning about unused %extra_argument var */
3507 return;
3508 }
3509 pptos = &pppParser->ppstack[pppParser->ppidx];
3510 pptos->stateno = ppNewState;
3511 pptos->major = ppMajor;
3512 pptos->minor = *pppMinor;
3513 #ifndef NDEBUG
3514 if( ppTraceFILE && pppParser->ppidx>0 ){
3515 int i;
3516 fprintf(ppTraceFILE,"%sShift %d\n",ppTracePrompt,ppNewState);
3517 fprintf(ppTraceFILE,"%sStack:",ppTracePrompt);
3518 for(i=1; i<=pppParser->ppidx; i++)
3519 fprintf(ppTraceFILE," %s",ppTokenName[pppParser->ppstack[i].major]);
3520 fprintf(ppTraceFILE,"\n");
3521 }
3522 #endif
3523 }
3524
3525 /* The following table contains information about every rule that
3526 ** is used during the reduce.
3527 */
3528 static struct {
3529 PPCODETYPE lhs; /* Symbol on the left-hand side of the rule */
3530 unsigned char nrhs; /* Number of right-hand side symbols in the rule */
3531 } ppRuleInfo[] = {
3532 { 80, 1 },
3533 { 81, 1 },
3534 { 81, 1 },
3535 { 81, 1 },
3536 { 81, 1 },
3537 { 82, 7 },
3538 { 86, 6 },
3539 { 93, 1 },
3540 { 93, 1 },
3541 { 93, 0 },
3542 { 94, 3 },
3543 { 94, 1 },
3544 { 97, 1 },
3545 { 97, 3 },
3546 { 97, 3 },
3547 { 97, 2 },
3548 { 97, 1 },
3549 { 95, 3 },
3550 { 95, 1 },
3551 { 96, 1 },
3552 { 96, 0 },
3553 { 100, 2 },
3554 { 100, 1 },
3555 { 101, 1 },
3556 { 102, 4 },
3557 { 105, 2 },
3558 { 105, 1 },
3559 { 105, 0 },
3560 { 103, 2 },
3561 { 103, 2 },
3562 { 103, 3 },
3563 { 103, 2 },
3564 { 103, 3 },
3565 { 103, 2 },
3566 { 103, 3 },
3567 { 103, 2 },
3568 { 103, 1 },
3569 { 106, 2 },
3570 { 106, 0 },
3571 { 83, 7 },
3572 { 83, 10 },
3573 { 107, 3 },
3574 { 107, 1 },
3575 { 110, 1 },
3576 { 108, 3 },
3577 { 108, 1 },
3578 { 111, 1 },
3579 { 84, 3 },
3580 { 112, 4 },
3581 { 114, 3 },
3582 { 114, 1 },
3583 { 115, 3 },
3584 { 117, 1 },
3585 { 85, 3 },
3586 { 118, 3 },
3587 { 99, 3 },
3588 { 99, 2 },
3589 { 99, 1 },
3590 { 99, 5 },
3591 { 99, 7 },
3592 { 99, 6 },
3593 { 99, 4 },
3594 { 99, 5 },
3595 { 99, 3 },
3596 { 120, 3 },
3597 { 120, 1 },
3598 { 119, 1 },
3599 { 104, 1 },
3600 { 87, 2 },
3601 { 87, 0 },
3602 { 90, 3 },
3603 { 90, 0 },
3604 { 121, 3 },
3605 { 121, 1 },
3606 { 122, 1 },
3607 { 122, 2 },
3608 { 122, 2 },
3609 { 88, 3 },
3610 { 88, 0 },
3611 { 123, 3 },
3612 { 123, 1 },
3613 { 124, 1 },
3614 { 89, 2 },
3615 { 89, 0 },
3616 { 92, 2 },
3617 { 92, 0 },
3618 { 91, 2 },
3619 { 91, 4 },
3620 { 91, 4 },
3621 { 91, 0 },
3622 { 113, 2 },
3623 { 113, 0 },
3624 { 125, 1 },
3625 { 125, 1 },
3626 { 125, 1 },
3627 { 125, 1 },
3628 { 125, 1 },
3629 { 98, 2 },
3630 { 98, 3 },
3631 { 98, 3 },
3632 { 98, 3 },
3633 { 98, 3 },
3634 { 98, 3 },
3635 { 98, 3 },
3636 { 98, 3 },
3637 { 98, 3 },
3638 { 98, 3 },
3639 { 98, 3 },
3640 { 98, 3 },
3641 { 98, 3 },
3642 { 98, 3 },
3643 { 98, 3 },
3644 { 98, 3 },
3645 { 98, 3 },
3646 { 98, 3 },
3647 { 98, 4 },
3648 { 98, 3 },
3649 { 98, 4 },
3650 { 98, 5 },
3651 { 98, 6 },
3652 { 98, 3 },
3653 { 98, 5 },
3654 { 98, 6 },
3655 { 98, 4 },
3656 { 98, 3 },
3657 { 98, 6 },
3658 { 98, 6 },
3659 { 98, 4 },
3660 { 127, 2 },
3661 { 127, 1 },
3662 { 128, 4 },
3663 { 128, 2 },
3664 { 98, 1 },
3665 { 129, 5 },
3666 { 130, 1 },
3667 { 130, 0 },
3668 { 131, 1 },
3669 { 131, 0 },
3670 { 126, 3 },
3671 { 126, 1 },
3672 { 132, 1 },
3673 { 132, 1 },
3674 { 98, 3 },
3675 { 98, 4 },
3676 { 98, 3 },
3677 { 98, 2 },
3678 { 98, 2 },
3679 { 98, 3 },
3680 { 98, 1 },
3681 { 98, 1 },
3682 { 98, 1 },
3683 { 98, 1 },
3684 { 98, 1 },
3685 { 98, 1 },
3686 { 98, 1 },
3687 { 98, 1 },
3688 { 98, 1 },
3689 { 98, 1 },
3690 { 98, 1 },
3691 { 116, 3 },
3692 { 116, 1 },
3693 };
3694
3695 static void pp_accept(ppParser*); /* Forward Declaration */
3696
3697 /*
3698 ** Perform a reduce action and the shift that must immediately
3699 ** follow the reduce.
3700 */
pp_reduce(ppParser * pppParser,int ppruleno)3701 static void pp_reduce(
3702 ppParser *pppParser, /* The parser */
3703 int ppruleno /* Number of the rule by which to reduce */
3704 ){
3705 int ppgoto; /* The next state */
3706 int ppact; /* The next action */
3707 PPMINORTYPE ppgotominor; /* The LHS of the rule reduced */
3708 ppStackEntry *ppmsp; /* The top of the parser's stack */
3709 int ppsize; /* Amount to pop the stack */
3710 phql_ARG_FETCH;
3711 ppmsp = &pppParser->ppstack[pppParser->ppidx];
3712 #ifndef NDEBUG
3713 if( ppTraceFILE && ppruleno>=0
3714 && ppruleno<sizeof(ppRuleName)/sizeof(ppRuleName[0]) ){
3715 fprintf(ppTraceFILE, "%sReduce [%s].\n", ppTracePrompt,
3716 ppRuleName[ppruleno]);
3717 }
3718 #endif /* NDEBUG */
3719
3720 switch( ppruleno ){
3721 /* Beginning here are the reduction cases. A typical example
3722 ** follows:
3723 ** case 0:
3724 ** // <lineno> <grammarfile>
3725 ** { ... } // User supplied code
3726 ** // <lineno> <thisfile>
3727 ** break;
3728 */
3729 case 0:
3730 // 119 "parser.php7.lemon"
3731 {
3732 ZVAL_ZVAL(&status->ret, &ppmsp[0].minor.pp204, 1, 1);
3733 }
3734 // 1263 "parser.php7.c"
3735 break;
3736 case 1:
3737 case 2:
3738 case 3:
3739 case 4:
3740 case 18:
3741 case 19:
3742 case 22:
3743 case 23:
3744 case 43:
3745 case 50:
3746 case 52:
3747 case 65:
3748 case 67:
3749 case 73:
3750 case 80:
3751 case 81:
3752 case 132:
3753 case 136:
3754 case 141:
3755 case 148:
3756 // 127 "parser.php7.lemon"
3757 {
3758 ppgotominor.pp204 = ppmsp[0].minor.pp204;
3759 }
3760 // 1289 "parser.php7.c"
3761 break;
3762 case 5:
3763 // 147 "parser.php7.lemon"
3764 {
3765 phql_ret_select_statement(&ppgotominor.pp204, &ppmsp[-6].minor.pp204, &ppmsp[-5].minor.pp204, &ppmsp[-2].minor.pp204, &ppmsp[-4].minor.pp204, &ppmsp[-3].minor.pp204, &ppmsp[-1].minor.pp204, &ppmsp[0].minor.pp204);
3766 }
3767 // 1296 "parser.php7.c"
3768 break;
3769 case 6:
3770 // 155 "parser.php7.lemon"
3771 {
3772 phql_ret_select_clause(&ppgotominor.pp204, &ppmsp[-4].minor.pp204, &ppmsp[-3].minor.pp204, &ppmsp[-1].minor.pp204, &ppmsp[0].minor.pp204);
3773 pp_destructor(26,&ppmsp[-5].minor);
3774 pp_destructor(27,&ppmsp[-2].minor);
3775 }
3776 // 1305 "parser.php7.c"
3777 break;
3778 case 7:
3779 // 163 "parser.php7.lemon"
3780 {
3781 phql_ret_distinct_all(&ppgotominor.pp204, 1);
3782 pp_destructor(28,&ppmsp[0].minor);
3783 }
3784 // 1313 "parser.php7.c"
3785 break;
3786 case 8:
3787 // 167 "parser.php7.lemon"
3788 {
3789 phql_ret_distinct_all(&ppgotominor.pp204, 0);
3790 pp_destructor(29,&ppmsp[0].minor);
3791 }
3792 // 1321 "parser.php7.c"
3793 break;
3794 case 9:
3795 case 20:
3796 case 27:
3797 case 38:
3798 case 69:
3799 case 71:
3800 case 78:
3801 case 83:
3802 case 85:
3803 case 89:
3804 case 91:
3805 case 135:
3806 case 137:
3807 // 171 "parser.php7.lemon"
3808 {
3809 ZVAL_UNDEF(&ppgotominor.pp204);
3810 }
3811 // 1340 "parser.php7.c"
3812 break;
3813 case 10:
3814 case 17:
3815 case 41:
3816 case 44:
3817 case 49:
3818 case 64:
3819 case 72:
3820 case 79:
3821 case 138:
3822 // 179 "parser.php7.lemon"
3823 {
3824 phql_ret_zval_list(&ppgotominor.pp204, &ppmsp[-2].minor.pp204, &ppmsp[0].minor.pp204);
3825 pp_destructor(25,&ppmsp[-1].minor);
3826 }
3827 // 1356 "parser.php7.c"
3828 break;
3829 case 11:
3830 case 42:
3831 case 45:
3832 case 129:
3833 case 139:
3834 // 183 "parser.php7.lemon"
3835 {
3836 phql_ret_zval_list(&ppgotominor.pp204, &ppmsp[0].minor.pp204, NULL);
3837 }
3838 // 1367 "parser.php7.c"
3839 break;
3840 case 12:
3841 case 140:
3842 // 191 "parser.php7.lemon"
3843 {
3844 phql_ret_column_item(&ppgotominor.pp204, PHQL_T_STARALL, NULL, NULL, NULL);
3845 pp_destructor(17,&ppmsp[0].minor);
3846 }
3847 // 1376 "parser.php7.c"
3848 break;
3849 case 13:
3850 // 195 "parser.php7.lemon"
3851 {
3852 phql_ret_column_item(&ppgotominor.pp204, PHQL_T_DOMAINALL, NULL, ppmsp[-2].minor.pp0, NULL);
3853 pp_destructor(31,&ppmsp[-1].minor);
3854 pp_destructor(17,&ppmsp[0].minor);
3855 }
3856 // 1385 "parser.php7.c"
3857 break;
3858 case 14:
3859 // 199 "parser.php7.lemon"
3860 {
3861 phql_ret_column_item(&ppgotominor.pp204, PHQL_T_EXPR, &ppmsp[-2].minor.pp204, NULL, ppmsp[0].minor.pp0);
3862 pp_destructor(32,&ppmsp[-1].minor);
3863 }
3864 // 1393 "parser.php7.c"
3865 break;
3866 case 15:
3867 // 203 "parser.php7.lemon"
3868 {
3869 phql_ret_column_item(&ppgotominor.pp204, PHQL_T_EXPR, &ppmsp[-1].minor.pp204, NULL, ppmsp[0].minor.pp0);
3870 }
3871 // 1400 "parser.php7.c"
3872 break;
3873 case 16:
3874 // 207 "parser.php7.lemon"
3875 {
3876 phql_ret_column_item(&ppgotominor.pp204, PHQL_T_EXPR, &ppmsp[0].minor.pp204, NULL, NULL);
3877 }
3878 // 1407 "parser.php7.c"
3879 break;
3880 case 21:
3881 case 128:
3882 // 235 "parser.php7.lemon"
3883 {
3884 phql_ret_zval_list(&ppgotominor.pp204, &ppmsp[-1].minor.pp204, &ppmsp[0].minor.pp204);
3885 }
3886 // 1415 "parser.php7.c"
3887 break;
3888 case 24:
3889 // 256 "parser.php7.lemon"
3890 {
3891 phql_ret_join_item(&ppgotominor.pp204, &ppmsp[-3].minor.pp204, &ppmsp[-2].minor.pp204, &ppmsp[-1].minor.pp204, &ppmsp[0].minor.pp204);
3892 }
3893 // 1422 "parser.php7.c"
3894 break;
3895 case 25:
3896 // 264 "parser.php7.lemon"
3897 {
3898 phql_ret_qualified_name(&ppgotominor.pp204, NULL, NULL, ppmsp[0].minor.pp0);
3899 pp_destructor(32,&ppmsp[-1].minor);
3900 }
3901 // 1430 "parser.php7.c"
3902 break;
3903 case 26:
3904 case 46:
3905 case 66:
3906 case 160:
3907 // 268 "parser.php7.lemon"
3908 {
3909 phql_ret_qualified_name(&ppgotominor.pp204, NULL, NULL, ppmsp[0].minor.pp0);
3910 }
3911 // 1440 "parser.php7.c"
3912 break;
3913 case 28:
3914 // 280 "parser.php7.lemon"
3915 {
3916 phql_ret_join_type(&ppgotominor.pp204, PHQL_T_INNERJOIN);
3917 pp_destructor(33,&ppmsp[-1].minor);
3918 pp_destructor(34,&ppmsp[0].minor);
3919 }
3920 // 1449 "parser.php7.c"
3921 break;
3922 case 29:
3923 // 284 "parser.php7.lemon"
3924 {
3925 phql_ret_join_type(&ppgotominor.pp204, PHQL_T_CROSSJOIN);
3926 pp_destructor(35,&ppmsp[-1].minor);
3927 pp_destructor(34,&ppmsp[0].minor);
3928 }
3929 // 1458 "parser.php7.c"
3930 break;
3931 case 30:
3932 // 288 "parser.php7.lemon"
3933 {
3934 phql_ret_join_type(&ppgotominor.pp204, PHQL_T_LEFTJOIN);
3935 pp_destructor(36,&ppmsp[-2].minor);
3936 pp_destructor(37,&ppmsp[-1].minor);
3937 pp_destructor(34,&ppmsp[0].minor);
3938 }
3939 // 1468 "parser.php7.c"
3940 break;
3941 case 31:
3942 // 292 "parser.php7.lemon"
3943 {
3944 phql_ret_join_type(&ppgotominor.pp204, PHQL_T_LEFTJOIN);
3945 pp_destructor(36,&ppmsp[-1].minor);
3946 pp_destructor(34,&ppmsp[0].minor);
3947 }
3948 // 1477 "parser.php7.c"
3949 break;
3950 case 32:
3951 // 296 "parser.php7.lemon"
3952 {
3953 phql_ret_join_type(&ppgotominor.pp204, PHQL_T_RIGHTJOIN);
3954 pp_destructor(38,&ppmsp[-2].minor);
3955 pp_destructor(37,&ppmsp[-1].minor);
3956 pp_destructor(34,&ppmsp[0].minor);
3957 }
3958 // 1487 "parser.php7.c"
3959 break;
3960 case 33:
3961 // 300 "parser.php7.lemon"
3962 {
3963 phql_ret_join_type(&ppgotominor.pp204, PHQL_T_RIGHTJOIN);
3964 pp_destructor(38,&ppmsp[-1].minor);
3965 pp_destructor(34,&ppmsp[0].minor);
3966 }
3967 // 1496 "parser.php7.c"
3968 break;
3969 case 34:
3970 // 304 "parser.php7.lemon"
3971 {
3972 phql_ret_join_type(&ppgotominor.pp204, PHQL_T_FULLJOIN);
3973 pp_destructor(39,&ppmsp[-2].minor);
3974 pp_destructor(37,&ppmsp[-1].minor);
3975 pp_destructor(34,&ppmsp[0].minor);
3976 }
3977 // 1506 "parser.php7.c"
3978 break;
3979 case 35:
3980 // 308 "parser.php7.lemon"
3981 {
3982 phql_ret_join_type(&ppgotominor.pp204, PHQL_T_FULLJOIN);
3983 pp_destructor(39,&ppmsp[-1].minor);
3984 pp_destructor(34,&ppmsp[0].minor);
3985 }
3986 // 1515 "parser.php7.c"
3987 break;
3988 case 36:
3989 // 312 "parser.php7.lemon"
3990 {
3991 phql_ret_join_type(&ppgotominor.pp204, PHQL_T_INNERJOIN);
3992 pp_destructor(34,&ppmsp[0].minor);
3993 }
3994 // 1523 "parser.php7.c"
3995 break;
3996 case 37:
3997 // 320 "parser.php7.lemon"
3998 {
3999 ppgotominor.pp204 = ppmsp[0].minor.pp204;
4000 pp_destructor(40,&ppmsp[-1].minor);
4001 }
4002 // 1531 "parser.php7.c"
4003 break;
4004 case 39:
4005 // 333 "parser.php7.lemon"
4006 {
4007 phql_ret_insert_statement(&ppgotominor.pp204, &ppmsp[-4].minor.pp204, NULL, &ppmsp[-1].minor.pp204);
4008 pp_destructor(41,&ppmsp[-6].minor);
4009 pp_destructor(42,&ppmsp[-5].minor);
4010 pp_destructor(43,&ppmsp[-3].minor);
4011 pp_destructor(44,&ppmsp[-2].minor);
4012 pp_destructor(45,&ppmsp[0].minor);
4013 }
4014 // 1543 "parser.php7.c"
4015 break;
4016 case 40:
4017 // 337 "parser.php7.lemon"
4018 {
4019 phql_ret_insert_statement(&ppgotominor.pp204, &ppmsp[-7].minor.pp204, &ppmsp[-5].minor.pp204, &ppmsp[-1].minor.pp204);
4020 pp_destructor(41,&ppmsp[-9].minor);
4021 pp_destructor(42,&ppmsp[-8].minor);
4022 pp_destructor(44,&ppmsp[-6].minor);
4023 pp_destructor(45,&ppmsp[-4].minor);
4024 pp_destructor(43,&ppmsp[-3].minor);
4025 pp_destructor(44,&ppmsp[-2].minor);
4026 pp_destructor(45,&ppmsp[0].minor);
4027 }
4028 // 1557 "parser.php7.c"
4029 break;
4030 case 47:
4031 // 383 "parser.php7.lemon"
4032 {
4033 phql_ret_update_statement(&ppgotominor.pp204, &ppmsp[-2].minor.pp204, &ppmsp[-1].minor.pp204, &ppmsp[0].minor.pp204);
4034 }
4035 // 1564 "parser.php7.c"
4036 break;
4037 case 48:
4038 // 391 "parser.php7.lemon"
4039 {
4040 phql_ret_update_clause(&ppgotominor.pp204, &ppmsp[-2].minor.pp204, &ppmsp[0].minor.pp204);
4041 pp_destructor(46,&ppmsp[-3].minor);
4042 pp_destructor(47,&ppmsp[-1].minor);
4043 }
4044 // 1573 "parser.php7.c"
4045 break;
4046 case 51:
4047 // 411 "parser.php7.lemon"
4048 {
4049 phql_ret_update_item(&ppgotominor.pp204, &ppmsp[-2].minor.pp204, &ppmsp[0].minor.pp204);
4050 pp_destructor(3,&ppmsp[-1].minor);
4051 }
4052 // 1581 "parser.php7.c"
4053 break;
4054 case 53:
4055 // 425 "parser.php7.lemon"
4056 {
4057 phql_ret_delete_statement(&ppgotominor.pp204, &ppmsp[-2].minor.pp204, &ppmsp[-1].minor.pp204, &ppmsp[0].minor.pp204);
4058 }
4059 // 1588 "parser.php7.c"
4060 break;
4061 case 54:
4062 // 433 "parser.php7.lemon"
4063 {
4064 phql_ret_delete_clause(&ppgotominor.pp204, &ppmsp[0].minor.pp204);
4065 pp_destructor(48,&ppmsp[-2].minor);
4066 pp_destructor(27,&ppmsp[-1].minor);
4067 }
4068 // 1597 "parser.php7.c"
4069 break;
4070 case 55:
4071 // 441 "parser.php7.lemon"
4072 {
4073 phql_ret_assoc_name(&ppgotominor.pp204, &ppmsp[-2].minor.pp204, ppmsp[0].minor.pp0, NULL);
4074 pp_destructor(32,&ppmsp[-1].minor);
4075 }
4076 // 1605 "parser.php7.c"
4077 break;
4078 case 56:
4079 // 445 "parser.php7.lemon"
4080 {
4081 phql_ret_assoc_name(&ppgotominor.pp204, &ppmsp[-1].minor.pp204, ppmsp[0].minor.pp0, NULL);
4082 }
4083 // 1612 "parser.php7.c"
4084 break;
4085 case 57:
4086 // 449 "parser.php7.lemon"
4087 {
4088 phql_ret_assoc_name(&ppgotominor.pp204, &ppmsp[0].minor.pp204, NULL, NULL);
4089 }
4090 // 1619 "parser.php7.c"
4091 break;
4092 case 58:
4093 // 453 "parser.php7.lemon"
4094 {
4095 phql_ret_assoc_name(&ppgotominor.pp204, &ppmsp[-4].minor.pp204, ppmsp[-2].minor.pp0, &ppmsp[0].minor.pp204);
4096 pp_destructor(32,&ppmsp[-3].minor);
4097 pp_destructor(49,&ppmsp[-1].minor);
4098 }
4099 // 1628 "parser.php7.c"
4100 break;
4101 case 59:
4102 // 457 "parser.php7.lemon"
4103 {
4104 phql_ret_assoc_name(&ppgotominor.pp204, &ppmsp[-6].minor.pp204, ppmsp[-4].minor.pp0, &ppmsp[-1].minor.pp204);
4105 pp_destructor(32,&ppmsp[-5].minor);
4106 pp_destructor(49,&ppmsp[-3].minor);
4107 pp_destructor(44,&ppmsp[-2].minor);
4108 pp_destructor(45,&ppmsp[0].minor);
4109 }
4110 // 1639 "parser.php7.c"
4111 break;
4112 case 60:
4113 // 461 "parser.php7.lemon"
4114 {
4115 phql_ret_assoc_name(&ppgotominor.pp204, &ppmsp[-5].minor.pp204, ppmsp[-4].minor.pp0, &ppmsp[-1].minor.pp204);
4116 pp_destructor(49,&ppmsp[-3].minor);
4117 pp_destructor(44,&ppmsp[-2].minor);
4118 pp_destructor(45,&ppmsp[0].minor);
4119 }
4120 // 1649 "parser.php7.c"
4121 break;
4122 case 61:
4123 // 465 "parser.php7.lemon"
4124 {
4125 phql_ret_assoc_name(&ppgotominor.pp204, &ppmsp[-3].minor.pp204, ppmsp[-2].minor.pp0, &ppmsp[0].minor.pp204);
4126 pp_destructor(49,&ppmsp[-1].minor);
4127 }
4128 // 1657 "parser.php7.c"
4129 break;
4130 case 62:
4131 // 469 "parser.php7.lemon"
4132 {
4133 phql_ret_assoc_name(&ppgotominor.pp204, &ppmsp[-4].minor.pp204, NULL, &ppmsp[-1].minor.pp204);
4134 pp_destructor(49,&ppmsp[-3].minor);
4135 pp_destructor(44,&ppmsp[-2].minor);
4136 pp_destructor(45,&ppmsp[0].minor);
4137 }
4138 // 1667 "parser.php7.c"
4139 break;
4140 case 63:
4141 // 473 "parser.php7.lemon"
4142 {
4143 phql_ret_assoc_name(&ppgotominor.pp204, &ppmsp[-2].minor.pp204, NULL, &ppmsp[0].minor.pp204);
4144 pp_destructor(49,&ppmsp[-1].minor);
4145 }
4146 // 1675 "parser.php7.c"
4147 break;
4148 case 68:
4149 // 509 "parser.php7.lemon"
4150 {
4151 ppgotominor.pp204 = ppmsp[0].minor.pp204;
4152 pp_destructor(50,&ppmsp[-1].minor);
4153 }
4154 // 1683 "parser.php7.c"
4155 break;
4156 case 70:
4157 // 521 "parser.php7.lemon"
4158 {
4159 ppgotominor.pp204 = ppmsp[0].minor.pp204;
4160 pp_destructor(51,&ppmsp[-2].minor);
4161 pp_destructor(52,&ppmsp[-1].minor);
4162 }
4163 // 1692 "parser.php7.c"
4164 break;
4165 case 74:
4166 // 545 "parser.php7.lemon"
4167 {
4168 phql_ret_order_item(&ppgotominor.pp204, &ppmsp[0].minor.pp204, 0);
4169 }
4170 // 1699 "parser.php7.c"
4171 break;
4172 case 75:
4173 // 549 "parser.php7.lemon"
4174 {
4175 phql_ret_order_item(&ppgotominor.pp204, &ppmsp[-1].minor.pp204, PHQL_T_ASC);
4176 pp_destructor(53,&ppmsp[0].minor);
4177 }
4178 // 1707 "parser.php7.c"
4179 break;
4180 case 76:
4181 // 553 "parser.php7.lemon"
4182 {
4183 phql_ret_order_item(&ppgotominor.pp204, &ppmsp[-1].minor.pp204, PHQL_T_DESC);
4184 pp_destructor(54,&ppmsp[0].minor);
4185 }
4186 // 1715 "parser.php7.c"
4187 break;
4188 case 77:
4189 // 561 "parser.php7.lemon"
4190 {
4191 ppgotominor.pp204 = ppmsp[0].minor.pp204;
4192 pp_destructor(55,&ppmsp[-2].minor);
4193 pp_destructor(52,&ppmsp[-1].minor);
4194 }
4195 // 1724 "parser.php7.c"
4196 break;
4197 case 82:
4198 // 593 "parser.php7.lemon"
4199 {
4200 ppgotominor.pp204 = ppmsp[0].minor.pp204;
4201 pp_destructor(56,&ppmsp[-1].minor);
4202 }
4203 // 1732 "parser.php7.c"
4204 break;
4205 case 84:
4206 // 605 "parser.php7.lemon"
4207 {
4208 phql_ret_for_update_clause(&ppgotominor.pp204);
4209 pp_destructor(57,&ppmsp[-1].minor);
4210 pp_destructor(46,&ppmsp[0].minor);
4211 }
4212 // 1741 "parser.php7.c"
4213 break;
4214 case 86:
4215 case 90:
4216 // 617 "parser.php7.lemon"
4217 {
4218 phql_ret_limit_clause(&ppgotominor.pp204, &ppmsp[0].minor.pp204, NULL);
4219 pp_destructor(58,&ppmsp[-1].minor);
4220 }
4221 // 1750 "parser.php7.c"
4222 break;
4223 case 87:
4224 // 621 "parser.php7.lemon"
4225 {
4226 phql_ret_limit_clause(&ppgotominor.pp204, &ppmsp[0].minor.pp204, &ppmsp[-2].minor.pp204);
4227 pp_destructor(58,&ppmsp[-3].minor);
4228 pp_destructor(25,&ppmsp[-1].minor);
4229 }
4230 // 1759 "parser.php7.c"
4231 break;
4232 case 88:
4233 // 625 "parser.php7.lemon"
4234 {
4235 phql_ret_limit_clause(&ppgotominor.pp204, &ppmsp[-2].minor.pp204, &ppmsp[0].minor.pp204);
4236 pp_destructor(58,&ppmsp[-3].minor);
4237 pp_destructor(59,&ppmsp[-1].minor);
4238 }
4239 // 1768 "parser.php7.c"
4240 break;
4241 case 92:
4242 case 149:
4243 // 645 "parser.php7.lemon"
4244 {
4245 phql_ret_literal_zval(&ppgotominor.pp204, PHQL_T_INTEGER, ppmsp[0].minor.pp0);
4246 }
4247 // 1776 "parser.php7.c"
4248 break;
4249 case 93:
4250 case 150:
4251 // 649 "parser.php7.lemon"
4252 {
4253 phql_ret_literal_zval(&ppgotominor.pp204, PHQL_T_HINTEGER, ppmsp[0].minor.pp0);
4254 }
4255 // 1784 "parser.php7.c"
4256 break;
4257 case 94:
4258 case 156:
4259 // 653 "parser.php7.lemon"
4260 {
4261 phql_ret_placeholder_zval(&ppgotominor.pp204, PHQL_T_NPLACEHOLDER, ppmsp[0].minor.pp0);
4262 }
4263 // 1792 "parser.php7.c"
4264 break;
4265 case 95:
4266 case 157:
4267 // 657 "parser.php7.lemon"
4268 {
4269 phql_ret_placeholder_zval(&ppgotominor.pp204, PHQL_T_SPLACEHOLDER, ppmsp[0].minor.pp0);
4270 }
4271 // 1800 "parser.php7.c"
4272 break;
4273 case 96:
4274 case 158:
4275 // 661 "parser.php7.lemon"
4276 {
4277 phql_ret_placeholder_zval(&ppgotominor.pp204, PHQL_T_BPLACEHOLDER, ppmsp[0].minor.pp0);
4278 }
4279 // 1808 "parser.php7.c"
4280 break;
4281 case 97:
4282 // 669 "parser.php7.lemon"
4283 {
4284 phql_ret_expr(&ppgotominor.pp204, PHQL_T_MINUS, NULL, &ppmsp[0].minor.pp204);
4285 pp_destructor(20,&ppmsp[-1].minor);
4286 }
4287 // 1816 "parser.php7.c"
4288 break;
4289 case 98:
4290 // 673 "parser.php7.lemon"
4291 {
4292 phql_ret_expr(&ppgotominor.pp204, PHQL_T_SUB, &ppmsp[-2].minor.pp204, &ppmsp[0].minor.pp204);
4293 pp_destructor(20,&ppmsp[-1].minor);
4294 }
4295 // 1824 "parser.php7.c"
4296 break;
4297 case 99:
4298 // 677 "parser.php7.lemon"
4299 {
4300 phql_ret_expr(&ppgotominor.pp204, PHQL_T_ADD, &ppmsp[-2].minor.pp204, &ppmsp[0].minor.pp204);
4301 pp_destructor(19,&ppmsp[-1].minor);
4302 }
4303 // 1832 "parser.php7.c"
4304 break;
4305 case 100:
4306 // 681 "parser.php7.lemon"
4307 {
4308 phql_ret_expr(&ppgotominor.pp204, PHQL_T_MUL, &ppmsp[-2].minor.pp204, &ppmsp[0].minor.pp204);
4309 pp_destructor(17,&ppmsp[-1].minor);
4310 }
4311 // 1840 "parser.php7.c"
4312 break;
4313 case 101:
4314 // 685 "parser.php7.lemon"
4315 {
4316 phql_ret_expr(&ppgotominor.pp204, PHQL_T_DIV, &ppmsp[-2].minor.pp204, &ppmsp[0].minor.pp204);
4317 pp_destructor(16,&ppmsp[-1].minor);
4318 }
4319 // 1848 "parser.php7.c"
4320 break;
4321 case 102:
4322 // 689 "parser.php7.lemon"
4323 {
4324 phql_ret_expr(&ppgotominor.pp204, PHQL_T_MOD, &ppmsp[-2].minor.pp204, &ppmsp[0].minor.pp204);
4325 pp_destructor(18,&ppmsp[-1].minor);
4326 }
4327 // 1856 "parser.php7.c"
4328 break;
4329 case 103:
4330 // 693 "parser.php7.lemon"
4331 {
4332 phql_ret_expr(&ppgotominor.pp204, PHQL_T_AND, &ppmsp[-2].minor.pp204, &ppmsp[0].minor.pp204);
4333 pp_destructor(9,&ppmsp[-1].minor);
4334 }
4335 // 1864 "parser.php7.c"
4336 break;
4337 case 104:
4338 // 697 "parser.php7.lemon"
4339 {
4340 phql_ret_expr(&ppgotominor.pp204, PHQL_T_OR, &ppmsp[-2].minor.pp204, &ppmsp[0].minor.pp204);
4341 pp_destructor(10,&ppmsp[-1].minor);
4342 }
4343 // 1872 "parser.php7.c"
4344 break;
4345 case 105:
4346 // 701 "parser.php7.lemon"
4347 {
4348 phql_ret_expr(&ppgotominor.pp204, PHQL_T_BITWISE_AND, &ppmsp[-2].minor.pp204, &ppmsp[0].minor.pp204);
4349 pp_destructor(13,&ppmsp[-1].minor);
4350 }
4351 // 1880 "parser.php7.c"
4352 break;
4353 case 106:
4354 // 705 "parser.php7.lemon"
4355 {
4356 phql_ret_expr(&ppgotominor.pp204, PHQL_T_BITWISE_OR, &ppmsp[-2].minor.pp204, &ppmsp[0].minor.pp204);
4357 pp_destructor(14,&ppmsp[-1].minor);
4358 }
4359 // 1888 "parser.php7.c"
4360 break;
4361 case 107:
4362 // 709 "parser.php7.lemon"
4363 {
4364 phql_ret_expr(&ppgotominor.pp204, PHQL_T_BITWISE_XOR, &ppmsp[-2].minor.pp204, &ppmsp[0].minor.pp204);
4365 pp_destructor(15,&ppmsp[-1].minor);
4366 }
4367 // 1896 "parser.php7.c"
4368 break;
4369 case 108:
4370 // 713 "parser.php7.lemon"
4371 {
4372 phql_ret_expr(&ppgotominor.pp204, PHQL_T_EQUALS, &ppmsp[-2].minor.pp204, &ppmsp[0].minor.pp204);
4373 pp_destructor(3,&ppmsp[-1].minor);
4374 }
4375 // 1904 "parser.php7.c"
4376 break;
4377 case 109:
4378 // 717 "parser.php7.lemon"
4379 {
4380 phql_ret_expr(&ppgotominor.pp204, PHQL_T_NOTEQUALS, &ppmsp[-2].minor.pp204, &ppmsp[0].minor.pp204);
4381 pp_destructor(4,&ppmsp[-1].minor);
4382 }
4383 // 1912 "parser.php7.c"
4384 break;
4385 case 110:
4386 // 721 "parser.php7.lemon"
4387 {
4388 phql_ret_expr(&ppgotominor.pp204, PHQL_T_LESS, &ppmsp[-2].minor.pp204, &ppmsp[0].minor.pp204);
4389 pp_destructor(5,&ppmsp[-1].minor);
4390 }
4391 // 1920 "parser.php7.c"
4392 break;
4393 case 111:
4394 // 725 "parser.php7.lemon"
4395 {
4396 phql_ret_expr(&ppgotominor.pp204, PHQL_T_GREATER, &ppmsp[-2].minor.pp204, &ppmsp[0].minor.pp204);
4397 pp_destructor(6,&ppmsp[-1].minor);
4398 }
4399 // 1928 "parser.php7.c"
4400 break;
4401 case 112:
4402 // 729 "parser.php7.lemon"
4403 {
4404 phql_ret_expr(&ppgotominor.pp204, PHQL_T_GREATEREQUAL, &ppmsp[-2].minor.pp204, &ppmsp[0].minor.pp204);
4405 pp_destructor(7,&ppmsp[-1].minor);
4406 }
4407 // 1936 "parser.php7.c"
4408 break;
4409 case 113:
4410 // 733 "parser.php7.lemon"
4411 {
4412 phql_ret_expr(&ppgotominor.pp204, PHQL_T_LESSEQUAL, &ppmsp[-2].minor.pp204, &ppmsp[0].minor.pp204);
4413 pp_destructor(8,&ppmsp[-1].minor);
4414 }
4415 // 1944 "parser.php7.c"
4416 break;
4417 case 114:
4418 // 737 "parser.php7.lemon"
4419 {
4420 phql_ret_expr(&ppgotominor.pp204, PHQL_T_LIKE, &ppmsp[-2].minor.pp204, &ppmsp[0].minor.pp204);
4421 pp_destructor(11,&ppmsp[-1].minor);
4422 }
4423 // 1952 "parser.php7.c"
4424 break;
4425 case 115:
4426 // 741 "parser.php7.lemon"
4427 {
4428 phql_ret_expr(&ppgotominor.pp204, PHQL_T_NLIKE, &ppmsp[-3].minor.pp204, &ppmsp[0].minor.pp204);
4429 pp_destructor(23,&ppmsp[-2].minor);
4430 pp_destructor(11,&ppmsp[-1].minor);
4431 }
4432 // 1961 "parser.php7.c"
4433 break;
4434 case 116:
4435 // 745 "parser.php7.lemon"
4436 {
4437 phql_ret_expr(&ppgotominor.pp204, PHQL_T_ILIKE, &ppmsp[-2].minor.pp204, &ppmsp[0].minor.pp204);
4438 pp_destructor(12,&ppmsp[-1].minor);
4439 }
4440 // 1969 "parser.php7.c"
4441 break;
4442 case 117:
4443 // 749 "parser.php7.lemon"
4444 {
4445 phql_ret_expr(&ppgotominor.pp204, PHQL_T_NILIKE, &ppmsp[-3].minor.pp204, &ppmsp[0].minor.pp204);
4446 pp_destructor(23,&ppmsp[-2].minor);
4447 pp_destructor(12,&ppmsp[-1].minor);
4448 }
4449 // 1978 "parser.php7.c"
4450 break;
4451 case 118:
4452 case 121:
4453 // 753 "parser.php7.lemon"
4454 {
4455 phql_ret_expr(&ppgotominor.pp204, PHQL_T_IN, &ppmsp[-4].minor.pp204, &ppmsp[-1].minor.pp204);
4456 pp_destructor(22,&ppmsp[-3].minor);
4457 pp_destructor(44,&ppmsp[-2].minor);
4458 pp_destructor(45,&ppmsp[0].minor);
4459 }
4460 // 1989 "parser.php7.c"
4461 break;
4462 case 119:
4463 case 122:
4464 // 757 "parser.php7.lemon"
4465 {
4466 phql_ret_expr(&ppgotominor.pp204, PHQL_T_NOTIN, &ppmsp[-5].minor.pp204, &ppmsp[-1].minor.pp204);
4467 pp_destructor(23,&ppmsp[-4].minor);
4468 pp_destructor(22,&ppmsp[-3].minor);
4469 pp_destructor(44,&ppmsp[-2].minor);
4470 pp_destructor(45,&ppmsp[0].minor);
4471 }
4472 // 2001 "parser.php7.c"
4473 break;
4474 case 120:
4475 // 761 "parser.php7.lemon"
4476 {
4477 phql_ret_expr(&ppgotominor.pp204, PHQL_T_SUBQUERY, &ppmsp[-1].minor.pp204, NULL);
4478 pp_destructor(44,&ppmsp[-2].minor);
4479 pp_destructor(45,&ppmsp[0].minor);
4480 }
4481 // 2010 "parser.php7.c"
4482 break;
4483 case 123:
4484 // 773 "parser.php7.lemon"
4485 {
4486 phql_ret_expr(&ppgotominor.pp204, PHQL_T_EXISTS, NULL, &ppmsp[-1].minor.pp204);
4487 pp_destructor(65,&ppmsp[-3].minor);
4488 pp_destructor(44,&ppmsp[-2].minor);
4489 pp_destructor(45,&ppmsp[0].minor);
4490 }
4491 // 2020 "parser.php7.c"
4492 break;
4493 case 124:
4494 // 777 "parser.php7.lemon"
4495 {
4496 phql_ret_expr(&ppgotominor.pp204, PHQL_T_AGAINST, &ppmsp[-2].minor.pp204, &ppmsp[0].minor.pp204);
4497 pp_destructor(1,&ppmsp[-1].minor);
4498 }
4499 // 2028 "parser.php7.c"
4500 break;
4501 case 125:
4502 // 781 "parser.php7.lemon"
4503 {
4504 {
4505 zval qualified;
4506 phql_ret_raw_qualified_name(&qualified, ppmsp[-1].minor.pp0, NULL);
4507 phql_ret_expr(&ppgotominor.pp204, PHQL_T_CAST, &ppmsp[-3].minor.pp204, &qualified);
4508 }
4509 pp_destructor(66,&ppmsp[-5].minor);
4510 pp_destructor(44,&ppmsp[-4].minor);
4511 pp_destructor(32,&ppmsp[-2].minor);
4512 pp_destructor(45,&ppmsp[0].minor);
4513 }
4514 // 2043 "parser.php7.c"
4515 break;
4516 case 126:
4517 // 789 "parser.php7.lemon"
4518 {
4519 {
4520 zval qualified;
4521 phql_ret_raw_qualified_name(&qualified, ppmsp[-1].minor.pp0, NULL);
4522 phql_ret_expr(&ppgotominor.pp204, PHQL_T_CONVERT, &ppmsp[-3].minor.pp204, &qualified);
4523 }
4524 pp_destructor(67,&ppmsp[-5].minor);
4525 pp_destructor(44,&ppmsp[-4].minor);
4526 pp_destructor(68,&ppmsp[-2].minor);
4527 pp_destructor(45,&ppmsp[0].minor);
4528 }
4529 // 2058 "parser.php7.c"
4530 break;
4531 case 127:
4532 // 797 "parser.php7.lemon"
4533 {
4534 phql_ret_expr(&ppgotominor.pp204, PHQL_T_CASE, &ppmsp[-2].minor.pp204, &ppmsp[-1].minor.pp204);
4535 pp_destructor(69,&ppmsp[-3].minor);
4536 pp_destructor(70,&ppmsp[0].minor);
4537 }
4538 // 2067 "parser.php7.c"
4539 break;
4540 case 130:
4541 // 809 "parser.php7.lemon"
4542 {
4543 phql_ret_expr(&ppgotominor.pp204, PHQL_T_WHEN, &ppmsp[-2].minor.pp204, &ppmsp[0].minor.pp204);
4544 pp_destructor(71,&ppmsp[-3].minor);
4545 pp_destructor(72,&ppmsp[-1].minor);
4546 }
4547 // 2076 "parser.php7.c"
4548 break;
4549 case 131:
4550 // 813 "parser.php7.lemon"
4551 {
4552 phql_ret_expr(&ppgotominor.pp204, PHQL_T_ELSE, &ppmsp[0].minor.pp204, NULL);
4553 pp_destructor(73,&ppmsp[-1].minor);
4554 }
4555 // 2084 "parser.php7.c"
4556 break;
4557 case 133:
4558 // 825 "parser.php7.lemon"
4559 {
4560 phql_ret_func_call(&ppgotominor.pp204, ppmsp[-4].minor.pp0, &ppmsp[-1].minor.pp204, &ppmsp[-2].minor.pp204);
4561 pp_destructor(44,&ppmsp[-3].minor);
4562 pp_destructor(45,&ppmsp[0].minor);
4563 }
4564 // 2093 "parser.php7.c"
4565 break;
4566 case 134:
4567 // 833 "parser.php7.lemon"
4568 {
4569 phql_ret_distinct(&ppgotominor.pp204);
4570 pp_destructor(28,&ppmsp[0].minor);
4571 }
4572 // 2101 "parser.php7.c"
4573 break;
4574 case 142:
4575 // 877 "parser.php7.lemon"
4576 {
4577 phql_ret_expr(&ppgotominor.pp204, PHQL_T_ISNULL, &ppmsp[-2].minor.pp204, NULL);
4578 pp_destructor(21,&ppmsp[-1].minor);
4579 pp_destructor(74,&ppmsp[0].minor);
4580 }
4581 // 2110 "parser.php7.c"
4582 break;
4583 case 143:
4584 // 881 "parser.php7.lemon"
4585 {
4586 phql_ret_expr(&ppgotominor.pp204, PHQL_T_ISNOTNULL, &ppmsp[-3].minor.pp204, NULL);
4587 pp_destructor(21,&ppmsp[-2].minor);
4588 pp_destructor(23,&ppmsp[-1].minor);
4589 pp_destructor(74,&ppmsp[0].minor);
4590 }
4591 // 2120 "parser.php7.c"
4592 break;
4593 case 144:
4594 // 885 "parser.php7.lemon"
4595 {
4596 phql_ret_expr(&ppgotominor.pp204, PHQL_T_BETWEEN, &ppmsp[-2].minor.pp204, &ppmsp[0].minor.pp204);
4597 pp_destructor(2,&ppmsp[-1].minor);
4598 }
4599 // 2128 "parser.php7.c"
4600 break;
4601 case 145:
4602 // 889 "parser.php7.lemon"
4603 {
4604 phql_ret_expr(&ppgotominor.pp204, PHQL_T_NOT, NULL, &ppmsp[0].minor.pp204);
4605 pp_destructor(23,&ppmsp[-1].minor);
4606 }
4607 // 2136 "parser.php7.c"
4608 break;
4609 case 146:
4610 // 893 "parser.php7.lemon"
4611 {
4612 phql_ret_expr(&ppgotominor.pp204, PHQL_T_BITWISE_NOT, NULL, &ppmsp[0].minor.pp204);
4613 pp_destructor(24,&ppmsp[-1].minor);
4614 }
4615 // 2144 "parser.php7.c"
4616 break;
4617 case 147:
4618 // 897 "parser.php7.lemon"
4619 {
4620 phql_ret_expr(&ppgotominor.pp204, PHQL_T_ENCLOSED, &ppmsp[-1].minor.pp204, NULL);
4621 pp_destructor(44,&ppmsp[-2].minor);
4622 pp_destructor(45,&ppmsp[0].minor);
4623 }
4624 // 2153 "parser.php7.c"
4625 break;
4626 case 151:
4627 // 913 "parser.php7.lemon"
4628 {
4629 phql_ret_literal_zval(&ppgotominor.pp204, PHQL_T_STRING, ppmsp[0].minor.pp0);
4630 }
4631 // 2160 "parser.php7.c"
4632 break;
4633 case 152:
4634 // 917 "parser.php7.lemon"
4635 {
4636 phql_ret_literal_zval(&ppgotominor.pp204, PHQL_T_DOUBLE, ppmsp[0].minor.pp0);
4637 }
4638 // 2167 "parser.php7.c"
4639 break;
4640 case 153:
4641 // 921 "parser.php7.lemon"
4642 {
4643 phql_ret_literal_zval(&ppgotominor.pp204, PHQL_T_NULL, NULL);
4644 pp_destructor(74,&ppmsp[0].minor);
4645 }
4646 // 2175 "parser.php7.c"
4647 break;
4648 case 154:
4649 // 925 "parser.php7.lemon"
4650 {
4651 phql_ret_literal_zval(&ppgotominor.pp204, PHQL_T_TRUE, NULL);
4652 pp_destructor(77,&ppmsp[0].minor);
4653 }
4654 // 2183 "parser.php7.c"
4655 break;
4656 case 155:
4657 // 929 "parser.php7.lemon"
4658 {
4659 phql_ret_literal_zval(&ppgotominor.pp204, PHQL_T_FALSE, NULL);
4660 pp_destructor(78,&ppmsp[0].minor);
4661 }
4662 // 2191 "parser.php7.c"
4663 break;
4664 case 159:
4665 // 952 "parser.php7.lemon"
4666 {
4667 phql_ret_qualified_name(&ppgotominor.pp204, NULL, ppmsp[-2].minor.pp0, ppmsp[0].minor.pp0);
4668 pp_destructor(31,&ppmsp[-1].minor);
4669 }
4670 // 2199 "parser.php7.c"
4671 break;
4672 };
4673 ppgoto = ppRuleInfo[ppruleno].lhs;
4674 ppsize = ppRuleInfo[ppruleno].nrhs;
4675 pppParser->ppidx -= ppsize;
4676 ppact = pp_find_reduce_action(pppParser,ppgoto);
4677 if( ppact < PPNSTATE ){
4678 pp_shift(pppParser,ppact,ppgoto,&ppgotominor);
4679 }else if( ppact == PPNSTATE + PPNRULE + 1 ){
4680 pp_accept(pppParser);
4681 }
4682 }
4683
4684 /*
4685 ** The following code executes when the parse fails
4686 */
pp_parse_failed(ppParser * pppParser)4687 static void pp_parse_failed(
4688 ppParser *pppParser /* The parser */
4689 ){
4690 phql_ARG_FETCH;
4691 #ifndef NDEBUG
4692 if( ppTraceFILE ){
4693 fprintf(ppTraceFILE,"%sFail!\n",ppTracePrompt);
4694 }
4695 #endif
4696 while( pppParser->ppidx>=0 ) pp_pop_parser_stack(pppParser);
4697 /* Here code is inserted which will be executed whenever the
4698 ** parser fails */
4699 phql_ARG_STORE; /* Suppress warning about unused %extra_argument variable */
4700 }
4701
4702 /*
4703 ** The following code executes when a syntax error first occurs.
4704 */
pp_syntax_error(ppParser * pppParser,int ppmajor,PPMINORTYPE ppminor)4705 static void pp_syntax_error(
4706 ppParser *pppParser, /* The parser */
4707 int ppmajor, /* The major type of the error token */
4708 PPMINORTYPE ppminor /* The minor type of the error token */
4709 ){
4710 phql_ARG_FETCH;
4711 #define PPTOKEN (ppminor.pp0)
4712 // 43 "parser.php7.lemon"
4713
4714 if (status->scanner_state->start_length) {
4715 {
4716
4717 char *token_name = NULL;
4718 int token_found = 0;
4719 unsigned int token_length;
4720 const phql_token_names *tokens = phql_tokens;
4721 int active_token = status->scanner_state->active_token;
4722 int near_length = status->scanner_state->start_length;
4723
4724 if (active_token) {
4725
4726 do {
4727 if (tokens->code == active_token) {
4728 token_name = tokens->name;
4729 token_length = tokens->length;
4730 token_found = 1;
4731 break;
4732 }
4733 ++tokens;
4734 } while (tokens[0].code != 0);
4735
4736 }
4737
4738 if (!token_name) {
4739 token_length = strlen("UNKNOWN");
4740 token_name = estrndup("UNKNOWN", token_length);
4741 token_found = 0;
4742 }
4743
4744 status->syntax_error_len = 96 + status->token->len + token_length + near_length + status->phql_length;;
4745 status->syntax_error = emalloc(sizeof(char) * status->syntax_error_len);
4746
4747 if (near_length > 0) {
4748 if (status->token->value) {
4749 snprintf(status->syntax_error, status->syntax_error_len, "Syntax error, unexpected token %s(%s), near to '%s', when parsing: %s (%d)", token_name, status->token->value, status->scanner_state->start, status->phql, status->phql_length);
4750 } else {
4751 snprintf(status->syntax_error, status->syntax_error_len, "Syntax error, unexpected token %s, near to '%s', when parsing: %s (%d)", token_name, status->scanner_state->start, status->phql, status->phql_length);
4752 }
4753 } else {
4754 if (active_token != PHQL_T_IGNORE) {
4755 if (status->token->value) {
4756 snprintf(status->syntax_error, status->syntax_error_len, "Syntax error, unexpected token %s(%s), at the end of query, when parsing: %s (%d)", token_name, status->token->value, status->phql, status->phql_length);
4757 } else {
4758 snprintf(status->syntax_error, status->syntax_error_len, "Syntax error, unexpected token %s, at the end of query, when parsing: %s (%d)", token_name, status->phql, status->phql_length);
4759 }
4760 } else {
4761 snprintf(status->syntax_error, status->syntax_error_len, "Syntax error, unexpected EOF, at the end of query");
4762 }
4763 status->syntax_error[status->syntax_error_len - 1] = '\0';
4764 }
4765
4766 if (!token_found) {
4767 if (token_name) {
4768 efree(token_name);
4769 }
4770 }
4771 }
4772 } else {
4773 status->syntax_error_len = strlen("Syntax error, unexpected EOF");
4774 status->syntax_error = estrndup("Syntax error, unexpected EOF", status->syntax_error_len);
4775 }
4776
4777 status->status = PHQL_PARSING_FAILED;
4778
4779 // 2308 "parser.php7.c"
4780 phql_ARG_STORE; /* Suppress warning about unused %extra_argument variable */
4781 }
4782
4783 /*
4784 ** The following is executed when the parser accepts
4785 */
pp_accept(ppParser * pppParser)4786 static void pp_accept(
4787 ppParser *pppParser /* The parser */
4788 ){
4789 phql_ARG_FETCH;
4790 #ifndef NDEBUG
4791 if( ppTraceFILE ){
4792 fprintf(ppTraceFILE,"%sAccept!\n",ppTracePrompt);
4793 }
4794 #endif
4795 while( pppParser->ppidx>=0 ) pp_pop_parser_stack(pppParser);
4796 /* Here code is inserted which will be executed whenever the
4797 ** parser accepts */
4798 phql_ARG_STORE; /* Suppress warning about unused %extra_argument variable */
4799 }
4800
4801 /* The main parser program.
4802 ** The first argument is a pointer to a structure obtained from
4803 ** "phql_Alloc" which describes the current state of the parser.
4804 ** The second argument is the major token number. The third is
4805 ** the minor token. The fourth optional argument is whatever the
4806 ** user wants (and specified in the grammar) and is available for
4807 ** use by the action routines.
4808 **
4809 ** Inputs:
4810 ** <ul>
4811 ** <li> A pointer to the parser (an opaque structure.)
4812 ** <li> The major token number.
4813 ** <li> The minor token number.
4814 ** <li> An option argument of a grammar-specified type.
4815 ** </ul>
4816 **
4817 ** Outputs:
4818 ** None.
4819 */
phql_(void * ppp,int ppmajor,phql_TOKENTYPE ppminor phql_ARG_PDECL)4820 void phql_(
4821 void *ppp, /* The parser */
4822 int ppmajor, /* The major token code number */
4823 phql_TOKENTYPE ppminor /* The value for the token */
4824 phql_ARG_PDECL /* Optional %extra_argument parameter */
4825 ){
4826 PPMINORTYPE ppminorunion;
4827 int ppact; /* The parser action. */
4828 int ppendofinput; /* True if we are at the end of input */
4829 int pperrorhit = 0; /* True if ppmajor has invoked an error */
4830 ppParser *pppParser; /* The parser */
4831
4832 /* (re)initialize the parser, if necessary */
4833 pppParser = (ppParser*)ppp;
4834 if( pppParser->ppidx<0 ){
4835 if( ppmajor==0 ) return;
4836 pppParser->ppidx = 0;
4837 pppParser->pperrcnt = -1;
4838 pppParser->ppstack[0].stateno = 0;
4839 pppParser->ppstack[0].major = 0;
4840 }
4841 ppminorunion.pp0 = ppminor;
4842 ppendofinput = (ppmajor==0);
4843 phql_ARG_STORE;
4844
4845 #ifndef NDEBUG
4846 if( ppTraceFILE ){
4847 fprintf(ppTraceFILE,"%sInput %s\n",ppTracePrompt,ppTokenName[ppmajor]);
4848 }
4849 #endif
4850
4851 do{
4852 ppact = pp_find_shift_action(pppParser,ppmajor);
4853 if( ppact<PPNSTATE ){
4854 pp_shift(pppParser,ppact,ppmajor,&ppminorunion);
4855 pppParser->pperrcnt--;
4856 if( ppendofinput && pppParser->ppidx>=0 ){
4857 ppmajor = 0;
4858 }else{
4859 ppmajor = PPNOCODE;
4860 }
4861 }else if( ppact < PPNSTATE + PPNRULE ){
4862 pp_reduce(pppParser,ppact-PPNSTATE);
4863 }else if( ppact == PP_ERROR_ACTION ){
4864 int ppmx;
4865 #ifndef NDEBUG
4866 if( ppTraceFILE ){
4867 fprintf(ppTraceFILE,"%sSyntax Error!\n",ppTracePrompt);
4868 }
4869 #endif
4870 #ifdef PPERRORSYMBOL
4871 /* A syntax error has occurred.
4872 ** The response to an error depends upon whether or not the
4873 ** grammar defines an error token "ERROR".
4874 **
4875 ** This is what we do if the grammar does define ERROR:
4876 **
4877 ** * Call the %syntax_error function.
4878 **
4879 ** * Begin popping the stack until we enter a state where
4880 ** it is legal to shift the error symbol, then shift
4881 ** the error symbol.
4882 **
4883 ** * Set the error count to three.
4884 **
4885 ** * Begin accepting and shifting new tokens. No new error
4886 ** processing will occur until three tokens have been
4887 ** shifted successfully.
4888 **
4889 */
4890 if( pppParser->pperrcnt<0 ){
4891 pp_syntax_error(pppParser,ppmajor,ppminorunion);
4892 }
4893 ppmx = pppParser->ppstack[pppParser->ppidx].major;
4894 if( ppmx==PPERRORSYMBOL || pperrorhit ){
4895 #ifndef NDEBUG
4896 if( ppTraceFILE ){
4897 fprintf(ppTraceFILE,"%sDiscard input token %s\n",
4898 ppTracePrompt,ppTokenName[ppmajor]);
4899 }
4900 #endif
4901 pp_destructor(ppmajor,&ppminorunion);
4902 ppmajor = PPNOCODE;
4903 }else{
4904 while(
4905 pppParser->ppidx >= 0 &&
4906 ppmx != PPERRORSYMBOL &&
4907 (ppact = pp_find_shift_action(pppParser,PPERRORSYMBOL)) >= PPNSTATE
4908 ){
4909 pp_pop_parser_stack(pppParser);
4910 }
4911 if( pppParser->ppidx < 0 || ppmajor==0 ){
4912 pp_destructor(ppmajor,&ppminorunion);
4913 pp_parse_failed(pppParser);
4914 ppmajor = PPNOCODE;
4915 }else if( ppmx!=PPERRORSYMBOL ){
4916 PPMINORTYPE u2;
4917 u2.PPERRSYMDT = 0;
4918 pp_shift(pppParser,ppact,PPERRORSYMBOL,&u2);
4919 }
4920 }
4921 pppParser->pperrcnt = 3;
4922 pperrorhit = 1;
4923 #else /* PPERRORSYMBOL is not defined */
4924 /* This is what we do if the grammar does not define ERROR:
4925 **
4926 ** * Report an error message, and throw away the input token.
4927 **
4928 ** * If the input token is $, then fail the parse.
4929 **
4930 ** As before, subsequent error messages are suppressed until
4931 ** three input tokens have been successfully shifted.
4932 */
4933 if( pppParser->pperrcnt<=0 ){
4934 pp_syntax_error(pppParser,ppmajor,ppminorunion);
4935 }
4936 pppParser->pperrcnt = 3;
4937 pp_destructor(ppmajor,&ppminorunion);
4938 if( ppendofinput ){
4939 pp_parse_failed(pppParser);
4940 }
4941 ppmajor = PPNOCODE;
4942 #endif
4943 }else{
4944 pp_accept(pppParser);
4945 ppmajor = PPNOCODE;
4946 }
4947 }while( ppmajor!=PPNOCODE && pppParser->ppidx>=0 );
4948 return;
4949 }
4950 #endif
4951
4952 /*
4953 +------------------------------------------------------------------------+
4954 | Phalcon Framework |
4955 +------------------------------------------------------------------------+
4956 | Copyright (c) 2011-2016 Phalcon Team (http://www.phalconphp.com) |
4957 +------------------------------------------------------------------------+
4958 | This source file is subject to the New BSD License that is bundled |
4959 | with this package in the file docs/LICENSE.txt. |
4960 | |
4961 | If you did not receive a copy of the license and are unable to |
4962 | obtain it through the world-wide-web, please send an email |
4963 | to license@phalconphp.com so we can send you a copy immediately. |
4964 +------------------------------------------------------------------------+
4965 | Authors: Andres Gutierrez <andres@phalconphp.com> |
4966 | Eduar Carvajal <eduar@phalconphp.com> |
4967 +------------------------------------------------------------------------+
4968 */
4969
4970 const phql_token_names phql_tokens[] =
4971 {
4972 { SL("INTEGER"), PHQL_T_INTEGER },
4973 { SL("DOUBLE"), PHQL_T_DOUBLE },
4974 { SL("STRING"), PHQL_T_STRING },
4975 { SL("IDENTIFIER"), PHQL_T_IDENTIFIER },
4976 { SL("HEXAINTEGER"), PHQL_T_HINTEGER },
4977 { SL("MINUS"), PHQL_T_MINUS },
4978 { SL("+"), PHQL_T_ADD },
4979 { SL("-"), PHQL_T_SUB },
4980 { SL("*"), PHQL_T_MUL },
4981 { SL("/"), PHQL_T_DIV },
4982 { SL("&"), PHQL_T_BITWISE_AND },
4983 { SL("|"), PHQL_T_BITWISE_OR },
4984 { SL("%%"), PHQL_T_MOD },
4985 { SL("AND"), PHQL_T_AND },
4986 { SL("OR"), PHQL_T_OR },
4987 { SL("LIKE"), PHQL_T_LIKE },
4988 { SL("ILIKE"), PHQL_T_ILIKE },
4989 { SL("DOT"), PHQL_T_DOT },
4990 { SL("COLON"), PHQL_T_COLON },
4991 { SL("COMMA"), PHQL_T_COMMA },
4992 { SL("EQUALS"), PHQL_T_EQUALS },
4993 { SL("NOT EQUALS"), PHQL_T_NOTEQUALS },
4994 { SL("NOT"), PHQL_T_NOT },
4995 { SL("<"), PHQL_T_LESS },
4996 { SL("<="), PHQL_T_LESSEQUAL },
4997 { SL(">"), PHQL_T_GREATER },
4998 { SL(">="), PHQL_T_GREATEREQUAL },
4999 { SL("("), PHQL_T_PARENTHESES_OPEN },
5000 { SL(")"), PHQL_T_PARENTHESES_CLOSE },
5001 { SL("NUMERIC PLACEHOLDER"), PHQL_T_NPLACEHOLDER },
5002 { SL("STRING PLACEHOLDER"), PHQL_T_SPLACEHOLDER },
5003 { SL("UPDATE"), PHQL_T_UPDATE },
5004 { SL("SET"), PHQL_T_SET },
5005 { SL("WHERE"), PHQL_T_WHERE },
5006 { SL("DELETE"), PHQL_T_DELETE },
5007 { SL("FROM"), PHQL_T_FROM },
5008 { SL("AS"), PHQL_T_AS },
5009 { SL("INSERT"), PHQL_T_INSERT },
5010 { SL("INTO"), PHQL_T_INTO },
5011 { SL("VALUES"), PHQL_T_VALUES },
5012 { SL("SELECT"), PHQL_T_SELECT },
5013 { SL("ORDER"), PHQL_T_ORDER },
5014 { SL("BY"), PHQL_T_BY },
5015 { SL("LIMIT"), PHQL_T_LIMIT },
5016 { SL("OFFSET"), PHQL_T_OFFSET },
5017 { SL("GROUP"), PHQL_T_GROUP },
5018 { SL("HAVING"), PHQL_T_HAVING },
5019 { SL("IN"), PHQL_T_IN },
5020 { SL("ON"), PHQL_T_ON },
5021 { SL("INNER"), PHQL_T_INNER },
5022 { SL("JOIN"), PHQL_T_JOIN },
5023 { SL("LEFT"), PHQL_T_LEFT },
5024 { SL("RIGHT"), PHQL_T_RIGHT },
5025 { SL("IS"), PHQL_T_IS },
5026 { SL("NULL"), PHQL_T_NULL },
5027 { SL("NOT IN"), PHQL_T_NOTIN },
5028 { SL("CROSS"), PHQL_T_CROSS },
5029 { SL("OUTER"), PHQL_T_OUTER },
5030 { SL("FULL"), PHQL_T_FULL },
5031 { SL("ASC"), PHQL_T_ASC },
5032 { SL("DESC"), PHQL_T_DESC },
5033 { SL("BETWEEN"), PHQL_T_BETWEEN },
5034 { SL("DISTINCT"), PHQL_T_DISTINCT },
5035 { SL("AGAINST"), PHQL_T_AGAINST },
5036 { SL("CAST"), PHQL_T_CAST },
5037 { SL("CONVERT"), PHQL_T_CONVERT },
5038 { SL("USING"), PHQL_T_USING },
5039 { SL("ALL"), PHQL_T_ALL },
5040 { SL("EXISTS"), PHQL_T_EXISTS },
5041 { SL("CASE"), PHQL_T_CASE },
5042 { SL("WHEN"), PHQL_T_WHEN },
5043 { SL("THEN"), PHQL_T_THEN },
5044 { SL("ELSE"), PHQL_T_ELSE },
5045 { SL("END"), PHQL_T_END },
5046 { SL("FOR"), PHQL_T_FOR },
5047 { SL("WITH"), PHQL_T_WITH },
5048 { NULL, 0, 0 }
5049 };
5050
phql_wrapper_alloc(size_t bytes)5051 static void *phql_wrapper_alloc(size_t bytes)
5052 {
5053 return emalloc(bytes);
5054 }
5055
phql_wrapper_free(void * pointer)5056 static void phql_wrapper_free(void *pointer)
5057 {
5058 efree(pointer);
5059 }
5060
phql_parse_with_token(void * phql_parser,int opcode,int parsercode,phql_scanner_token * token,phql_parser_status * parser_status)5061 static void phql_parse_with_token(void* phql_parser, int opcode, int parsercode, phql_scanner_token *token, phql_parser_status *parser_status)
5062 {
5063
5064 phql_parser_token *pToken;
5065
5066 pToken = emalloc(sizeof(phql_parser_token));
5067 pToken->opcode = opcode;
5068 pToken->token = token->value;
5069 pToken->token_len = token->len;
5070 pToken->free_flag = 1;
5071 phql_(phql_parser, parsercode, pToken, parser_status);
5072
5073 token->value = NULL;
5074 token->len = 0;
5075 }
5076
5077 /**
5078 * Creates an error message when it's triggered by the scanner
5079 */
phql_scanner_error_msg(phql_parser_status * parser_status,zval ** error_msg TSRMLS_DC)5080 static void phql_scanner_error_msg(phql_parser_status *parser_status, zval **error_msg TSRMLS_DC)
5081 {
5082
5083 char *error = NULL, *error_part;
5084 unsigned int length;
5085 phql_scanner_state *state = parser_status->scanner_state;
5086
5087 #if PHP_VERSION_ID < 70000
5088 MAKE_STD_ZVAL(*error_msg);
5089 #else
5090 ZVAL_UNDEF(*error_msg);
5091 #endif
5092
5093 if (state->start) {
5094 length = 64 + state->start_length + parser_status->phql_length;
5095 error = emalloc(sizeof(char) * length);
5096 if (state->start_length > 16) {
5097 error_part = estrndup(state->start, 16);
5098 snprintf(error, length, "Scanning error before '%s...' when parsing: %s (%d)", error_part, parser_status->phql, parser_status->phql_length);
5099 efree(error_part);
5100 } else {
5101 snprintf(error, length, "Scanning error before '%s' when parsing: %s (%d)", state->start, parser_status->phql, parser_status->phql_length);
5102 }
5103 error[length - 1] = '\0';
5104 #if PHP_VERSION_ID < 70000
5105 ZVAL_STRING(*error_msg, error, 1);
5106 #else
5107 ZVAL_STRING(*error_msg, error);
5108 #endif
5109 } else {
5110 #if PHP_VERSION_ID < 70000
5111 ZVAL_STRING(*error_msg, "Scanning error near to EOF", 1);
5112 #else
5113 ZVAL_STRING(*error_msg, "Scanning error near to EOF");
5114 #endif
5115 }
5116
5117 if (error) {
5118 efree(error);
5119 }
5120 }
5121
5122 /**
5123 * Executes the internal PHQL parser/tokenizer
5124 */
phql_parse_phql(zval * result,zval * phql TSRMLS_DC)5125 int phql_parse_phql(zval *result, zval *phql TSRMLS_DC)
5126 {
5127 #if PHP_VERSION_ID < 70000
5128 zval *error_msg = NULL;
5129 #else
5130 zval err_msg, *error_msg = &err_msg;
5131 ZVAL_UNDEF(error_msg);
5132 #endif
5133
5134 ZVAL_NULL(result);
5135
5136 if (phql_internal_parse_phql(&result, Z_STRVAL_P(phql), Z_STRLEN_P(phql), &error_msg TSRMLS_CC) == FAILURE) {
5137 ZEPHIR_THROW_EXCEPTION_STRW(phalcon_mvc_model_exception_ce, Z_STRVAL_P(error_msg));
5138 return FAILURE;
5139 }
5140
5141 return SUCCESS;
5142 }
5143
5144 /**
5145 * Executes a PHQL parser/tokenizer
5146 */
phql_internal_parse_phql(zval ** result,char * phql,unsigned int phql_length,zval ** error_msg TSRMLS_DC)5147 int phql_internal_parse_phql(zval **result, char *phql, unsigned int phql_length, zval **error_msg TSRMLS_DC)
5148 {
5149 zend_phalcon_globals *phalcon_globals_ptr = ZEPHIR_VGLOBAL;
5150 phql_parser_status *parser_status = NULL;
5151 int scanner_status, status = SUCCESS, error_length, cache_level;
5152 phql_scanner_state *state;
5153 phql_scanner_token token;
5154 void* phql_parser;
5155 char *error;
5156 unsigned long phql_key = 0;
5157 #if PHP_VERSION_ID < 70000
5158 zval **temp_ast;
5159 #else
5160 zval *temp_ast;
5161 #endif
5162
5163 if (!phql) {
5164 #if PHP_VERSION_ID < 70000
5165 MAKE_STD_ZVAL(*error_msg);
5166 ZVAL_STRING(*error_msg, "PHQL statement cannot be NULL", 1);
5167 #else
5168 ZVAL_STRING(*error_msg, "PHQL statement cannot be NULL");
5169 #endif
5170 return FAILURE;
5171 }
5172
5173 cache_level = phalcon_globals_ptr->orm.cache_level;
5174 if (cache_level >= 0) {
5175 phql_key = zend_inline_hash_func(phql, phql_length + 1);
5176 if (phalcon_globals_ptr->orm.parser_cache != NULL) {
5177 #if PHP_VERSION_ID < 70000
5178 if (zend_hash_index_find(phalcon_globals_ptr->orm.parser_cache, phql_key, (void**) &temp_ast) == SUCCESS) {
5179 ZVAL_ZVAL(*result, *temp_ast, 1, 0);
5180 Z_SET_REFCOUNT_P(*result, 1);
5181 return SUCCESS;
5182 }
5183 #else
5184 if ((temp_ast = zend_hash_index_find(phalcon_globals_ptr->orm.parser_cache, phql_key)) != NULL) {
5185 ZVAL_ZVAL(*result, temp_ast, 1, 0);
5186 Z_TRY_ADDREF_P(*result);
5187 return SUCCESS;
5188 }
5189 #endif
5190 }
5191 }
5192
5193 phql_parser = phql_Alloc(phql_wrapper_alloc);
5194
5195 parser_status = emalloc(sizeof(phql_parser_status));
5196 state = emalloc(sizeof(phql_scanner_state));
5197
5198 parser_status->status = PHQL_PARSING_OK;
5199 parser_status->scanner_state = state;
5200 #if PHP_VERSION_ID < 70000
5201 parser_status->ret = NULL;
5202 #else
5203 ZVAL_UNDEF(&parser_status->ret);
5204 #endif
5205 parser_status->syntax_error = NULL;
5206 parser_status->token = &token;
5207 parser_status->enable_literals = phalcon_globals_ptr->orm.enable_literals;
5208 parser_status->phql = phql;
5209 parser_status->phql_length = phql_length;
5210
5211 state->active_token = 0;
5212 state->start = phql;
5213 state->start_length = 0;
5214 state->end = state->start;
5215
5216 token.value = NULL;
5217 token.len = 0;
5218
5219 while (0 <= (scanner_status = phql_get_token(state, &token))) {
5220
5221 /* Calculate the 'start' length */
5222 state->start_length = (phql + phql_length - state->start);
5223
5224 state->active_token = token.opcode;
5225
5226 /* Parse the token found */
5227 switch (token.opcode) {
5228
5229 case PHQL_T_IGNORE:
5230 break;
5231
5232 case PHQL_T_ADD:
5233 phql_(phql_parser, PHQL_PLUS, NULL, parser_status);
5234 break;
5235 case PHQL_T_SUB:
5236 phql_(phql_parser, PHQL_MINUS, NULL, parser_status);
5237 break;
5238 case PHQL_T_MUL:
5239 phql_(phql_parser, PHQL_TIMES, NULL, parser_status);
5240 break;
5241 case PHQL_T_DIV:
5242 phql_(phql_parser, PHQL_DIVIDE, NULL, parser_status);
5243 break;
5244 case PHQL_T_MOD:
5245 phql_(phql_parser, PHQL_MOD, NULL, parser_status);
5246 break;
5247 case PHQL_T_AND:
5248 phql_(phql_parser, PHQL_AND, NULL, parser_status);
5249 break;
5250 case PHQL_T_OR:
5251 phql_(phql_parser, PHQL_OR, NULL, parser_status);
5252 break;
5253 case PHQL_T_EQUALS:
5254 phql_(phql_parser, PHQL_EQUALS, NULL, parser_status);
5255 break;
5256 case PHQL_T_NOTEQUALS:
5257 phql_(phql_parser, PHQL_NOTEQUALS, NULL, parser_status);
5258 break;
5259 case PHQL_T_LESS:
5260 phql_(phql_parser, PHQL_LESS, NULL, parser_status);
5261 break;
5262 case PHQL_T_GREATER:
5263 phql_(phql_parser, PHQL_GREATER, NULL, parser_status);
5264 break;
5265 case PHQL_T_GREATEREQUAL:
5266 phql_(phql_parser, PHQL_GREATEREQUAL, NULL, parser_status);
5267 break;
5268 case PHQL_T_LESSEQUAL:
5269 phql_(phql_parser, PHQL_LESSEQUAL, NULL, parser_status);
5270 break;
5271
5272 case PHQL_T_IDENTIFIER:
5273 phql_parse_with_token(phql_parser, PHQL_T_IDENTIFIER, PHQL_IDENTIFIER, &token, parser_status);
5274 break;
5275
5276 case PHQL_T_DOT:
5277 phql_(phql_parser, PHQL_DOT, NULL, parser_status);
5278 break;
5279 case PHQL_T_COMMA:
5280 phql_(phql_parser, PHQL_COMMA, NULL, parser_status);
5281 break;
5282
5283 case PHQL_T_PARENTHESES_OPEN:
5284 phql_(phql_parser, PHQL_PARENTHESES_OPEN, NULL, parser_status);
5285 break;
5286 case PHQL_T_PARENTHESES_CLOSE:
5287 phql_(phql_parser, PHQL_PARENTHESES_CLOSE, NULL, parser_status);
5288 break;
5289
5290 case PHQL_T_LIKE:
5291 phql_(phql_parser, PHQL_LIKE, NULL, parser_status);
5292 break;
5293 case PHQL_T_ILIKE:
5294 phql_(phql_parser, PHQL_ILIKE, NULL, parser_status);
5295 break;
5296 case PHQL_T_NOT:
5297 phql_(phql_parser, PHQL_NOT, NULL, parser_status);
5298 break;
5299 case PHQL_T_BITWISE_AND:
5300 phql_(phql_parser, PHQL_BITWISE_AND, NULL, parser_status);
5301 break;
5302 case PHQL_T_BITWISE_OR:
5303 phql_(phql_parser, PHQL_BITWISE_OR, NULL, parser_status);
5304 break;
5305 case PHQL_T_BITWISE_NOT:
5306 phql_(phql_parser, PHQL_BITWISE_NOT, NULL, parser_status);
5307 break;
5308 case PHQL_T_BITWISE_XOR:
5309 phql_(phql_parser, PHQL_BITWISE_XOR, NULL, parser_status);
5310 break;
5311 case PHQL_T_AGAINST:
5312 phql_(phql_parser, PHQL_AGAINST, NULL, parser_status);
5313 break;
5314 case PHQL_T_CASE:
5315 phql_(phql_parser, PHQL_CASE, NULL, parser_status);
5316 break;
5317 case PHQL_T_WHEN:
5318 phql_(phql_parser, PHQL_WHEN, NULL, parser_status);
5319 break;
5320 case PHQL_T_THEN:
5321 phql_(phql_parser, PHQL_THEN, NULL, parser_status);
5322 break;
5323 case PHQL_T_END:
5324 phql_(phql_parser, PHQL_END, NULL, parser_status);
5325 break;
5326 case PHQL_T_ELSE:
5327 phql_(phql_parser, PHQL_ELSE, NULL, parser_status);
5328 break;
5329 case PHQL_T_FOR:
5330 phql_(phql_parser, PHQL_FOR, NULL, parser_status);
5331 break;
5332 case PHQL_T_WITH:
5333 phql_(phql_parser, PHQL_WITH, NULL, parser_status);
5334 break;
5335
5336 case PHQL_T_INTEGER:
5337 if (parser_status->enable_literals) {
5338 phql_parse_with_token(phql_parser, PHQL_T_INTEGER, PHQL_INTEGER, &token, parser_status);
5339 } else {
5340 #if PHP_VERSION_ID < 70000
5341 MAKE_STD_ZVAL(*error_msg);
5342 ZVAL_STRING(*error_msg, "Literals are disabled in PHQL statements", 1);
5343 #else
5344 ZVAL_STRING(*error_msg, "Literals are disabled in PHQL statements");
5345 #endif
5346 parser_status->status = PHQL_PARSING_FAILED;
5347 }
5348 break;
5349 case PHQL_T_DOUBLE:
5350 if (parser_status->enable_literals) {
5351 phql_parse_with_token(phql_parser, PHQL_T_DOUBLE, PHQL_DOUBLE, &token, parser_status);
5352 } else {
5353 #if PHP_VERSION_ID < 70000
5354 MAKE_STD_ZVAL(*error_msg);
5355 ZVAL_STRING(*error_msg, "Literals are disabled in PHQL statements", 1);
5356 #else
5357 ZVAL_STRING(*error_msg, "Literals are disabled in PHQL statements");
5358 #endif
5359 parser_status->status = PHQL_PARSING_FAILED;
5360 }
5361 break;
5362 case PHQL_T_STRING:
5363 if (parser_status->enable_literals) {
5364 phql_parse_with_token(phql_parser, PHQL_T_STRING, PHQL_STRING, &token, parser_status);
5365 } else {
5366 #if PHP_VERSION_ID < 70000
5367 MAKE_STD_ZVAL(*error_msg);
5368 ZVAL_STRING(*error_msg, "Literals are disabled in PHQL statements", 1);
5369 #else
5370 ZVAL_STRING(*error_msg, "Literals are disabled in PHQL statements");
5371 #endif
5372 parser_status->status = PHQL_PARSING_FAILED;
5373 }
5374 break;
5375 case PHQL_T_TRUE:
5376 if (parser_status->enable_literals) {
5377 phql_(phql_parser, PHQL_TRUE, NULL, parser_status);
5378 } else {
5379 #if PHP_VERSION_ID < 70000
5380 MAKE_STD_ZVAL(*error_msg);
5381 ZVAL_STRING(*error_msg, "Literals are disabled in PHQL statements", 1);
5382 #else
5383 ZVAL_STRING(*error_msg, "Literals are disabled in PHQL statements");
5384 #endif
5385 parser_status->status = PHQL_PARSING_FAILED;
5386 }
5387 break;
5388 case PHQL_T_FALSE:
5389 if (parser_status->enable_literals) {
5390 phql_(phql_parser, PHQL_FALSE, NULL, parser_status);
5391 } else {
5392 #if PHP_VERSION_ID < 70000
5393 MAKE_STD_ZVAL(*error_msg);
5394 ZVAL_STRING(*error_msg, "Literals are disabled in PHQL statements", 1);
5395 #else
5396 ZVAL_STRING(*error_msg, "Literals are disabled in PHQL statements");
5397 #endif
5398 parser_status->status = PHQL_PARSING_FAILED;
5399 }
5400 break;
5401 case PHQL_T_HINTEGER:
5402 if (parser_status->enable_literals) {
5403 phql_parse_with_token(phql_parser, PHQL_T_HINTEGER, PHQL_HINTEGER, &token, parser_status);
5404 } else {
5405 #if PHP_VERSION_ID < 70000
5406 MAKE_STD_ZVAL(*error_msg);
5407 ZVAL_STRING(*error_msg, "Literals are disabled in PHQL statements", 1);
5408 #else
5409 ZVAL_STRING(*error_msg, "Literals are disabled in PHQL statements");
5410 #endif
5411 parser_status->status = PHQL_PARSING_FAILED;
5412 }
5413 break;
5414
5415 case PHQL_T_NPLACEHOLDER:
5416 phql_parse_with_token(phql_parser, PHQL_T_NPLACEHOLDER, PHQL_NPLACEHOLDER, &token, parser_status);
5417 break;
5418 case PHQL_T_SPLACEHOLDER:
5419 phql_parse_with_token(phql_parser, PHQL_T_SPLACEHOLDER, PHQL_SPLACEHOLDER, &token, parser_status);
5420 break;
5421 case PHQL_T_BPLACEHOLDER:
5422 phql_parse_with_token(phql_parser, PHQL_T_BPLACEHOLDER, PHQL_BPLACEHOLDER, &token, parser_status);
5423 break;
5424
5425 case PHQL_T_FROM:
5426 phql_(phql_parser, PHQL_FROM, NULL, parser_status);
5427 break;
5428 case PHQL_T_UPDATE:
5429 phql_(phql_parser, PHQL_UPDATE, NULL, parser_status);
5430 break;
5431 case PHQL_T_SET:
5432 phql_(phql_parser, PHQL_SET, NULL, parser_status);
5433 break;
5434 case PHQL_T_WHERE:
5435 phql_(phql_parser, PHQL_WHERE, NULL, parser_status);
5436 break;
5437 case PHQL_T_DELETE:
5438 phql_(phql_parser, PHQL_DELETE, NULL, parser_status);
5439 break;
5440 case PHQL_T_INSERT:
5441 phql_(phql_parser, PHQL_INSERT, NULL, parser_status);
5442 break;
5443 case PHQL_T_INTO:
5444 phql_(phql_parser, PHQL_INTO, NULL, parser_status);
5445 break;
5446 case PHQL_T_VALUES:
5447 phql_(phql_parser, PHQL_VALUES, NULL, parser_status);
5448 break;
5449 case PHQL_T_SELECT:
5450 phql_(phql_parser, PHQL_SELECT, NULL, parser_status);
5451 break;
5452 case PHQL_T_AS:
5453 phql_(phql_parser, PHQL_AS, NULL, parser_status);
5454 break;
5455 case PHQL_T_ORDER:
5456 phql_(phql_parser, PHQL_ORDER, NULL, parser_status);
5457 break;
5458 case PHQL_T_BY:
5459 phql_(phql_parser, PHQL_BY, NULL, parser_status);
5460 break;
5461 case PHQL_T_LIMIT:
5462 phql_(phql_parser, PHQL_LIMIT, NULL, parser_status);
5463 break;
5464 case PHQL_T_OFFSET:
5465 phql_(phql_parser, PHQL_OFFSET, NULL, parser_status);
5466 break;
5467 case PHQL_T_GROUP:
5468 phql_(phql_parser, PHQL_GROUP, NULL, parser_status);
5469 break;
5470 case PHQL_T_HAVING:
5471 phql_(phql_parser, PHQL_HAVING, NULL, parser_status);
5472 break;
5473 case PHQL_T_ASC:
5474 phql_(phql_parser, PHQL_ASC, NULL, parser_status);
5475 break;
5476 case PHQL_T_DESC:
5477 phql_(phql_parser, PHQL_DESC, NULL, parser_status);
5478 break;
5479 case PHQL_T_IN:
5480 phql_(phql_parser, PHQL_IN, NULL, parser_status);
5481 break;
5482 case PHQL_T_ON:
5483 phql_(phql_parser, PHQL_ON, NULL, parser_status);
5484 break;
5485 case PHQL_T_INNER:
5486 phql_(phql_parser, PHQL_INNER, NULL, parser_status);
5487 break;
5488 case PHQL_T_JOIN:
5489 phql_(phql_parser, PHQL_JOIN, NULL, parser_status);
5490 break;
5491 case PHQL_T_LEFT:
5492 phql_(phql_parser, PHQL_LEFT, NULL, parser_status);
5493 break;
5494 case PHQL_T_RIGHT:
5495 phql_(phql_parser, PHQL_RIGHT, NULL, parser_status);
5496 break;
5497 case PHQL_T_CROSS:
5498 phql_(phql_parser, PHQL_CROSS, NULL, parser_status);
5499 break;
5500 case PHQL_T_FULL:
5501 phql_(phql_parser, PHQL_FULL, NULL, parser_status);
5502 break;
5503 case PHQL_T_OUTER:
5504 phql_(phql_parser, PHQL_OUTER, NULL, parser_status);
5505 break;
5506 case PHQL_T_IS:
5507 phql_(phql_parser, PHQL_IS, NULL, parser_status);
5508 break;
5509 case PHQL_T_NULL:
5510 phql_(phql_parser, PHQL_NULL, NULL, parser_status);
5511 break;
5512 case PHQL_T_BETWEEN:
5513 phql_(phql_parser, PHQL_BETWEEN, NULL, parser_status);
5514 break;
5515 case PHQL_T_DISTINCT:
5516 phql_(phql_parser, PHQL_DISTINCT, NULL, parser_status);
5517 break;
5518 case PHQL_T_ALL:
5519 phql_(phql_parser, PHQL_ALL, NULL, parser_status);
5520 break;
5521 case PHQL_T_CAST:
5522 phql_(phql_parser, PHQL_CAST, NULL, parser_status);
5523 break;
5524 case PHQL_T_CONVERT:
5525 phql_(phql_parser, PHQL_CONVERT, NULL, parser_status);
5526 break;
5527 case PHQL_T_USING:
5528 phql_(phql_parser, PHQL_USING, NULL, parser_status);
5529 break;
5530 case PHQL_T_EXISTS:
5531 phql_(phql_parser, PHQL_EXISTS, NULL, parser_status);
5532 break;
5533
5534 default:
5535 parser_status->status = PHQL_PARSING_FAILED;
5536 error_length = sizeof(char) * 32;
5537 error = emalloc(error_length);
5538 snprintf(error, error_length, "Scanner: Unknown opcode %d", token.opcode);
5539 error[error_length - 1] = '\0';
5540 #if PHP_VERSION_ID < 70000
5541 MAKE_STD_ZVAL(*error_msg);
5542 ZVAL_STRING(*error_msg, error, 1);
5543 #else
5544 ZVAL_STRING(*error_msg, error);
5545 #endif
5546 efree(error);
5547 break;
5548 }
5549
5550 if (parser_status->status != PHQL_PARSING_OK) {
5551 status = FAILURE;
5552 break;
5553 }
5554
5555 state->end = state->start;
5556 }
5557
5558 if (status != FAILURE) {
5559 switch (scanner_status) {
5560
5561 case PHQL_SCANNER_RETCODE_ERR:
5562 case PHQL_SCANNER_RETCODE_IMPOSSIBLE:
5563 #if PHP_VERSION_ID < 70000
5564 if (!*error_msg) {
5565 phql_scanner_error_msg(parser_status, error_msg TSRMLS_CC);
5566 }
5567 #else
5568 if (Z_TYPE_P(*error_msg) == IS_UNDEF) {
5569 phql_scanner_error_msg(parser_status, error_msg TSRMLS_CC);
5570 }
5571 #endif
5572 status = FAILURE;
5573 break;
5574
5575 default:
5576 phql_(phql_parser, 0, NULL, parser_status);
5577 }
5578 }
5579
5580 state->active_token = 0;
5581 state->start = NULL;
5582
5583 if (parser_status->status != PHQL_PARSING_OK) {
5584 status = FAILURE;
5585 if (parser_status->syntax_error) {
5586 #if PHP_VERSION_ID < 70000
5587 if (!*error_msg) {
5588 MAKE_STD_ZVAL(*error_msg);
5589 ZVAL_STRING(*error_msg, parser_status->syntax_error, 1);
5590 }
5591 #else
5592 if (Z_TYPE_P(*error_msg) == IS_UNDEF) {
5593 ZVAL_STRING(*error_msg, parser_status->syntax_error);
5594 }
5595 #endif
5596 efree(parser_status->syntax_error);
5597 }
5598 }
5599
5600 phql_Free(phql_parser, phql_wrapper_free);
5601
5602 if (status != FAILURE) {
5603 if (parser_status->status == PHQL_PARSING_OK) {
5604 #if PHP_VERSION_ID < 70000
5605 if (parser_status->ret) {
5606 #else
5607 if (Z_TYPE_P(&parser_status->ret) == IS_ARRAY) {
5608 #endif
5609
5610 /**
5611 * Set a unique id for the parsed ast
5612 */
5613 if (phalcon_globals_ptr->orm.cache_level >= 1) {
5614 #if PHP_VERSION_ID < 70000
5615 if (Z_TYPE_P(parser_status->ret) == IS_ARRAY) {
5616 add_assoc_long(parser_status->ret, "id", phalcon_globals_ptr->orm.unique_cache_id++);
5617 }
5618 #else
5619 if (Z_TYPE_P(&parser_status->ret) == IS_ARRAY) {
5620 add_assoc_long(&parser_status->ret, "id", phalcon_globals_ptr->orm.unique_cache_id++);
5621 }
5622 #endif
5623 }
5624
5625 #if PHP_VERSION_ID < 70000
5626 ZVAL_ZVAL(*result, parser_status->ret, 0, 0);
5627 ZVAL_NULL(parser_status->ret);
5628 zval_ptr_dtor(&parser_status->ret);
5629 #else
5630 ZVAL_ZVAL(*result, &parser_status->ret, 1, 1);
5631 #endif
5632
5633 /**
5634 * Store the parsed definition in the cache
5635 */
5636 if (cache_level >= 0) {
5637
5638 if (!phalcon_globals_ptr->orm.parser_cache) {
5639 ALLOC_HASHTABLE(phalcon_globals_ptr->orm.parser_cache);
5640 zend_hash_init(phalcon_globals_ptr->orm.parser_cache, 0, NULL, ZVAL_PTR_DTOR, 0);
5641 }
5642
5643 #if PHP_VERSION_ID < 70000
5644
5645 Z_ADDREF_PP(result);
5646
5647 zend_hash_index_update(
5648 phalcon_globals_ptr->orm.parser_cache,
5649 phql_key,
5650 result,
5651 sizeof(zval *),
5652 NULL
5653 );
5654 #else
5655 Z_TRY_ADDREF_P(*result);
5656
5657 zend_hash_index_update(
5658 phalcon_globals_ptr->orm.parser_cache,
5659 phql_key,
5660 *result
5661 );
5662 #endif
5663 }
5664
5665 } else {
5666 #if PHP_VERSION_ID < 70000
5667 efree(parser_status->ret);
5668 #endif
5669 }
5670 }
5671 }
5672
5673 efree(parser_status);
5674 efree(state);
5675
5676 return status;
5677 }
5678