1 /* Driver template for the LEMON parser generator.
2 ** The author disclaims copyright to this source code.
3 */
4 /* First off, code is included that follows the "include" declaration
5 ** in the input grammar file. */
6 #include <stdio.h>
7 #line 36 "./parser.y"
8
9 #include <string.h>
10 #include <glib.h>
11 #include <glib-object.h>
12 #include <glib/gi18n-lib.h>
13 #include <libgda/sql-parser/gda-sql-parser-private.h>
14 #include <libgda/sql-parser/gda-statement-struct-util.h>
15 #include <libgda/sql-parser/gda-statement-struct-trans.h>
16 #include <libgda/sql-parser/gda-statement-struct-insert.h>
17 #include <libgda/sql-parser/gda-statement-struct-update.h>
18 #include <libgda/sql-parser/gda-statement-struct-delete.h>
19 #include <libgda/sql-parser/gda-statement-struct-select.h>
20 #include <libgda/sql-parser/gda-statement-struct-compound.h>
21 #include <libgda/sql-parser/gda-statement-struct-parts.h>
22 #include <assert.h>
23
24 typedef struct {
25 GValue *fname;
26 GdaSqlExpr *expr;
27 } UpdateSet;
28
29 typedef struct {
30 gboolean distinct;
31 GdaSqlExpr *expr;
32 } Distinct;
33
34 typedef struct {
35 GdaSqlExpr *count;
36 GdaSqlExpr *offset;
37 } Limit;
38
39 typedef struct {
40 GSList *when_list;
41 GSList *then_list;
42 } CaseBody;
43
44 static GdaSqlOperatorType
sql_operation_string_to_operator(const gchar * op)45 sql_operation_string_to_operator (const gchar *op)
46 {
47 switch (g_ascii_toupper (*op)) {
48 case 'A':
49 return GDA_SQL_OPERATOR_TYPE_AND;
50 case 'O':
51 return GDA_SQL_OPERATOR_TYPE_OR;
52 case 'N':
53 return GDA_SQL_OPERATOR_TYPE_NOT;
54 case '=':
55 return GDA_SQL_OPERATOR_TYPE_EQ;
56 case 'I':
57 if (op[1] == 'S')
58 return GDA_SQL_OPERATOR_TYPE_IS;
59 else if (op[1] == 'N')
60 return GDA_SQL_OPERATOR_TYPE_IN;
61 else if (op[1] == 'I')
62 return GDA_SQL_OPERATOR_TYPE_ILIKE;
63 break;
64 case 'L':
65 return GDA_SQL_OPERATOR_TYPE_LIKE;
66 case 'B':
67 return GDA_SQL_OPERATOR_TYPE_BETWEEN;
68 case '>':
69 if (op[1] == '=')
70 return GDA_SQL_OPERATOR_TYPE_GEQ;
71 else if (op[1] == 0)
72 return GDA_SQL_OPERATOR_TYPE_GT;
73 break;
74 case '<':
75 if (op[1] == '=')
76 return GDA_SQL_OPERATOR_TYPE_LEQ;
77 else if (op[1] == '>')
78 return GDA_SQL_OPERATOR_TYPE_DIFF;
79 else if (op[1] == 0)
80 return GDA_SQL_OPERATOR_TYPE_LT;
81 break;
82 case '!':
83 if (op[1] == '=')
84 return GDA_SQL_OPERATOR_TYPE_DIFF;
85 else if (op[1] == '~') {
86 if (op[2] == 0)
87 return GDA_SQL_OPERATOR_TYPE_NOT_REGEXP;
88 else if (op[2] == '*')
89 return GDA_SQL_OPERATOR_TYPE_NOT_REGEXP_CI;
90 }
91 break;
92 case '~':
93 if (op[1] == '*')
94 return GDA_SQL_OPERATOR_TYPE_REGEXP_CI;
95 else if (op[1] == 0)
96 return GDA_SQL_OPERATOR_TYPE_REGEXP;
97 break;
98 case 'S':
99 return GDA_SQL_OPERATOR_TYPE_SIMILAR;
100 case '|':
101 if (op[1] == '|')
102 return GDA_SQL_OPERATOR_TYPE_CONCAT;
103 else
104 return GDA_SQL_OPERATOR_TYPE_BITOR;
105 case '+':
106 return GDA_SQL_OPERATOR_TYPE_PLUS;
107 case '-':
108 return GDA_SQL_OPERATOR_TYPE_MINUS;
109 case '*':
110 return GDA_SQL_OPERATOR_TYPE_STAR;
111 case '/':
112 return GDA_SQL_OPERATOR_TYPE_DIV;
113 case '%':
114 return GDA_SQL_OPERATOR_TYPE_REM;
115 case '&':
116 return GDA_SQL_OPERATOR_TYPE_BITAND;
117 }
118 g_error ("Unhandled operator named '%s'\n", op);
119 return 0;
120 }
121
122 static GdaSqlOperatorType
string_to_op_type(GValue * value)123 string_to_op_type (GValue *value)
124 {
125 GdaSqlOperatorType op;
126 op = sql_operation_string_to_operator (g_value_get_string (value));
127 g_value_reset (value);
128 g_free (value);
129 return op;
130 }
131
132 static GdaSqlExpr *
compose_multiple_expr(GdaSqlOperatorType op,GdaSqlExpr * left,GdaSqlExpr * right)133 compose_multiple_expr (GdaSqlOperatorType op, GdaSqlExpr *left, GdaSqlExpr *right) {
134 GdaSqlExpr *ret;
135 if (left->cond && (left->cond->operator_type == op)) {
136 ret = left;
137 ret->cond->operands = g_slist_append (ret->cond->operands, right);
138 }
139 else {
140 GdaSqlOperation *cond;
141 ret = gda_sql_expr_new (NULL);
142 cond = gda_sql_operation_new (GDA_SQL_ANY_PART (ret));
143 ret->cond = cond;
144 cond->operator_type = op;
145 cond->operands = g_slist_prepend (NULL, right);
146 GDA_SQL_ANY_PART (right)->parent = GDA_SQL_ANY_PART (cond);
147 cond->operands = g_slist_prepend (cond->operands, left);
148 GDA_SQL_ANY_PART (left)->parent = GDA_SQL_ANY_PART (cond);
149 }
150 return ret;
151 }
152
153 static GdaSqlExpr *
create_two_expr(GdaSqlOperatorType op,GdaSqlExpr * left,GdaSqlExpr * right)154 create_two_expr (GdaSqlOperatorType op, GdaSqlExpr *left, GdaSqlExpr *right) {
155 GdaSqlExpr *ret;
156 GdaSqlOperation *cond;
157 ret = gda_sql_expr_new (NULL);
158 cond = gda_sql_operation_new (GDA_SQL_ANY_PART (ret));
159 ret->cond = cond;
160 cond->operator_type = op;
161 cond->operands = g_slist_prepend (NULL, right);
162 GDA_SQL_ANY_PART (right)->parent = GDA_SQL_ANY_PART (cond);
163 cond->operands = g_slist_prepend (cond->operands, left);
164 GDA_SQL_ANY_PART (left)->parent = GDA_SQL_ANY_PART (cond);
165 return ret;
166 }
167
168 static GdaSqlExpr *
create_uni_expr(GdaSqlOperatorType op,GdaSqlExpr * expr)169 create_uni_expr (GdaSqlOperatorType op, GdaSqlExpr *expr) {
170 GdaSqlExpr *ret;
171 GdaSqlOperation *cond;
172 ret = gda_sql_expr_new (NULL);
173 cond = gda_sql_operation_new (GDA_SQL_ANY_PART (ret));
174 ret->cond = cond;
175 cond->operator_type = op;
176 cond->operands = g_slist_prepend (NULL, expr);
177 GDA_SQL_ANY_PART (expr)->parent = GDA_SQL_ANY_PART (cond);
178 return ret;
179 }
180
181 static GdaSqlStatement *
compose_multiple_compounds(GdaSqlStatementCompoundType ctype,GdaSqlStatement * left,GdaSqlStatement * right)182 compose_multiple_compounds (GdaSqlStatementCompoundType ctype, GdaSqlStatement *left, GdaSqlStatement *right) {
183 GdaSqlStatement *ret = NULL;
184 GdaSqlStatementCompound *lc = (GdaSqlStatementCompound*) left->contents;
185 if (lc->compound_type == ctype) {
186 GdaSqlStatementCompound *rc = (GdaSqlStatementCompound*) right->contents;
187 if (!rc->stmt_list->next || rc->compound_type == ctype) {
188 GSList *list;
189 for (list = rc->stmt_list; list; list = list->next)
190 GDA_SQL_ANY_PART (((GdaSqlStatement*)list->data)->contents)->parent = GDA_SQL_ANY_PART (lc);
191
192 ret = left;
193 lc->stmt_list = g_slist_concat (lc->stmt_list, rc->stmt_list);
194 rc->stmt_list = NULL;
195 gda_sql_statement_free (right);
196 }
197 }
198 else {
199 ret = gda_sql_statement_new (GDA_SQL_STATEMENT_COMPOUND);
200 gda_sql_statement_compound_set_type (ret, ctype);
201 gda_sql_statement_compound_take_stmt (ret, left);
202 gda_sql_statement_compound_take_stmt (ret, right);
203 }
204 return ret;
205 }
206
207 #line 208 "parser.c"
208 /* Next is all token values, in a form suitable for use by makeheaders.
209 ** This section will be null unless lemon is run with the -m switch.
210 */
211 /*
212 ** These constants (all generated automatically by the parser generator)
213 ** specify the various kinds of tokens (terminals) that the parser
214 ** understands.
215 **
216 ** Each symbol here is a terminal symbol in the grammar.
217 */
218 /* Make sure the INTERFACE macro is defined.
219 */
220 #ifndef INTERFACE
221 # define INTERFACE 1
222 #endif
223 /* The next thing included is series of defines which control
224 ** various aspects of the generated parser.
225 ** YYCODETYPE is the data type used for storing terminal
226 ** and nonterminal numbers. "unsigned char" is
227 ** used if there are fewer than 250 terminals
228 ** and nonterminals. "int" is used otherwise.
229 ** YYNOCODE is a number of type YYCODETYPE which corresponds
230 ** to no legal terminal or nonterminal number. This
231 ** number is used to fill in empty slots of the hash
232 ** table.
233 ** YYFALLBACK If defined, this indicates that one or more tokens
234 ** have fall-back values which should be used if the
235 ** original value of the token will not parse.
236 ** YYACTIONTYPE is the data type used for storing terminal
237 ** and nonterminal numbers. "unsigned char" is
238 ** used if there are fewer than 250 rules and
239 ** states combined. "int" is used otherwise.
240 ** priv_gda_sql_parserTOKENTYPE is the data type used for minor tokens given
241 ** directly to the parser from the tokenizer.
242 ** YYMINORTYPE is the data type used for all minor tokens.
243 ** This is typically a union of many types, one of
244 ** which is priv_gda_sql_parserTOKENTYPE. The entry in the union
245 ** for base tokens is called "yy0".
246 ** YYSTACKDEPTH is the maximum depth of the parser's stack. If
247 ** zero the stack is dynamically sized using realloc()
248 ** priv_gda_sql_parserARG_SDECL A static variable declaration for the %extra_argument
249 ** priv_gda_sql_parserARG_PDECL A parameter declaration for the %extra_argument
250 ** priv_gda_sql_parserARG_STORE Code to store %extra_argument into yypParser
251 ** priv_gda_sql_parserARG_FETCH Code to extract %extra_argument from yypParser
252 ** YYNSTATE the combined number of states.
253 ** YYNRULE the number of rules in the grammar
254 ** YYERRORSYMBOL is the code number of the error symbol. If not
255 ** defined, then do no error processing.
256 */
257 #define YYCODETYPE unsigned char
258 #define YYNOCODE 211
259 #define YYACTIONTYPE unsigned short int
260 #define priv_gda_sql_parserTOKENTYPE GValue *
261 typedef union {
262 int yyinit;
263 priv_gda_sql_parserTOKENTYPE yy0;
264 Limit yy44;
265 CaseBody yy59;
266 GdaSqlExpr * yy70;
267 GdaSqlStatement * yy116;
268 GdaSqlSelectTarget * yy134;
269 GdaSqlExpr* yy146;
270 GdaSqlOperatorType yy147;
271 GdaTransactionIsolation yy169;
272 GdaSqlSelectFrom * yy191;
273 gboolean yy276;
274 Distinct * yy297;
275 GSList * yy325;
276 GSList* yy333;
277 GdaSqlParamSpec * yy339;
278 GdaSqlSelectJoinType yy371;
279 } YYMINORTYPE;
280 #ifndef YYSTACKDEPTH
281 #define YYSTACKDEPTH 100
282 #endif
283 #define priv_gda_sql_parserARG_SDECL GdaSqlParserIface *pdata;
284 #define priv_gda_sql_parserARG_PDECL ,GdaSqlParserIface *pdata
285 #define priv_gda_sql_parserARG_FETCH GdaSqlParserIface *pdata = yypParser->pdata
286 #define priv_gda_sql_parserARG_STORE yypParser->pdata = pdata
287 #define YYNSTATE 367
288 #define YYNRULE 200
289 #define YYFALLBACK 1
290 #define YY_NO_ACTION (YYNSTATE+YYNRULE+2)
291 #define YY_ACCEPT_ACTION (YYNSTATE+YYNRULE+1)
292 #define YY_ERROR_ACTION (YYNSTATE+YYNRULE)
293
294 /* The yyzerominor constant is used to initialize instances of
295 ** YYMINORTYPE objects to zero. */
296 static const YYMINORTYPE yyzerominor = { 0 };
297
298 /* Define the yytestcase() macro to be a no-op if is not already defined
299 ** otherwise.
300 **
301 ** Applications can choose to define yytestcase() in the %include section
302 ** to a macro that can assist in verifying code coverage. For production
303 ** code the yytestcase() macro should be turned off. But it is useful
304 ** for testing.
305 */
306 #ifndef yytestcase
307 # define yytestcase(X)
308 #endif
309
310
311 /* Next are the tables used to determine what action to take based on the
312 ** current state and lookahead token. These tables are used to implement
313 ** functions that take a state number and lookahead value and return an
314 ** action integer.
315 **
316 ** Suppose the action integer is N. Then the action is determined as
317 ** follows
318 **
319 ** 0 <= N < YYNSTATE Shift N. That is, push the lookahead
320 ** token onto the stack and goto state N.
321 **
322 ** YYNSTATE <= N < YYNSTATE+YYNRULE Reduce by rule N-YYNSTATE.
323 **
324 ** N == YYNSTATE+YYNRULE A syntax error has occurred.
325 **
326 ** N == YYNSTATE+YYNRULE+1 The parser accepts its input.
327 **
328 ** N == YYNSTATE+YYNRULE+2 No such action. Denotes unused
329 ** slots in the yy_action[] table.
330 **
331 ** The action table is constructed as a single large table named yy_action[].
332 ** Given state S and lookahead X, the action is computed as
333 **
334 ** yy_action[ yy_shift_ofst[S] + X ]
335 **
336 ** If the index value yy_shift_ofst[S]+X is out of range or if the value
337 ** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X or if yy_shift_ofst[S]
338 ** is equal to YY_SHIFT_USE_DFLT, it means that the action is not in the table
339 ** and that yy_default[S] should be used instead.
340 **
341 ** The formula above is for computing the action when the lookahead is
342 ** a terminal symbol. If the lookahead is a non-terminal (as occurs after
343 ** a reduce action) then the yy_reduce_ofst[] array is used in place of
344 ** the yy_shift_ofst[] array and YY_REDUCE_USE_DFLT is used in place of
345 ** YY_SHIFT_USE_DFLT.
346 **
347 ** The following are the tables generated in this section:
348 **
349 ** yy_action[] A single table containing all actions.
350 ** yy_lookahead[] A table containing the lookahead for each entry in
351 ** yy_action. Used to detect hash collisions.
352 ** yy_shift_ofst[] For each state, the offset into yy_action for
353 ** shifting terminals.
354 ** yy_reduce_ofst[] For each state, the offset into yy_action for
355 ** shifting non-terminals after a reduce.
356 ** yy_default[] Default action for each state.
357 */
358 #define YY_ACTTAB_COUNT (1395)
359 static const YYACTIONTYPE yy_action[] = {
360 /* 0 */ 41, 40, 367, 246, 246, 142, 243, 22, 51, 49,
361 /* 10 */ 49, 44, 103, 368, 36, 43, 43, 43, 43, 37,
362 /* 20 */ 37, 37, 37, 37, 138, 47, 47, 160, 77, 52,
363 /* 30 */ 52, 51, 49, 49, 44, 244, 354, 353, 165, 352,
364 /* 40 */ 351, 350, 349, 45, 46, 203, 13, 39, 38, 238,
365 /* 50 */ 339, 77, 42, 42, 36, 43, 43, 43, 43, 37,
366 /* 60 */ 37, 37, 37, 37, 175, 47, 47, 323, 298, 52,
367 /* 70 */ 52, 51, 49, 49, 44, 84, 322, 318, 228, 227,
368 /* 80 */ 200, 199, 198, 229, 194, 182, 282, 195, 41, 40,
369 /* 90 */ 219, 77, 246, 319, 243, 276, 202, 21, 157, 328,
370 /* 100 */ 104, 278, 363, 43, 43, 43, 43, 37, 37, 37,
371 /* 110 */ 37, 37, 340, 47, 47, 137, 50, 52, 52, 51,
372 /* 120 */ 49, 49, 44, 244, 354, 263, 262, 193, 28, 50,
373 /* 130 */ 26, 45, 46, 203, 13, 39, 38, 238, 339, 77,
374 /* 140 */ 42, 42, 36, 43, 43, 43, 43, 37, 37, 37,
375 /* 150 */ 37, 37, 1, 47, 47, 280, 279, 52, 52, 51,
376 /* 160 */ 49, 49, 44, 41, 40, 82, 37, 128, 47, 47,
377 /* 170 */ 286, 285, 52, 52, 51, 49, 49, 44, 221, 77,
378 /* 180 */ 186, 52, 52, 51, 49, 49, 44, 333, 213, 352,
379 /* 190 */ 351, 350, 349, 127, 77, 147, 358, 363, 173, 172,
380 /* 200 */ 171, 366, 365, 77, 366, 365, 45, 46, 203, 13,
381 /* 210 */ 39, 38, 238, 339, 329, 42, 42, 36, 43, 43,
382 /* 220 */ 43, 43, 37, 37, 37, 37, 37, 48, 47, 47,
383 /* 230 */ 343, 50, 52, 52, 51, 49, 49, 44, 41, 40,
384 /* 240 */ 314, 3, 246, 348, 243, 37, 37, 37, 37, 37,
385 /* 250 */ 63, 47, 47, 312, 77, 52, 52, 51, 49, 49,
386 /* 260 */ 44, 232, 357, 336, 173, 172, 171, 235, 303, 246,
387 /* 270 */ 364, 305, 34, 244, 354, 197, 226, 77, 173, 172,
388 /* 280 */ 171, 45, 46, 203, 13, 39, 38, 238, 339, 225,
389 /* 290 */ 42, 42, 36, 43, 43, 43, 43, 37, 37, 37,
390 /* 300 */ 37, 37, 359, 47, 47, 146, 306, 52, 52, 51,
391 /* 310 */ 49, 49, 44, 183, 338, 41, 40, 184, 2, 335,
392 /* 320 */ 242, 6, 243, 75, 204, 173, 172, 171, 104, 77,
393 /* 330 */ 363, 356, 370, 291, 140, 136, 267, 266, 289, 278,
394 /* 340 */ 370, 370, 370, 287, 265, 264, 337, 334, 288, 327,
395 /* 350 */ 234, 244, 354, 299, 358, 122, 59, 76, 45, 46,
396 /* 360 */ 203, 13, 39, 38, 238, 339, 310, 42, 42, 36,
397 /* 370 */ 43, 43, 43, 43, 37, 37, 37, 37, 37, 196,
398 /* 380 */ 47, 47, 66, 181, 52, 52, 51, 49, 49, 44,
399 /* 390 */ 246, 156, 243, 246, 201, 305, 41, 40, 104, 189,
400 /* 400 */ 363, 242, 224, 243, 174, 246, 77, 243, 246, 65,
401 /* 410 */ 205, 178, 57, 95, 11, 215, 218, 139, 20, 347,
402 /* 420 */ 357, 244, 354, 56, 154, 10, 230, 173, 172, 171,
403 /* 430 */ 151, 296, 244, 354, 131, 124, 244, 354, 27, 45,
404 /* 440 */ 46, 203, 13, 39, 38, 238, 339, 50, 42, 42,
405 /* 450 */ 36, 43, 43, 43, 43, 37, 37, 37, 37, 37,
406 /* 460 */ 359, 47, 47, 58, 134, 52, 52, 51, 49, 49,
407 /* 470 */ 44, 18, 403, 180, 295, 72, 185, 41, 40, 55,
408 /* 480 */ 246, 378, 243, 246, 254, 243, 222, 77, 90, 356,
409 /* 490 */ 363, 90, 317, 363, 68, 378, 378, 57, 284, 271,
410 /* 500 */ 153, 50, 53, 208, 261, 278, 149, 277, 246, 147,
411 /* 510 */ 360, 244, 354, 278, 244, 354, 358, 316, 315, 24,
412 /* 520 */ 45, 46, 203, 13, 39, 38, 238, 339, 358, 42,
413 /* 530 */ 42, 36, 43, 43, 43, 43, 37, 37, 37, 37,
414 /* 540 */ 37, 313, 47, 47, 284, 311, 52, 52, 51, 49,
415 /* 550 */ 49, 44, 289, 273, 41, 40, 246, 287, 243, 278,
416 /* 560 */ 192, 341, 288, 246, 104, 239, 377, 270, 77, 173,
417 /* 570 */ 172, 171, 293, 278, 253, 132, 330, 16, 403, 309,
418 /* 580 */ 377, 377, 357, 284, 173, 172, 171, 244, 354, 363,
419 /* 590 */ 220, 50, 62, 196, 357, 292, 57, 45, 46, 203,
420 /* 600 */ 13, 39, 38, 238, 339, 358, 42, 42, 36, 43,
421 /* 610 */ 43, 43, 43, 37, 37, 37, 37, 37, 188, 47,
422 /* 620 */ 47, 281, 359, 52, 52, 51, 49, 49, 44, 41,
423 /* 630 */ 40, 252, 217, 246, 359, 243, 44, 191, 246, 186,
424 /* 640 */ 243, 104, 190, 362, 216, 77, 104, 269, 75, 74,
425 /* 650 */ 284, 356, 246, 77, 307, 246, 363, 152, 155, 71,
426 /* 660 */ 363, 54, 260, 356, 244, 354, 358, 82, 278, 244,
427 /* 670 */ 354, 357, 45, 35, 203, 13, 39, 38, 238, 339,
428 /* 680 */ 358, 42, 42, 36, 43, 43, 43, 43, 37, 37,
429 /* 690 */ 37, 37, 37, 9, 47, 47, 211, 147, 52, 52,
430 /* 700 */ 51, 49, 49, 44, 41, 40, 246, 246, 243, 150,
431 /* 710 */ 246, 359, 243, 246, 108, 243, 361, 246, 126, 207,
432 /* 720 */ 77, 143, 179, 8, 7, 130, 326, 251, 246, 125,
433 /* 730 */ 206, 70, 357, 363, 173, 172, 171, 244, 354, 363,
434 /* 740 */ 356, 244, 354, 60, 244, 354, 357, 45, 33, 203,
435 /* 750 */ 13, 39, 38, 238, 339, 324, 42, 42, 36, 43,
436 /* 760 */ 43, 43, 43, 37, 37, 37, 37, 37, 342, 47,
437 /* 770 */ 47, 15, 359, 52, 52, 51, 49, 49, 44, 41,
438 /* 780 */ 40, 246, 187, 243, 79, 246, 359, 243, 246, 107,
439 /* 790 */ 243, 14, 297, 144, 141, 77, 89, 342, 321, 363,
440 /* 800 */ 177, 356, 173, 172, 171, 176, 83, 294, 81, 80,
441 /* 810 */ 164, 342, 244, 354, 53, 356, 244, 354, 77, 244,
442 /* 820 */ 354, 145, 25, 46, 203, 13, 39, 38, 238, 339,
443 /* 830 */ 358, 42, 42, 36, 43, 43, 43, 43, 37, 37,
444 /* 840 */ 37, 37, 37, 342, 47, 47, 163, 231, 52, 52,
445 /* 850 */ 51, 49, 49, 44, 41, 40, 246, 162, 243, 246,
446 /* 860 */ 19, 243, 233, 246, 123, 243, 161, 112, 23, 159,
447 /* 870 */ 77, 109, 358, 17, 358, 325, 223, 568, 148, 308,
448 /* 880 */ 129, 240, 283, 220, 275, 272, 214, 244, 354, 73,
449 /* 890 */ 244, 354, 178, 268, 244, 354, 357, 363, 67, 203,
450 /* 900 */ 13, 39, 38, 238, 339, 209, 42, 42, 36, 43,
451 /* 910 */ 43, 43, 43, 37, 37, 37, 37, 37, 78, 47,
452 /* 920 */ 47, 61, 358, 52, 52, 51, 49, 49, 44, 212,
453 /* 930 */ 246, 240, 302, 210, 250, 69, 359, 248, 357, 336,
454 /* 940 */ 357, 85, 30, 158, 358, 77, 358, 358, 237, 304,
455 /* 950 */ 246, 170, 243, 240, 246, 249, 243, 245, 169, 289,
456 /* 960 */ 300, 301, 120, 355, 287, 356, 31, 32, 346, 288,
457 /* 970 */ 345, 135, 290, 133, 274, 29, 4, 247, 359, 320,
458 /* 980 */ 359, 244, 354, 258, 257, 244, 354, 256, 357, 336,
459 /* 990 */ 241, 259, 30, 255, 358, 335, 569, 220, 331, 569,
460 /* 1000 */ 196, 569, 569, 240, 569, 569, 147, 356, 569, 356,
461 /* 1010 */ 357, 336, 357, 357, 30, 569, 31, 32, 12, 569,
462 /* 1020 */ 569, 569, 337, 334, 236, 29, 5, 332, 359, 569,
463 /* 1030 */ 569, 569, 569, 569, 569, 569, 569, 569, 31, 32,
464 /* 1040 */ 346, 569, 344, 569, 569, 335, 569, 29, 5, 569,
465 /* 1050 */ 359, 569, 359, 359, 246, 569, 243, 356, 569, 569,
466 /* 1060 */ 357, 336, 118, 569, 30, 569, 358, 335, 12, 569,
467 /* 1070 */ 569, 569, 337, 334, 236, 240, 246, 332, 243, 356,
468 /* 1080 */ 569, 356, 356, 569, 117, 244, 354, 569, 31, 32,
469 /* 1090 */ 12, 569, 569, 569, 337, 334, 236, 29, 4, 332,
470 /* 1100 */ 359, 569, 569, 569, 569, 569, 569, 244, 354, 569,
471 /* 1110 */ 569, 246, 569, 243, 569, 569, 569, 335, 569, 116,
472 /* 1120 */ 569, 569, 569, 246, 569, 243, 569, 569, 147, 356,
473 /* 1130 */ 569, 115, 357, 336, 569, 569, 30, 569, 569, 569,
474 /* 1140 */ 12, 569, 244, 354, 337, 334, 236, 569, 246, 332,
475 /* 1150 */ 243, 246, 569, 243, 244, 354, 114, 569, 569, 121,
476 /* 1160 */ 31, 32, 569, 569, 569, 569, 569, 569, 569, 29,
477 /* 1170 */ 5, 569, 359, 246, 569, 243, 246, 569, 243, 244,
478 /* 1180 */ 354, 106, 244, 354, 119, 569, 569, 569, 569, 335,
479 /* 1190 */ 569, 246, 569, 243, 569, 246, 569, 243, 246, 105,
480 /* 1200 */ 243, 356, 569, 111, 244, 354, 168, 244, 354, 569,
481 /* 1210 */ 569, 246, 12, 243, 569, 569, 337, 334, 236, 167,
482 /* 1220 */ 569, 332, 244, 354, 569, 569, 244, 354, 569, 244,
483 /* 1230 */ 354, 569, 569, 246, 569, 243, 569, 569, 569, 569,
484 /* 1240 */ 569, 110, 244, 354, 569, 246, 569, 243, 246, 569,
485 /* 1250 */ 243, 569, 246, 166, 243, 246, 88, 243, 569, 246,
486 /* 1260 */ 102, 243, 569, 101, 244, 354, 569, 87, 569, 569,
487 /* 1270 */ 246, 569, 243, 246, 569, 243, 244, 354, 100, 244,
488 /* 1280 */ 354, 86, 569, 244, 354, 569, 244, 354, 569, 569,
489 /* 1290 */ 244, 354, 246, 569, 243, 569, 569, 569, 569, 569,
490 /* 1300 */ 99, 244, 354, 569, 244, 354, 246, 569, 243, 246,
491 /* 1310 */ 569, 243, 569, 246, 98, 243, 569, 64, 246, 569,
492 /* 1320 */ 243, 97, 569, 244, 354, 569, 96, 246, 569, 243,
493 /* 1330 */ 569, 569, 569, 569, 246, 94, 243, 244, 354, 569,
494 /* 1340 */ 244, 354, 93, 569, 244, 354, 246, 569, 243, 244,
495 /* 1350 */ 354, 569, 569, 246, 92, 243, 569, 569, 244, 354,
496 /* 1360 */ 569, 91, 246, 569, 243, 244, 354, 569, 569, 569,
497 /* 1370 */ 113, 569, 569, 569, 569, 569, 569, 244, 354, 569,
498 /* 1380 */ 569, 569, 569, 569, 244, 354, 569, 569, 569, 569,
499 /* 1390 */ 569, 569, 569, 244, 354,
500 };
501 static const YYCODETYPE yy_lookahead[] = {
502 /* 0 */ 26, 27, 0, 172, 172, 174, 174, 33, 97, 98,
503 /* 10 */ 99, 100, 180, 0, 80, 81, 82, 83, 84, 85,
504 /* 20 */ 86, 87, 88, 89, 144, 91, 92, 196, 117, 95,
505 /* 30 */ 96, 97, 98, 99, 100, 203, 204, 155, 206, 157,
506 /* 40 */ 158, 159, 160, 69, 70, 71, 72, 73, 74, 75,
507 /* 50 */ 76, 117, 78, 79, 80, 81, 82, 83, 84, 85,
508 /* 60 */ 86, 87, 88, 89, 154, 91, 92, 5, 123, 95,
509 /* 70 */ 96, 97, 98, 99, 100, 130, 14, 107, 108, 109,
510 /* 80 */ 110, 111, 112, 113, 23, 165, 53, 54, 26, 27,
511 /* 90 */ 57, 117, 172, 123, 174, 166, 176, 123, 169, 106,
512 /* 100 */ 180, 172, 182, 81, 82, 83, 84, 85, 86, 87,
513 /* 110 */ 88, 89, 106, 91, 92, 144, 123, 95, 96, 97,
514 /* 120 */ 98, 99, 100, 203, 204, 64, 65, 66, 148, 123,
515 /* 130 */ 150, 69, 70, 71, 72, 73, 74, 75, 76, 117,
516 /* 140 */ 78, 79, 80, 81, 82, 83, 84, 85, 86, 87,
517 /* 150 */ 88, 89, 105, 91, 92, 55, 56, 95, 96, 97,
518 /* 160 */ 98, 99, 100, 26, 27, 105, 89, 144, 91, 92,
519 /* 170 */ 58, 59, 95, 96, 97, 98, 99, 100, 163, 117,
520 /* 180 */ 165, 95, 96, 97, 98, 99, 100, 155, 128, 157,
521 /* 190 */ 158, 159, 160, 144, 117, 135, 1, 182, 114, 115,
522 /* 200 */ 116, 120, 121, 117, 120, 121, 69, 70, 71, 72,
523 /* 210 */ 73, 74, 75, 76, 106, 78, 79, 80, 81, 82,
524 /* 220 */ 83, 84, 85, 86, 87, 88, 89, 105, 91, 92,
525 /* 230 */ 106, 123, 95, 96, 97, 98, 99, 100, 26, 27,
526 /* 240 */ 107, 105, 172, 106, 174, 85, 86, 87, 88, 89,
527 /* 250 */ 180, 91, 92, 107, 117, 95, 96, 97, 98, 99,
528 /* 260 */ 100, 191, 67, 68, 114, 115, 116, 75, 1, 172,
529 /* 270 */ 106, 174, 80, 203, 204, 178, 143, 117, 114, 115,
530 /* 280 */ 116, 69, 70, 71, 72, 73, 74, 75, 76, 143,
531 /* 290 */ 78, 79, 80, 81, 82, 83, 84, 85, 86, 87,
532 /* 300 */ 88, 89, 107, 91, 92, 185, 106, 95, 96, 97,
533 /* 310 */ 98, 99, 100, 165, 17, 26, 27, 106, 105, 124,
534 /* 320 */ 172, 201, 174, 123, 176, 114, 115, 116, 180, 117,
535 /* 330 */ 182, 136, 106, 166, 167, 168, 64, 65, 13, 172,
536 /* 340 */ 114, 115, 116, 18, 64, 65, 151, 152, 23, 106,
537 /* 350 */ 202, 203, 204, 1, 1, 194, 195, 145, 69, 70,
538 /* 360 */ 71, 72, 73, 74, 75, 76, 107, 78, 79, 80,
539 /* 370 */ 81, 82, 83, 84, 85, 86, 87, 88, 89, 54,
540 /* 380 */ 91, 92, 8, 165, 95, 96, 97, 98, 99, 100,
541 /* 390 */ 172, 17, 174, 172, 176, 174, 26, 27, 180, 178,
542 /* 400 */ 182, 172, 143, 174, 154, 172, 117, 174, 172, 180,
543 /* 410 */ 174, 58, 145, 180, 138, 62, 63, 181, 123, 106,
544 /* 420 */ 67, 203, 204, 49, 50, 138, 193, 114, 115, 116,
545 /* 430 */ 106, 202, 203, 204, 60, 61, 203, 204, 149, 69,
546 /* 440 */ 70, 71, 72, 73, 74, 75, 76, 123, 78, 79,
547 /* 450 */ 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
548 /* 460 */ 107, 91, 92, 167, 168, 95, 96, 97, 98, 99,
549 /* 470 */ 100, 123, 51, 165, 134, 122, 165, 26, 27, 105,
550 /* 480 */ 172, 106, 174, 172, 106, 174, 146, 117, 180, 136,
551 /* 490 */ 182, 180, 107, 182, 123, 120, 121, 145, 123, 166,
552 /* 500 */ 126, 123, 131, 129, 171, 172, 132, 166, 172, 135,
553 /* 510 */ 174, 203, 204, 172, 203, 204, 1, 107, 107, 149,
554 /* 520 */ 69, 70, 71, 72, 73, 74, 75, 76, 1, 78,
555 /* 530 */ 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
556 /* 540 */ 89, 107, 91, 92, 123, 107, 95, 96, 97, 98,
557 /* 550 */ 99, 100, 13, 166, 26, 27, 172, 18, 174, 172,
558 /* 560 */ 176, 106, 23, 172, 180, 174, 106, 166, 117, 114,
559 /* 570 */ 115, 116, 165, 172, 106, 60, 106, 142, 51, 107,
560 /* 580 */ 120, 121, 67, 123, 114, 115, 116, 203, 204, 182,
561 /* 590 */ 51, 123, 105, 54, 67, 106, 145, 69, 70, 71,
562 /* 600 */ 72, 73, 74, 75, 76, 1, 78, 79, 80, 81,
563 /* 610 */ 82, 83, 84, 85, 86, 87, 88, 89, 52, 91,
564 /* 620 */ 92, 54, 107, 95, 96, 97, 98, 99, 100, 26,
565 /* 630 */ 27, 106, 68, 172, 107, 174, 100, 176, 172, 165,
566 /* 640 */ 174, 180, 176, 165, 123, 117, 180, 124, 123, 122,
567 /* 650 */ 123, 136, 172, 117, 174, 172, 182, 174, 68, 127,
568 /* 660 */ 182, 122, 166, 136, 203, 204, 1, 105, 172, 203,
569 /* 670 */ 204, 67, 69, 70, 71, 72, 73, 74, 75, 76,
570 /* 680 */ 1, 78, 79, 80, 81, 82, 83, 84, 85, 86,
571 /* 690 */ 87, 88, 89, 105, 91, 92, 123, 135, 95, 96,
572 /* 700 */ 97, 98, 99, 100, 26, 27, 172, 172, 174, 174,
573 /* 710 */ 172, 107, 174, 172, 180, 174, 165, 172, 180, 174,
574 /* 720 */ 117, 180, 165, 105, 105, 60, 106, 1, 172, 125,
575 /* 730 */ 174, 130, 67, 182, 114, 115, 116, 203, 204, 182,
576 /* 740 */ 136, 203, 204, 133, 203, 204, 67, 69, 70, 71,
577 /* 750 */ 72, 73, 74, 75, 76, 192, 78, 79, 80, 81,
578 /* 760 */ 82, 83, 84, 85, 86, 87, 88, 89, 205, 91,
579 /* 770 */ 92, 79, 107, 95, 96, 97, 98, 99, 100, 26,
580 /* 780 */ 27, 172, 165, 174, 105, 172, 107, 174, 172, 180,
581 /* 790 */ 174, 79, 200, 180, 106, 117, 180, 205, 192, 182,
582 /* 800 */ 209, 136, 114, 115, 116, 209, 183, 134, 183, 183,
583 /* 810 */ 179, 205, 203, 204, 131, 136, 203, 204, 117, 203,
584 /* 820 */ 204, 207, 148, 70, 71, 72, 73, 74, 75, 76,
585 /* 830 */ 1, 78, 79, 80, 81, 82, 83, 84, 85, 86,
586 /* 840 */ 87, 88, 89, 205, 91, 92, 187, 140, 95, 96,
587 /* 850 */ 97, 98, 99, 100, 26, 27, 172, 188, 174, 172,
588 /* 860 */ 139, 174, 137, 172, 180, 174, 189, 180, 136, 197,
589 /* 870 */ 117, 180, 1, 142, 1, 190, 141, 162, 163, 198,
590 /* 880 */ 165, 10, 168, 51, 168, 122, 173, 203, 204, 170,
591 /* 890 */ 203, 204, 58, 171, 203, 204, 67, 182, 170, 71,
592 /* 900 */ 72, 73, 74, 75, 76, 69, 78, 79, 80, 81,
593 /* 910 */ 82, 83, 84, 85, 86, 87, 88, 89, 175, 91,
594 /* 920 */ 92, 105, 1, 95, 96, 97, 98, 99, 100, 177,
595 /* 930 */ 172, 10, 174, 123, 179, 173, 107, 164, 67, 68,
596 /* 940 */ 67, 184, 71, 169, 1, 117, 1, 1, 208, 200,
597 /* 950 */ 172, 186, 174, 10, 172, 179, 174, 172, 180, 13,
598 /* 960 */ 200, 203, 180, 172, 18, 136, 95, 96, 97, 23,
599 /* 970 */ 97, 169, 167, 169, 167, 104, 105, 164, 107, 199,
600 /* 980 */ 107, 203, 204, 172, 172, 203, 204, 172, 67, 68,
601 /* 990 */ 172, 172, 71, 172, 1, 124, 210, 51, 77, 210,
602 /* 1000 */ 54, 210, 210, 10, 210, 210, 135, 136, 210, 136,
603 /* 1010 */ 67, 68, 67, 67, 71, 210, 95, 96, 147, 210,
604 /* 1020 */ 210, 210, 151, 152, 153, 104, 105, 156, 107, 210,
605 /* 1030 */ 210, 210, 210, 210, 210, 210, 210, 210, 95, 96,
606 /* 1040 */ 97, 210, 97, 210, 210, 124, 210, 104, 105, 210,
607 /* 1050 */ 107, 210, 107, 107, 172, 210, 174, 136, 210, 210,
608 /* 1060 */ 67, 68, 180, 210, 71, 210, 1, 124, 147, 210,
609 /* 1070 */ 210, 210, 151, 152, 153, 10, 172, 156, 174, 136,
610 /* 1080 */ 210, 136, 136, 210, 180, 203, 204, 210, 95, 96,
611 /* 1090 */ 147, 210, 210, 210, 151, 152, 153, 104, 105, 156,
612 /* 1100 */ 107, 210, 210, 210, 210, 210, 210, 203, 204, 210,
613 /* 1110 */ 210, 172, 210, 174, 210, 210, 210, 124, 210, 180,
614 /* 1120 */ 210, 210, 210, 172, 210, 174, 210, 210, 135, 136,
615 /* 1130 */ 210, 180, 67, 68, 210, 210, 71, 210, 210, 210,
616 /* 1140 */ 147, 210, 203, 204, 151, 152, 153, 210, 172, 156,
617 /* 1150 */ 174, 172, 210, 174, 203, 204, 180, 210, 210, 180,
618 /* 1160 */ 95, 96, 210, 210, 210, 210, 210, 210, 210, 104,
619 /* 1170 */ 105, 210, 107, 172, 210, 174, 172, 210, 174, 203,
620 /* 1180 */ 204, 180, 203, 204, 180, 210, 210, 210, 210, 124,
621 /* 1190 */ 210, 172, 210, 174, 210, 172, 210, 174, 172, 180,
622 /* 1200 */ 174, 136, 210, 180, 203, 204, 180, 203, 204, 210,
623 /* 1210 */ 210, 172, 147, 174, 210, 210, 151, 152, 153, 180,
624 /* 1220 */ 210, 156, 203, 204, 210, 210, 203, 204, 210, 203,
625 /* 1230 */ 204, 210, 210, 172, 210, 174, 210, 210, 210, 210,
626 /* 1240 */ 210, 180, 203, 204, 210, 172, 210, 174, 172, 210,
627 /* 1250 */ 174, 210, 172, 180, 174, 172, 180, 174, 210, 172,
628 /* 1260 */ 180, 174, 210, 180, 203, 204, 210, 180, 210, 210,
629 /* 1270 */ 172, 210, 174, 172, 210, 174, 203, 204, 180, 203,
630 /* 1280 */ 204, 180, 210, 203, 204, 210, 203, 204, 210, 210,
631 /* 1290 */ 203, 204, 172, 210, 174, 210, 210, 210, 210, 210,
632 /* 1300 */ 180, 203, 204, 210, 203, 204, 172, 210, 174, 172,
633 /* 1310 */ 210, 174, 210, 172, 180, 174, 210, 180, 172, 210,
634 /* 1320 */ 174, 180, 210, 203, 204, 210, 180, 172, 210, 174,
635 /* 1330 */ 210, 210, 210, 210, 172, 180, 174, 203, 204, 210,
636 /* 1340 */ 203, 204, 180, 210, 203, 204, 172, 210, 174, 203,
637 /* 1350 */ 204, 210, 210, 172, 180, 174, 210, 210, 203, 204,
638 /* 1360 */ 210, 180, 172, 210, 174, 203, 204, 210, 210, 210,
639 /* 1370 */ 180, 210, 210, 210, 210, 210, 210, 203, 204, 210,
640 /* 1380 */ 210, 210, 210, 210, 203, 204, 210, 210, 210, 210,
641 /* 1390 */ 210, 210, 210, 203, 204,
642 };
643 #define YY_SHIFT_USE_DFLT (-121)
644 #define YY_SHIFT_COUNT (248)
645 #define YY_SHIFT_MIN (-120)
646 #define YY_SHIFT_MAX (1065)
647 static const short yy_shift_ofst[] = {
648 /* 0 */ 374, 871, 993, 993, 993, 993, 943, 1065, 1065, 1065,
649 /* 10 */ 1065, 1065, 1065, 921, 1065, 1065, 1065, 1065, 1065, 1065,
650 /* 20 */ 1065, 1065, 1065, 1065, 1065, 1065, 1065, 1065, 1065, 1065,
651 /* 30 */ 1065, 1065, 1065, 1065, 1065, 1065, 1065, 1065, 1065, 1065,
652 /* 40 */ 1065, 1065, 1065, 1065, 1065, 1065, 1065, 1065, 1065, 1065,
653 /* 50 */ 1065, 1065, 1065, 1065, 946, 374, 353, 195, 527, 679,
654 /* 60 */ 829, 829, 829, 62, 62, 451, 539, 604, 829, 829,
655 /* 70 */ 829, 829, 829, 829, 829, 829, 829, 829, 60, 562,
656 /* 80 */ 562, 562, 562, 562, -121, -121, -26, 370, 289, 212,
657 /* 90 */ 137, 528, 528, 528, 528, 528, 528, 528, 528, 528,
658 /* 100 */ 528, 528, 528, 528, 528, 678, 603, 528, 528, 753,
659 /* 110 */ 828, 828, 828, -66, -66, -66, -66, -66, -66, 22,
660 /* 120 */ 160, 77, -30, 86, 665, 515, -89, 945, 873, 84,
661 /* 130 */ 829, 829, 829, 325, 460, 325, 375, 829, 829, 371,
662 /* 140 */ 421, 352, 267, 536, 536, -20, -55, 340, 81, 836,
663 /* 150 */ 683, 810, 816, 836, 763, 834, 763, 832, 832, 735,
664 /* 160 */ 731, 732, 725, 721, 707, 674, 701, 701, 701, 701,
665 /* 170 */ 683, 673, 673, 673, -121, -121, 32, -118, 61, 688,
666 /* 180 */ 620, 470, 455, 313, 226, 211, 164, 150, 33, 525,
667 /* 190 */ 468, 378, 324, 280, 272, 100, 112, 200, 259, 146,
668 /* 200 */ 133, 108, 6, 192, -7, 712, 692, 610, 601, 726,
669 /* 210 */ 619, 618, 573, 588, 532, 590, 523, 521, 564, 567,
670 /* 220 */ 566, 489, 435, 487, 472, 438, 434, 411, 410, 385,
671 /* 230 */ 348, 287, 295, 276, 243, 213, 250, 297, 136, 124,
672 /* 240 */ 122, 49, 23, 47, -90, -29, -120, 13, 2,
673 };
674 #define YY_REDUCE_USE_DFLT (-170)
675 #define YY_REDUCE_COUNT (175)
676 #define YY_REDUCE_MIN (-169)
677 #define YY_REDUCE_MAX (1190)
678 static const short yy_reduce_ofst[] = {
679 /* 0 */ 715, 148, 218, -80, 311, 308, 229, 466, 461, 384,
680 /* 10 */ 233, 70, -168, 1190, 1181, 1174, 1162, 1155, 1146, 1141,
681 /* 20 */ 1137, 1134, 1120, 1101, 1098, 1087, 1083, 1080, 1076, 1073,
682 /* 30 */ 1061, 1039, 1026, 1023, 1019, 1004, 1001, 979, 976, 951,
683 /* 40 */ 939, 904, 882, 782, 778, 691, 687, 684, 616, 613,
684 /* 50 */ 609, 541, 538, 534, 167, 15, 333, 758, -71, -169,
685 /* 60 */ 236, 221, 97, 606, 563, 592, 296, 496, 556, 545,
686 /* 70 */ 535, 483, 401, 387, 341, 480, 391, 336, 617, 557,
687 /* 80 */ 551, 478, 474, 407, 161, 120, 638, 638, 638, 638,
688 /* 90 */ 638, 638, 638, 638, 638, 638, 638, 638, 638, 638,
689 /* 100 */ 638, 638, 638, 638, 638, 638, 638, 638, 638, 638,
690 /* 110 */ 638, 638, 638, 638, 638, 638, 638, 638, 638, 638,
691 /* 120 */ 638, 638, 780, 638, 821, 819, 638, 791, 818, 813,
692 /* 130 */ 815, 812, 811, 807, 804, 805, 802, 791, 785, 776,
693 /* 140 */ 774, 760, 749, 638, 638, 740, 765, 757, 773, 762,
694 /* 150 */ 755, 752, 743, 713, 728, 722, 719, 716, 714, 681,
695 /* 160 */ 672, 685, 677, 669, 659, 614, 638, 638, 638, 638,
696 /* 170 */ 631, 626, 625, 623, 596, 591,
697 };
698 static const YYACTIONTYPE yy_default[] = {
699 /* 0 */ 567, 500, 500, 500, 567, 567, 567, 500, 500, 500,
700 /* 10 */ 567, 567, 541, 567, 567, 567, 567, 567, 567, 567,
701 /* 20 */ 567, 567, 567, 567, 567, 567, 567, 567, 567, 567,
702 /* 30 */ 567, 567, 567, 567, 567, 567, 567, 567, 567, 567,
703 /* 40 */ 567, 567, 567, 567, 567, 567, 567, 567, 567, 567,
704 /* 50 */ 567, 567, 567, 567, 409, 567, 409, 567, 409, 567,
705 /* 60 */ 567, 567, 567, 455, 455, 493, 373, 409, 567, 567,
706 /* 70 */ 567, 567, 409, 409, 409, 567, 567, 567, 567, 567,
707 /* 80 */ 567, 567, 567, 567, 465, 485, 446, 567, 567, 567,
708 /* 90 */ 567, 437, 436, 497, 467, 499, 498, 457, 448, 447,
709 /* 100 */ 543, 544, 542, 540, 502, 567, 567, 501, 434, 519,
710 /* 110 */ 530, 529, 518, 533, 526, 525, 524, 523, 522, 528,
711 /* 120 */ 521, 527, 461, 515, 567, 567, 512, 567, 567, 567,
712 /* 130 */ 567, 567, 567, 567, 403, 567, 403, 567, 567, 433,
713 /* 140 */ 379, 493, 493, 513, 514, 545, 460, 494, 567, 424,
714 /* 150 */ 433, 421, 428, 424, 401, 389, 401, 567, 567, 464,
715 /* 160 */ 468, 445, 449, 456, 458, 567, 531, 517, 516, 520,
716 /* 170 */ 433, 442, 442, 442, 555, 555, 567, 567, 567, 567,
717 /* 180 */ 567, 567, 567, 567, 534, 567, 567, 423, 567, 567,
718 /* 190 */ 567, 567, 567, 394, 393, 567, 567, 567, 567, 567,
719 /* 200 */ 567, 567, 567, 567, 567, 567, 567, 567, 567, 567,
720 /* 210 */ 567, 567, 422, 567, 567, 567, 567, 387, 567, 567,
721 /* 220 */ 567, 567, 496, 567, 567, 567, 567, 567, 567, 567,
722 /* 230 */ 459, 567, 450, 567, 567, 567, 567, 567, 567, 567,
723 /* 240 */ 567, 565, 564, 506, 504, 565, 564, 567, 567, 435,
724 /* 250 */ 432, 425, 429, 427, 426, 418, 417, 416, 420, 419,
725 /* 260 */ 392, 391, 396, 395, 400, 399, 398, 397, 390, 388,
726 /* 270 */ 386, 385, 402, 384, 383, 382, 376, 375, 410, 408,
727 /* 280 */ 407, 406, 405, 380, 404, 415, 414, 413, 412, 411,
728 /* 290 */ 381, 374, 369, 439, 443, 495, 487, 486, 484, 483,
729 /* 300 */ 482, 492, 491, 481, 480, 431, 463, 430, 462, 479,
730 /* 310 */ 478, 477, 476, 475, 474, 473, 472, 471, 470, 469,
731 /* 320 */ 466, 452, 454, 453, 451, 444, 534, 509, 507, 537,
732 /* 330 */ 538, 547, 554, 552, 551, 550, 549, 548, 539, 546,
733 /* 340 */ 535, 536, 532, 510, 490, 489, 488, 508, 505, 559,
734 /* 350 */ 558, 557, 556, 553, 503, 566, 563, 562, 561, 560,
735 /* 360 */ 511, 441, 440, 438, 370, 372, 371,
736 };
737
738 /* The next table maps tokens into fallback tokens. If a construct
739 ** like the following:
740 **
741 ** %fallback ID X Y Z.
742 **
743 ** appears in the grammar, then ID becomes a fallback token for X, Y,
744 ** and Z. Whenever one of the tokens X, Y, or Z is input to the parser
745 ** but it does not parse, the type of the token is changed to ID and
746 ** the parse is retried before an error is thrown.
747 */
748 #ifdef YYFALLBACK
749 static const YYCODETYPE yyFallback[] = {
750 0, /* $ => nothing */
751 0, /* ID => nothing */
752 1, /* ABORT => ID */
753 1, /* AFTER => ID */
754 1, /* ANALYZE => ID */
755 1, /* ASC => ID */
756 1, /* ATTACH => ID */
757 1, /* BEFORE => ID */
758 1, /* BEGIN => ID */
759 1, /* CASCADE => ID */
760 1, /* CAST => ID */
761 1, /* CONFLICT => ID */
762 1, /* DATABASE => ID */
763 1, /* DEFERRED => ID */
764 1, /* DESC => ID */
765 1, /* DETACH => ID */
766 1, /* EACH => ID */
767 1, /* END => ID */
768 1, /* EXCLUSIVE => ID */
769 1, /* EXPLAIN => ID */
770 1, /* FAIL => ID */
771 1, /* FOR => ID */
772 1, /* IGNORE => ID */
773 1, /* IMMEDIATE => ID */
774 1, /* INITIALLY => ID */
775 1, /* INSTEAD => ID */
776 1, /* LIKE => ID */
777 1, /* ILIKE => ID */
778 1, /* MATCH => ID */
779 1, /* PLAN => ID */
780 1, /* QUERY => ID */
781 1, /* KEY => ID */
782 1, /* OF => ID */
783 1, /* OFFSET => ID */
784 1, /* PRAGMA => ID */
785 1, /* RAISE => ID */
786 1, /* REPLACE => ID */
787 1, /* RESTRICT => ID */
788 1, /* ROW => ID */
789 1, /* TEMP => ID */
790 1, /* TRIGGER => ID */
791 1, /* VACUUM => ID */
792 1, /* VIEW => ID */
793 1, /* VIRTUAL => ID */
794 1, /* REINDEX => ID */
795 1, /* RENAME => ID */
796 1, /* CTIME_KW => ID */
797 1, /* IF => ID */
798 1, /* DELIMITER => ID */
799 1, /* COMMIT => ID */
800 1, /* ROLLBACK => ID */
801 1, /* ISOLATION => ID */
802 1, /* LEVEL => ID */
803 1, /* SERIALIZABLE => ID */
804 1, /* READ => ID */
805 1, /* COMMITTED => ID */
806 1, /* UNCOMMITTED => ID */
807 1, /* REPEATABLE => ID */
808 1, /* WRITE => ID */
809 1, /* ONLY => ID */
810 1, /* SAVEPOINT => ID */
811 1, /* RELEASE => ID */
812 1, /* COMMENT => ID */
813 1, /* FORCE => ID */
814 1, /* WAIT => ID */
815 1, /* NOWAIT => ID */
816 1, /* BATCH => ID */
817 0, /* TEXTUAL => nothing */
818 67, /* STRING => TEXTUAL */
819 };
820 #endif /* YYFALLBACK */
821
822 /* The following structure represents a single element of the
823 ** parser's stack. Information stored includes:
824 **
825 ** + The state number for the parser at this level of the stack.
826 **
827 ** + The value of the token stored at this level of the stack.
828 ** (In other words, the "major" token.)
829 **
830 ** + The semantic value stored at this level of the stack. This is
831 ** the information used by the action routines in the grammar.
832 ** It is sometimes called the "minor" token.
833 */
834 struct yyStackEntry {
835 YYACTIONTYPE stateno; /* The state-number */
836 YYCODETYPE major; /* The major token value. This is the code
837 ** number for the token at this stack level */
838 YYMINORTYPE minor; /* The user-supplied minor token value. This
839 ** is the value of the token */
840 };
841 typedef struct yyStackEntry yyStackEntry;
842
843 /* The state of the parser is completely contained in an instance of
844 ** the following structure */
845 struct yyParser {
846 int yyidx; /* Index of top element in stack */
847 #ifdef YYTRACKMAXSTACKDEPTH
848 int yyidxMax; /* Maximum value of yyidx */
849 #endif
850 int yyerrcnt; /* Shifts left before out of the error */
851 priv_gda_sql_parserARG_SDECL /* A place to hold %extra_argument */
852 #if YYSTACKDEPTH<=0
853 int yystksz; /* Current side of the stack */
854 yyStackEntry *yystack; /* The parser's stack */
855 #else
856 yyStackEntry yystack[YYSTACKDEPTH]; /* The parser's stack */
857 #endif
858 };
859 typedef struct yyParser yyParser;
860
861 #ifndef NDEBUG
862 #include <stdio.h>
863 static FILE *yyTraceFILE = 0;
864 static char *yyTracePrompt = 0;
865 #endif /* NDEBUG */
866
867 #ifndef NDEBUG
868 /*
869 ** Turn parser tracing on by giving a stream to which to write the trace
870 ** and a prompt to preface each trace message. Tracing is turned off
871 ** by making either argument NULL
872 **
873 ** Inputs:
874 ** <ul>
875 ** <li> A FILE* to which trace output should be written.
876 ** If NULL, then tracing is turned off.
877 ** <li> A prefix string written at the beginning of every
878 ** line of trace output. If NULL, then tracing is
879 ** turned off.
880 ** </ul>
881 **
882 ** Outputs:
883 ** None.
884 */
priv_gda_sql_parserTrace(FILE * TraceFILE,char * zTracePrompt)885 void priv_gda_sql_parserTrace(FILE *TraceFILE, char *zTracePrompt){
886 yyTraceFILE = TraceFILE;
887 yyTracePrompt = zTracePrompt;
888 if( yyTraceFILE==0 ) yyTracePrompt = 0;
889 else if( yyTracePrompt==0 ) yyTraceFILE = 0;
890 }
891 #endif /* NDEBUG */
892
893 #ifndef NDEBUG
894 /* For tracing shifts, the names of all terminals and nonterminals
895 ** are required. The following table supplies these names */
896 static const char *const yyTokenName[] = {
897 "$", "ID", "ABORT", "AFTER",
898 "ANALYZE", "ASC", "ATTACH", "BEFORE",
899 "BEGIN", "CASCADE", "CAST", "CONFLICT",
900 "DATABASE", "DEFERRED", "DESC", "DETACH",
901 "EACH", "END", "EXCLUSIVE", "EXPLAIN",
902 "FAIL", "FOR", "IGNORE", "IMMEDIATE",
903 "INITIALLY", "INSTEAD", "LIKE", "ILIKE",
904 "MATCH", "PLAN", "QUERY", "KEY",
905 "OF", "OFFSET", "PRAGMA", "RAISE",
906 "REPLACE", "RESTRICT", "ROW", "TEMP",
907 "TRIGGER", "VACUUM", "VIEW", "VIRTUAL",
908 "REINDEX", "RENAME", "CTIME_KW", "IF",
909 "DELIMITER", "COMMIT", "ROLLBACK", "ISOLATION",
910 "LEVEL", "SERIALIZABLE", "READ", "COMMITTED",
911 "UNCOMMITTED", "REPEATABLE", "WRITE", "ONLY",
912 "SAVEPOINT", "RELEASE", "COMMENT", "FORCE",
913 "WAIT", "NOWAIT", "BATCH", "TEXTUAL",
914 "STRING", "OR", "AND", "NOT",
915 "IS", "NOTLIKE", "NOTILIKE", "IN",
916 "ISNULL", "NOTNULL", "DIFF", "EQ",
917 "BETWEEN", "GT", "LEQ", "LT",
918 "GEQ", "REGEXP", "REGEXP_CI", "NOT_REGEXP",
919 "NOT_REGEXP_CI", "SIMILAR", "ESCAPE", "BITAND",
920 "BITOR", "LSHIFT", "RSHIFT", "PLUS",
921 "MINUS", "STAR", "SLASH", "REM",
922 "CONCAT", "COLLATE", "UMINUS", "UPLUS",
923 "BITNOT", "LP", "RP", "JOIN",
924 "INNER", "NATURAL", "LEFT", "RIGHT",
925 "FULL", "CROSS", "UNION", "EXCEPT",
926 "INTERSECT", "PGCAST", "ILLEGAL", "SQLCOMMENT",
927 "SEMI", "END_OF_FILE", "TRANSACTION", "COMMA",
928 "INTEGER", "TO", "INSERT", "INTO",
929 "VALUES", "DELETE", "FROM", "WHERE",
930 "UPDATE", "SET", "ALL", "SELECT",
931 "LIMIT", "ORDER", "BY", "HAVING",
932 "GROUP", "USING", "ON", "OUTER",
933 "DOT", "AS", "DISTINCT", "CASE",
934 "WHEN", "THEN", "ELSE", "NULL",
935 "FLOAT", "UNSPECVAL", "LSBRACKET", "RSBRACKET",
936 "SIMPLEPARAM", "PNAME", "PDESCR", "PTYPE",
937 "PNULLOK", "error", "stmt", "cmd",
938 "eos", "compound", "nm_opt", "transtype",
939 "transilev", "opt_comma", "trans_opt_kw", "ora_commit_write",
940 "nm", "opt_on_conflict", "fullname", "inscollist_opt",
941 "rexprlist", "ins_extra_values", "inscollist", "where_opt",
942 "expr", "setlist", "selectcmd", "opt_compound_all",
943 "distinct", "selcollist", "from", "groupby_opt",
944 "having_opt", "orderby_opt", "limit_opt", "sortlist",
945 "sortorder", "rnexprlist", "seltablist", "stl_prefix",
946 "seltarget", "on_cond", "using_opt", "jointype",
947 "as", "sclp", "starname", "value",
948 "pvalue", "uni_op", "case_operand", "case_exprlist",
949 "case_else", "paramspec",
950 };
951 #endif /* NDEBUG */
952
953 #ifndef NDEBUG
954 /* For tracing reduce actions, the names of all rules are required.
955 */
956 static const char *const yyRuleName[] = {
957 /* 0 */ "stmt ::= cmd eos",
958 /* 1 */ "stmt ::= compound eos",
959 /* 2 */ "cmd ::= LP cmd RP",
960 /* 3 */ "compound ::= LP compound RP",
961 /* 4 */ "eos ::= SEMI",
962 /* 5 */ "eos ::= END_OF_FILE",
963 /* 6 */ "cmd ::= BEGIN",
964 /* 7 */ "cmd ::= BEGIN TRANSACTION nm_opt",
965 /* 8 */ "cmd ::= BEGIN transtype TRANSACTION nm_opt",
966 /* 9 */ "cmd ::= BEGIN transtype nm_opt",
967 /* 10 */ "cmd ::= BEGIN transilev",
968 /* 11 */ "cmd ::= BEGIN TRANSACTION transilev",
969 /* 12 */ "cmd ::= BEGIN TRANSACTION transtype",
970 /* 13 */ "cmd ::= BEGIN TRANSACTION transtype opt_comma transilev",
971 /* 14 */ "cmd ::= BEGIN TRANSACTION transilev opt_comma transtype",
972 /* 15 */ "cmd ::= BEGIN transtype opt_comma transilev",
973 /* 16 */ "cmd ::= BEGIN transilev opt_comma transtype",
974 /* 17 */ "cmd ::= END trans_opt_kw nm_opt",
975 /* 18 */ "cmd ::= COMMIT nm_opt",
976 /* 19 */ "cmd ::= COMMIT TRANSACTION nm_opt",
977 /* 20 */ "cmd ::= COMMIT FORCE STRING",
978 /* 21 */ "cmd ::= COMMIT FORCE STRING COMMA INTEGER",
979 /* 22 */ "cmd ::= COMMIT COMMENT STRING",
980 /* 23 */ "cmd ::= COMMIT COMMENT STRING ora_commit_write",
981 /* 24 */ "cmd ::= COMMIT ora_commit_write",
982 /* 25 */ "cmd ::= ROLLBACK trans_opt_kw nm_opt",
983 /* 26 */ "ora_commit_write ::= WRITE IMMEDIATE",
984 /* 27 */ "ora_commit_write ::= WRITE BATCH",
985 /* 28 */ "ora_commit_write ::= WRITE WAIT",
986 /* 29 */ "ora_commit_write ::= WRITE NOWAIT",
987 /* 30 */ "ora_commit_write ::= WRITE IMMEDIATE WAIT",
988 /* 31 */ "ora_commit_write ::= WRITE IMMEDIATE NOWAIT",
989 /* 32 */ "ora_commit_write ::= WRITE BATCH WAIT",
990 /* 33 */ "ora_commit_write ::= WRITE BATCH NOWAIT",
991 /* 34 */ "trans_opt_kw ::=",
992 /* 35 */ "trans_opt_kw ::= TRANSACTION",
993 /* 36 */ "opt_comma ::=",
994 /* 37 */ "opt_comma ::= COMMA",
995 /* 38 */ "transilev ::= ISOLATION LEVEL SERIALIZABLE",
996 /* 39 */ "transilev ::= ISOLATION LEVEL REPEATABLE READ",
997 /* 40 */ "transilev ::= ISOLATION LEVEL READ COMMITTED",
998 /* 41 */ "transilev ::= ISOLATION LEVEL READ UNCOMMITTED",
999 /* 42 */ "nm_opt ::=",
1000 /* 43 */ "nm_opt ::= nm",
1001 /* 44 */ "transtype ::= DEFERRED",
1002 /* 45 */ "transtype ::= IMMEDIATE",
1003 /* 46 */ "transtype ::= EXCLUSIVE",
1004 /* 47 */ "transtype ::= READ WRITE",
1005 /* 48 */ "transtype ::= READ ONLY",
1006 /* 49 */ "cmd ::= SAVEPOINT nm",
1007 /* 50 */ "cmd ::= RELEASE SAVEPOINT nm",
1008 /* 51 */ "cmd ::= RELEASE nm",
1009 /* 52 */ "cmd ::= ROLLBACK trans_opt_kw TO nm",
1010 /* 53 */ "cmd ::= ROLLBACK trans_opt_kw TO SAVEPOINT nm",
1011 /* 54 */ "cmd ::= INSERT opt_on_conflict INTO fullname inscollist_opt VALUES LP rexprlist RP",
1012 /* 55 */ "cmd ::= INSERT opt_on_conflict INTO fullname inscollist_opt VALUES LP rexprlist RP ins_extra_values",
1013 /* 56 */ "cmd ::= INSERT opt_on_conflict INTO fullname inscollist_opt compound",
1014 /* 57 */ "opt_on_conflict ::=",
1015 /* 58 */ "opt_on_conflict ::= OR ID",
1016 /* 59 */ "ins_extra_values ::= ins_extra_values COMMA LP rexprlist RP",
1017 /* 60 */ "ins_extra_values ::= COMMA LP rexprlist RP",
1018 /* 61 */ "inscollist_opt ::=",
1019 /* 62 */ "inscollist_opt ::= LP inscollist RP",
1020 /* 63 */ "inscollist ::= inscollist COMMA fullname",
1021 /* 64 */ "inscollist ::= fullname",
1022 /* 65 */ "cmd ::= DELETE FROM fullname where_opt",
1023 /* 66 */ "where_opt ::=",
1024 /* 67 */ "where_opt ::= WHERE expr",
1025 /* 68 */ "cmd ::= UPDATE opt_on_conflict fullname SET setlist where_opt",
1026 /* 69 */ "setlist ::= setlist COMMA fullname EQ expr",
1027 /* 70 */ "setlist ::= fullname EQ expr",
1028 /* 71 */ "compound ::= selectcmd",
1029 /* 72 */ "compound ::= compound UNION opt_compound_all compound",
1030 /* 73 */ "compound ::= compound EXCEPT opt_compound_all compound",
1031 /* 74 */ "compound ::= compound INTERSECT opt_compound_all compound",
1032 /* 75 */ "opt_compound_all ::=",
1033 /* 76 */ "opt_compound_all ::= ALL",
1034 /* 77 */ "selectcmd ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt",
1035 /* 78 */ "limit_opt ::=",
1036 /* 79 */ "limit_opt ::= LIMIT expr",
1037 /* 80 */ "limit_opt ::= LIMIT expr OFFSET expr",
1038 /* 81 */ "limit_opt ::= LIMIT expr COMMA expr",
1039 /* 82 */ "orderby_opt ::=",
1040 /* 83 */ "orderby_opt ::= ORDER BY sortlist",
1041 /* 84 */ "sortlist ::= sortlist COMMA expr sortorder",
1042 /* 85 */ "sortlist ::= expr sortorder",
1043 /* 86 */ "sortorder ::= ASC",
1044 /* 87 */ "sortorder ::= DESC",
1045 /* 88 */ "sortorder ::=",
1046 /* 89 */ "having_opt ::=",
1047 /* 90 */ "having_opt ::= HAVING expr",
1048 /* 91 */ "groupby_opt ::=",
1049 /* 92 */ "groupby_opt ::= GROUP BY rnexprlist",
1050 /* 93 */ "from ::=",
1051 /* 94 */ "from ::= FROM seltablist",
1052 /* 95 */ "seltablist ::= stl_prefix seltarget on_cond using_opt",
1053 /* 96 */ "using_opt ::= USING LP inscollist RP",
1054 /* 97 */ "using_opt ::=",
1055 /* 98 */ "stl_prefix ::=",
1056 /* 99 */ "stl_prefix ::= seltablist jointype",
1057 /* 100 */ "on_cond ::= ON expr",
1058 /* 101 */ "on_cond ::=",
1059 /* 102 */ "jointype ::= COMMA",
1060 /* 103 */ "jointype ::= JOIN",
1061 /* 104 */ "jointype ::= CROSS JOIN",
1062 /* 105 */ "jointype ::= INNER JOIN",
1063 /* 106 */ "jointype ::= NATURAL JOIN",
1064 /* 107 */ "jointype ::= LEFT JOIN",
1065 /* 108 */ "jointype ::= LEFT OUTER JOIN",
1066 /* 109 */ "jointype ::= RIGHT JOIN",
1067 /* 110 */ "jointype ::= RIGHT OUTER JOIN",
1068 /* 111 */ "jointype ::= FULL JOIN",
1069 /* 112 */ "jointype ::= FULL OUTER JOIN",
1070 /* 113 */ "seltarget ::= fullname as",
1071 /* 114 */ "seltarget ::= fullname ID",
1072 /* 115 */ "seltarget ::= LP compound RP as",
1073 /* 116 */ "seltarget ::= LP compound RP ID",
1074 /* 117 */ "sclp ::= selcollist COMMA",
1075 /* 118 */ "sclp ::=",
1076 /* 119 */ "selcollist ::= sclp expr as",
1077 /* 120 */ "selcollist ::= sclp starname",
1078 /* 121 */ "starname ::= STAR",
1079 /* 122 */ "starname ::= nm DOT STAR",
1080 /* 123 */ "starname ::= nm DOT nm DOT STAR",
1081 /* 124 */ "as ::= AS fullname",
1082 /* 125 */ "as ::= AS value",
1083 /* 126 */ "as ::=",
1084 /* 127 */ "distinct ::=",
1085 /* 128 */ "distinct ::= ALL",
1086 /* 129 */ "distinct ::= DISTINCT",
1087 /* 130 */ "distinct ::= DISTINCT ON expr",
1088 /* 131 */ "rnexprlist ::= rnexprlist COMMA expr",
1089 /* 132 */ "rnexprlist ::= expr",
1090 /* 133 */ "rexprlist ::=",
1091 /* 134 */ "rexprlist ::= rexprlist COMMA expr",
1092 /* 135 */ "rexprlist ::= expr",
1093 /* 136 */ "expr ::= pvalue",
1094 /* 137 */ "expr ::= value",
1095 /* 138 */ "expr ::= LP expr RP",
1096 /* 139 */ "expr ::= fullname",
1097 /* 140 */ "expr ::= fullname LP rexprlist RP",
1098 /* 141 */ "expr ::= fullname LP compound RP",
1099 /* 142 */ "expr ::= fullname LP starname RP",
1100 /* 143 */ "expr ::= CAST LP expr AS fullname RP",
1101 /* 144 */ "expr ::= expr PGCAST fullname",
1102 /* 145 */ "expr ::= expr PLUS|MINUS expr",
1103 /* 146 */ "expr ::= expr STAR expr",
1104 /* 147 */ "expr ::= expr SLASH|REM expr",
1105 /* 148 */ "expr ::= expr BITAND|BITOR expr",
1106 /* 149 */ "expr ::= MINUS expr",
1107 /* 150 */ "expr ::= PLUS expr",
1108 /* 151 */ "expr ::= expr AND expr",
1109 /* 152 */ "expr ::= expr OR expr",
1110 /* 153 */ "expr ::= expr CONCAT expr",
1111 /* 154 */ "expr ::= expr GT|LEQ|GEQ|LT expr",
1112 /* 155 */ "expr ::= expr DIFF|EQ expr",
1113 /* 156 */ "expr ::= expr LIKE expr",
1114 /* 157 */ "expr ::= expr ILIKE expr",
1115 /* 158 */ "expr ::= expr NOTLIKE expr",
1116 /* 159 */ "expr ::= expr NOTILIKE expr",
1117 /* 160 */ "expr ::= expr REGEXP|REGEXP_CI|NOT_REGEXP|NOT_REGEXP_CI|SIMILAR expr",
1118 /* 161 */ "expr ::= expr BETWEEN expr AND expr",
1119 /* 162 */ "expr ::= expr NOT BETWEEN expr AND expr",
1120 /* 163 */ "expr ::= NOT expr",
1121 /* 164 */ "expr ::= BITNOT expr",
1122 /* 165 */ "expr ::= expr uni_op",
1123 /* 166 */ "expr ::= expr IS expr",
1124 /* 167 */ "expr ::= LP compound RP",
1125 /* 168 */ "expr ::= expr IN LP rexprlist RP",
1126 /* 169 */ "expr ::= expr IN LP compound RP",
1127 /* 170 */ "expr ::= expr NOT IN LP rexprlist RP",
1128 /* 171 */ "expr ::= expr NOT IN LP compound RP",
1129 /* 172 */ "expr ::= CASE case_operand case_exprlist case_else END",
1130 /* 173 */ "case_operand ::= expr",
1131 /* 174 */ "case_operand ::=",
1132 /* 175 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr",
1133 /* 176 */ "case_exprlist ::= WHEN expr THEN expr",
1134 /* 177 */ "case_else ::= ELSE expr",
1135 /* 178 */ "case_else ::=",
1136 /* 179 */ "uni_op ::= ISNULL",
1137 /* 180 */ "uni_op ::= IS NOTNULL",
1138 /* 181 */ "value ::= NULL",
1139 /* 182 */ "value ::= STRING",
1140 /* 183 */ "value ::= INTEGER",
1141 /* 184 */ "value ::= FLOAT",
1142 /* 185 */ "pvalue ::= UNSPECVAL LSBRACKET paramspec RSBRACKET",
1143 /* 186 */ "pvalue ::= value LSBRACKET paramspec RSBRACKET",
1144 /* 187 */ "pvalue ::= SIMPLEPARAM",
1145 /* 188 */ "paramspec ::=",
1146 /* 189 */ "paramspec ::= paramspec PNAME",
1147 /* 190 */ "paramspec ::= paramspec PDESCR",
1148 /* 191 */ "paramspec ::= paramspec PTYPE",
1149 /* 192 */ "paramspec ::= paramspec PNULLOK",
1150 /* 193 */ "nm ::= JOIN",
1151 /* 194 */ "nm ::= ID",
1152 /* 195 */ "nm ::= TEXTUAL",
1153 /* 196 */ "nm ::= LIMIT",
1154 /* 197 */ "fullname ::= nm",
1155 /* 198 */ "fullname ::= nm DOT nm",
1156 /* 199 */ "fullname ::= nm DOT nm DOT nm",
1157 };
1158 #endif /* NDEBUG */
1159
1160
1161 #if YYSTACKDEPTH<=0
1162 /*
1163 ** Try to increase the size of the parser stack.
1164 */
yyGrowStack(yyParser * p)1165 static void yyGrowStack(yyParser *p){
1166 int newSize;
1167 yyStackEntry *pNew;
1168
1169 newSize = p->yystksz*2 + 100;
1170 pNew = realloc(p->yystack, newSize*sizeof(pNew[0]));
1171 if( pNew ){
1172 p->yystack = pNew;
1173 p->yystksz = newSize;
1174 #ifndef NDEBUG
1175 if( yyTraceFILE ){
1176 fprintf(yyTraceFILE,"%sStack grows to %d entries!\n",
1177 yyTracePrompt, p->yystksz);
1178 }
1179 #endif
1180 }
1181 }
1182 #endif
1183
1184 /*
1185 ** This function allocates a new parser.
1186 ** The only argument is a pointer to a function which works like
1187 ** malloc.
1188 **
1189 ** Inputs:
1190 ** A pointer to the function used to allocate memory.
1191 **
1192 ** Outputs:
1193 ** A pointer to a parser. This pointer is used in subsequent calls
1194 ** to priv_gda_sql_parser and priv_gda_sql_parserFree.
1195 */
priv_gda_sql_parserAlloc(void * (* mallocProc)(size_t))1196 void *priv_gda_sql_parserAlloc(void *(*mallocProc)(size_t)){
1197 yyParser *pParser;
1198 pParser = (yyParser*)(*mallocProc)( (size_t)sizeof(yyParser) );
1199 if( pParser ){
1200 pParser->yyidx = -1;
1201 #ifdef YYTRACKMAXSTACKDEPTH
1202 pParser->yyidxMax = 0;
1203 #endif
1204 #if YYSTACKDEPTH<=0
1205 pParser->yystack = NULL;
1206 pParser->yystksz = 0;
1207 yyGrowStack(pParser);
1208 #endif
1209 }
1210 return pParser;
1211 }
1212
1213 /* The following function deletes the value associated with a
1214 ** symbol. The symbol can be either a terminal or nonterminal.
1215 ** "yymajor" is the symbol code, and "yypminor" is a pointer to
1216 ** the value.
1217 */
yy_destructor(yyParser * yypParser,YYCODETYPE yymajor,YYMINORTYPE * yypminor)1218 static void yy_destructor(
1219 yyParser *yypParser, /* The parser */
1220 YYCODETYPE yymajor, /* Type code for object to destroy */
1221 YYMINORTYPE *yypminor /* The object to be destroyed */
1222 ){
1223 priv_gda_sql_parserARG_FETCH;
1224 switch( yymajor ){
1225 /* Here is inserted the actions which take place when a
1226 ** terminal or non-terminal is destroyed. This can happen
1227 ** when the symbol is popped from the stack during a
1228 ** reduce or during error processing or when a parser is
1229 ** being destroyed before it is finished parsing.
1230 **
1231 ** Note: during a reduce, the only symbols destroyed are those
1232 ** which appear on the RHS of the rule, but which are not used
1233 ** inside the C code.
1234 */
1235 /* TERMINAL Destructor */
1236 case 1: /* ID */
1237 case 2: /* ABORT */
1238 case 3: /* AFTER */
1239 case 4: /* ANALYZE */
1240 case 5: /* ASC */
1241 case 6: /* ATTACH */
1242 case 7: /* BEFORE */
1243 case 8: /* BEGIN */
1244 case 9: /* CASCADE */
1245 case 10: /* CAST */
1246 case 11: /* CONFLICT */
1247 case 12: /* DATABASE */
1248 case 13: /* DEFERRED */
1249 case 14: /* DESC */
1250 case 15: /* DETACH */
1251 case 16: /* EACH */
1252 case 17: /* END */
1253 case 18: /* EXCLUSIVE */
1254 case 19: /* EXPLAIN */
1255 case 20: /* FAIL */
1256 case 21: /* FOR */
1257 case 22: /* IGNORE */
1258 case 23: /* IMMEDIATE */
1259 case 24: /* INITIALLY */
1260 case 25: /* INSTEAD */
1261 case 26: /* LIKE */
1262 case 27: /* ILIKE */
1263 case 28: /* MATCH */
1264 case 29: /* PLAN */
1265 case 30: /* QUERY */
1266 case 31: /* KEY */
1267 case 32: /* OF */
1268 case 33: /* OFFSET */
1269 case 34: /* PRAGMA */
1270 case 35: /* RAISE */
1271 case 36: /* REPLACE */
1272 case 37: /* RESTRICT */
1273 case 38: /* ROW */
1274 case 39: /* TEMP */
1275 case 40: /* TRIGGER */
1276 case 41: /* VACUUM */
1277 case 42: /* VIEW */
1278 case 43: /* VIRTUAL */
1279 case 44: /* REINDEX */
1280 case 45: /* RENAME */
1281 case 46: /* CTIME_KW */
1282 case 47: /* IF */
1283 case 48: /* DELIMITER */
1284 case 49: /* COMMIT */
1285 case 50: /* ROLLBACK */
1286 case 51: /* ISOLATION */
1287 case 52: /* LEVEL */
1288 case 53: /* SERIALIZABLE */
1289 case 54: /* READ */
1290 case 55: /* COMMITTED */
1291 case 56: /* UNCOMMITTED */
1292 case 57: /* REPEATABLE */
1293 case 58: /* WRITE */
1294 case 59: /* ONLY */
1295 case 60: /* SAVEPOINT */
1296 case 61: /* RELEASE */
1297 case 62: /* COMMENT */
1298 case 63: /* FORCE */
1299 case 64: /* WAIT */
1300 case 65: /* NOWAIT */
1301 case 66: /* BATCH */
1302 case 67: /* TEXTUAL */
1303 case 68: /* STRING */
1304 case 69: /* OR */
1305 case 70: /* AND */
1306 case 71: /* NOT */
1307 case 72: /* IS */
1308 case 73: /* NOTLIKE */
1309 case 74: /* NOTILIKE */
1310 case 75: /* IN */
1311 case 76: /* ISNULL */
1312 case 77: /* NOTNULL */
1313 case 78: /* DIFF */
1314 case 79: /* EQ */
1315 case 80: /* BETWEEN */
1316 case 81: /* GT */
1317 case 82: /* LEQ */
1318 case 83: /* LT */
1319 case 84: /* GEQ */
1320 case 85: /* REGEXP */
1321 case 86: /* REGEXP_CI */
1322 case 87: /* NOT_REGEXP */
1323 case 88: /* NOT_REGEXP_CI */
1324 case 89: /* SIMILAR */
1325 case 90: /* ESCAPE */
1326 case 91: /* BITAND */
1327 case 92: /* BITOR */
1328 case 93: /* LSHIFT */
1329 case 94: /* RSHIFT */
1330 case 95: /* PLUS */
1331 case 96: /* MINUS */
1332 case 97: /* STAR */
1333 case 98: /* SLASH */
1334 case 99: /* REM */
1335 case 100: /* CONCAT */
1336 case 101: /* COLLATE */
1337 case 102: /* UMINUS */
1338 case 103: /* UPLUS */
1339 case 104: /* BITNOT */
1340 case 105: /* LP */
1341 case 106: /* RP */
1342 case 107: /* JOIN */
1343 case 108: /* INNER */
1344 case 109: /* NATURAL */
1345 case 110: /* LEFT */
1346 case 111: /* RIGHT */
1347 case 112: /* FULL */
1348 case 113: /* CROSS */
1349 case 114: /* UNION */
1350 case 115: /* EXCEPT */
1351 case 116: /* INTERSECT */
1352 case 117: /* PGCAST */
1353 case 118: /* ILLEGAL */
1354 case 119: /* SQLCOMMENT */
1355 case 120: /* SEMI */
1356 case 121: /* END_OF_FILE */
1357 case 122: /* TRANSACTION */
1358 case 123: /* COMMA */
1359 case 124: /* INTEGER */
1360 case 125: /* TO */
1361 case 126: /* INSERT */
1362 case 127: /* INTO */
1363 case 128: /* VALUES */
1364 case 129: /* DELETE */
1365 case 130: /* FROM */
1366 case 131: /* WHERE */
1367 case 132: /* UPDATE */
1368 case 133: /* SET */
1369 case 134: /* ALL */
1370 case 135: /* SELECT */
1371 case 136: /* LIMIT */
1372 case 137: /* ORDER */
1373 case 138: /* BY */
1374 case 139: /* HAVING */
1375 case 140: /* GROUP */
1376 case 141: /* USING */
1377 case 142: /* ON */
1378 case 143: /* OUTER */
1379 case 144: /* DOT */
1380 case 145: /* AS */
1381 case 146: /* DISTINCT */
1382 case 147: /* CASE */
1383 case 148: /* WHEN */
1384 case 149: /* THEN */
1385 case 150: /* ELSE */
1386 case 151: /* NULL */
1387 case 152: /* FLOAT */
1388 case 153: /* UNSPECVAL */
1389 case 154: /* LSBRACKET */
1390 case 155: /* RSBRACKET */
1391 case 156: /* SIMPLEPARAM */
1392 case 157: /* PNAME */
1393 case 158: /* PDESCR */
1394 case 159: /* PTYPE */
1395 case 160: /* PNULLOK */
1396 {
1397 #line 9 "./parser.y"
1398 if ((yypminor->yy0)) {
1399 #ifdef GDA_DEBUG_NO
1400 gchar *str = gda_sql_value_stringify ((yypminor->yy0));
1401 g_print ("___ token destructor /%s/\n", str)
1402 g_free (str);
1403 #endif
1404 g_value_unset ((yypminor->yy0)); g_free ((yypminor->yy0));}
1405 #line 1406 "parser.c"
1406 }
1407 break;
1408 case 162: /* stmt */
1409 {
1410 #line 280 "./parser.y"
1411 g_print ("Statement destroyed by parser: %p\n", (yypminor->yy116)); gda_sql_statement_free ((yypminor->yy116));
1412 #line 1413 "parser.c"
1413 }
1414 break;
1415 case 163: /* cmd */
1416 case 165: /* compound */
1417 case 182: /* selectcmd */
1418 {
1419 #line 303 "./parser.y"
1420 gda_sql_statement_free ((yypminor->yy116));
1421 #line 1422 "parser.c"
1422 }
1423 break;
1424 case 175: /* inscollist_opt */
1425 case 178: /* inscollist */
1426 case 198: /* using_opt */
1427 {
1428 #line 480 "./parser.y"
1429 if ((yypminor->yy333)) {g_slist_foreach ((yypminor->yy333), (GFunc) gda_sql_field_free, NULL); g_slist_free ((yypminor->yy333));}
1430 #line 1431 "parser.c"
1431 }
1432 break;
1433 case 176: /* rexprlist */
1434 case 193: /* rnexprlist */
1435 {
1436 #line 769 "./parser.y"
1437 if ((yypminor->yy325)) {g_slist_foreach ((yypminor->yy325), (GFunc) gda_sql_expr_free, NULL); g_slist_free ((yypminor->yy325));}
1438 #line 1439 "parser.c"
1439 }
1440 break;
1441 case 177: /* ins_extra_values */
1442 {
1443 #line 469 "./parser.y"
1444 GSList *list;
1445 for (list = (yypminor->yy333); list; list = list->next) {
1446 g_slist_foreach ((GSList*) list->data, (GFunc) gda_sql_field_free, NULL);
1447 g_slist_free ((GSList*) list->data);
1448 }
1449 g_slist_free ((yypminor->yy333));
1450
1451 #line 1452 "parser.c"
1452 }
1453 break;
1454 case 179: /* where_opt */
1455 case 180: /* expr */
1456 case 188: /* having_opt */
1457 case 197: /* on_cond */
1458 case 204: /* pvalue */
1459 {
1460 #line 502 "./parser.y"
1461 gda_sql_expr_free ((yypminor->yy70));
1462 #line 1463 "parser.c"
1463 }
1464 break;
1465 case 181: /* setlist */
1466 {
1467 #line 522 "./parser.y"
1468 GSList *list;
1469 for (list = (yypminor->yy333); list; list = list->next) {
1470 UpdateSet *set = (UpdateSet*) list->data;
1471 g_value_reset (set->fname); g_free (set->fname);
1472 gda_sql_expr_free (set->expr);
1473 g_free (set);
1474 }
1475 g_slist_free ((yypminor->yy333));
1476
1477 #line 1478 "parser.c"
1478 }
1479 break;
1480 case 184: /* distinct */
1481 {
1482 #line 755 "./parser.y"
1483 if ((yypminor->yy297)) {if ((yypminor->yy297)->expr) gda_sql_expr_free ((yypminor->yy297)->expr); g_free ((yypminor->yy297));}
1484 #line 1485 "parser.c"
1485 }
1486 break;
1487 case 185: /* selcollist */
1488 case 201: /* sclp */
1489 {
1490 #line 712 "./parser.y"
1491 g_slist_foreach ((yypminor->yy325), (GFunc) gda_sql_select_field_free, NULL); g_slist_free ((yypminor->yy325));
1492 #line 1493 "parser.c"
1493 }
1494 break;
1495 case 186: /* from */
1496 case 194: /* seltablist */
1497 case 195: /* stl_prefix */
1498 {
1499 #line 635 "./parser.y"
1500 gda_sql_select_from_free ((yypminor->yy191));
1501 #line 1502 "parser.c"
1502 }
1503 break;
1504 case 187: /* groupby_opt */
1505 {
1506 #line 630 "./parser.y"
1507 if ((yypminor->yy333)) {g_slist_foreach ((yypminor->yy333), (GFunc) gda_sql_expr_free, NULL); g_slist_free ((yypminor->yy333));}
1508 #line 1509 "parser.c"
1509 }
1510 break;
1511 case 189: /* orderby_opt */
1512 case 191: /* sortlist */
1513 {
1514 #line 599 "./parser.y"
1515 if ((yypminor->yy325)) {g_slist_foreach ((yypminor->yy325), (GFunc) gda_sql_select_order_free, NULL); g_slist_free ((yypminor->yy325));}
1516 #line 1517 "parser.c"
1517 }
1518 break;
1519 case 190: /* limit_opt */
1520 {
1521 #line 592 "./parser.y"
1522 gda_sql_expr_free ((yypminor->yy44).count); gda_sql_expr_free ((yypminor->yy44).offset);
1523 #line 1524 "parser.c"
1524 }
1525 break;
1526 case 196: /* seltarget */
1527 {
1528 #line 694 "./parser.y"
1529 gda_sql_select_target_free ((yypminor->yy134));
1530 #line 1531 "parser.c"
1531 }
1532 break;
1533 case 206: /* case_operand */
1534 case 208: /* case_else */
1535 {
1536 #line 936 "./parser.y"
1537 gda_sql_expr_free ((yypminor->yy146));
1538 #line 1539 "parser.c"
1539 }
1540 break;
1541 case 207: /* case_exprlist */
1542 {
1543 #line 941 "./parser.y"
1544 g_slist_foreach ((yypminor->yy59).when_list, (GFunc) gda_sql_expr_free, NULL); g_slist_free ((yypminor->yy59).when_list);
1545 g_slist_foreach ((yypminor->yy59).then_list, (GFunc) gda_sql_expr_free, NULL); g_slist_free ((yypminor->yy59).then_list);
1546 #line 1547 "parser.c"
1547 }
1548 break;
1549 case 209: /* paramspec */
1550 {
1551 #line 979 "./parser.y"
1552 gda_sql_param_spec_free ((yypminor->yy339));
1553 #line 1554 "parser.c"
1554 }
1555 break;
1556 default: break; /* If no destructor action specified: do nothing */
1557 }
1558 }
1559
1560 /*
1561 ** Pop the parser's stack once.
1562 **
1563 ** If there is a destructor routine associated with the token which
1564 ** is popped from the stack, then call it.
1565 **
1566 ** Return the major token number for the symbol popped.
1567 */
yy_pop_parser_stack(yyParser * pParser)1568 static int yy_pop_parser_stack(yyParser *pParser){
1569 YYCODETYPE yymajor;
1570 yyStackEntry *yytos;
1571
1572 if( pParser->yyidx<0 ) return 0;
1573 yytos = &pParser->yystack[pParser->yyidx];
1574 #ifndef NDEBUG
1575 if( yyTraceFILE && pParser->yyidx>=0 ){
1576 fprintf(yyTraceFILE,"%sPopping %s\n",
1577 yyTracePrompt,
1578 yyTokenName[yytos->major]);
1579 }
1580 #endif
1581 yymajor = yytos->major;
1582 yy_destructor(pParser, yymajor, &yytos->minor);
1583 pParser->yyidx--;
1584 return yymajor;
1585 }
1586
1587 /*
1588 ** Deallocate and destroy a parser. Destructors are all called for
1589 ** all stack elements before shutting the parser down.
1590 **
1591 ** Inputs:
1592 ** <ul>
1593 ** <li> A pointer to the parser. This should be a pointer
1594 ** obtained from priv_gda_sql_parserAlloc.
1595 ** <li> A pointer to a function used to reclaim memory obtained
1596 ** from malloc.
1597 ** </ul>
1598 */
priv_gda_sql_parserFree(void * p,void (* freeProc)(void *))1599 void priv_gda_sql_parserFree(
1600 void *p, /* The parser to be deleted */
1601 void (*freeProc)(void*) /* Function used to reclaim memory */
1602 ){
1603 yyParser *pParser = (yyParser*)p;
1604 if( pParser==0 ) return;
1605 while( pParser->yyidx>=0 ) yy_pop_parser_stack(pParser);
1606 #if YYSTACKDEPTH<=0
1607 free(pParser->yystack);
1608 #endif
1609 (*freeProc)((void*)pParser);
1610 }
1611
1612 /*
1613 ** Return the peak depth of the stack for a parser.
1614 */
1615 #ifdef YYTRACKMAXSTACKDEPTH
priv_gda_sql_parserStackPeak(void * p)1616 int priv_gda_sql_parserStackPeak(void *p){
1617 yyParser *pParser = (yyParser*)p;
1618 return pParser->yyidxMax;
1619 }
1620 #endif
1621
1622 /*
1623 ** Find the appropriate action for a parser given the terminal
1624 ** look-ahead token iLookAhead.
1625 **
1626 ** If the look-ahead token is YYNOCODE, then check to see if the action is
1627 ** independent of the look-ahead. If it is, return the action, otherwise
1628 ** return YY_NO_ACTION.
1629 */
yy_find_shift_action(yyParser * pParser,YYCODETYPE iLookAhead)1630 static int yy_find_shift_action(
1631 yyParser *pParser, /* The parser */
1632 YYCODETYPE iLookAhead /* The look-ahead token */
1633 ){
1634 int i;
1635 int stateno = pParser->yystack[pParser->yyidx].stateno;
1636
1637 if( stateno>YY_SHIFT_COUNT
1638 || (i = yy_shift_ofst[stateno])==YY_SHIFT_USE_DFLT ){
1639 return yy_default[stateno];
1640 }
1641 assert( iLookAhead!=YYNOCODE );
1642 i += iLookAhead;
1643 if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){
1644 if( iLookAhead>0 ){
1645 #ifdef YYFALLBACK
1646 YYCODETYPE iFallback; /* Fallback token */
1647 if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0])
1648 && (iFallback = yyFallback[iLookAhead])!=0 ){
1649 #ifndef NDEBUG
1650 if( yyTraceFILE ){
1651 fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",
1652 yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]);
1653 }
1654 #endif
1655 return yy_find_shift_action(pParser, iFallback);
1656 }
1657 #endif
1658 #ifdef YYWILDCARD
1659 {
1660 int j = i - iLookAhead + YYWILDCARD;
1661 if(
1662 #if YY_SHIFT_MIN+YYWILDCARD<0
1663 j>=0 &&
1664 #endif
1665 #if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT
1666 j<YY_ACTTAB_COUNT &&
1667 #endif
1668 yy_lookahead[j]==YYWILDCARD
1669 ){
1670 #ifndef NDEBUG
1671 if( yyTraceFILE ){
1672 fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n",
1673 yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[YYWILDCARD]);
1674 }
1675 #endif /* NDEBUG */
1676 return yy_action[j];
1677 }
1678 }
1679 #endif /* YYWILDCARD */
1680 }
1681 return yy_default[stateno];
1682 }else{
1683 return yy_action[i];
1684 }
1685 }
1686
1687 /*
1688 ** Find the appropriate action for a parser given the non-terminal
1689 ** look-ahead token iLookAhead.
1690 **
1691 ** If the look-ahead token is YYNOCODE, then check to see if the action is
1692 ** independent of the look-ahead. If it is, return the action, otherwise
1693 ** return YY_NO_ACTION.
1694 */
yy_find_reduce_action(int stateno,YYCODETYPE iLookAhead)1695 static int yy_find_reduce_action(
1696 int stateno, /* Current state number */
1697 YYCODETYPE iLookAhead /* The look-ahead token */
1698 ){
1699 int i;
1700 #ifdef YYERRORSYMBOL
1701 if( stateno>YY_REDUCE_COUNT ){
1702 return yy_default[stateno];
1703 }
1704 #else
1705 assert( stateno<=YY_REDUCE_COUNT );
1706 #endif
1707 i = yy_reduce_ofst[stateno];
1708 assert( i!=YY_REDUCE_USE_DFLT );
1709 assert( iLookAhead!=YYNOCODE );
1710 i += iLookAhead;
1711 #ifdef YYERRORSYMBOL
1712 if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){
1713 return yy_default[stateno];
1714 }
1715 #else
1716 assert( i>=0 && i<YY_ACTTAB_COUNT );
1717 assert( yy_lookahead[i]==iLookAhead );
1718 #endif
1719 return yy_action[i];
1720 }
1721
1722 /*
1723 ** The following routine is called if the stack overflows.
1724 */
yyStackOverflow(yyParser * yypParser,YYMINORTYPE * yypMinor)1725 static void yyStackOverflow(yyParser *yypParser, YYMINORTYPE *yypMinor){
1726 priv_gda_sql_parserARG_FETCH;
1727 yypParser->yyidx--;
1728 #ifndef NDEBUG
1729 if( yyTraceFILE ){
1730 fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
1731 }
1732 #endif
1733 while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
1734 /* Here code is inserted which will execute if the parser
1735 ** stack every overflows */
1736 #line 25 "./parser.y"
1737
1738 gda_sql_parser_set_overflow_error (pdata->parser);
1739 #line 1740 "parser.c"
1740 priv_gda_sql_parserARG_STORE; /* Suppress warning about unused %extra_argument var */
1741 }
1742
1743 /*
1744 ** Perform a shift action.
1745 */
yy_shift(yyParser * yypParser,int yyNewState,int yyMajor,YYMINORTYPE * yypMinor)1746 static void yy_shift(
1747 yyParser *yypParser, /* The parser to be shifted */
1748 int yyNewState, /* The new state to shift in */
1749 int yyMajor, /* The major token to shift in */
1750 YYMINORTYPE *yypMinor /* Pointer to the minor token to shift in */
1751 ){
1752 yyStackEntry *yytos;
1753 yypParser->yyidx++;
1754 #ifdef YYTRACKMAXSTACKDEPTH
1755 if( yypParser->yyidx>yypParser->yyidxMax ){
1756 yypParser->yyidxMax = yypParser->yyidx;
1757 }
1758 #endif
1759 #if YYSTACKDEPTH>0
1760 if( yypParser->yyidx>=YYSTACKDEPTH ){
1761 yyStackOverflow(yypParser, yypMinor);
1762 return;
1763 }
1764 #else
1765 if( yypParser->yyidx>=yypParser->yystksz ){
1766 yyGrowStack(yypParser);
1767 if( yypParser->yyidx>=yypParser->yystksz ){
1768 yyStackOverflow(yypParser, yypMinor);
1769 return;
1770 }
1771 }
1772 #endif
1773 yytos = &yypParser->yystack[yypParser->yyidx];
1774 yytos->stateno = (YYACTIONTYPE)yyNewState;
1775 yytos->major = (YYCODETYPE)yyMajor;
1776 yytos->minor = *yypMinor;
1777 #ifndef NDEBUG
1778 if( yyTraceFILE && yypParser->yyidx>0 ){
1779 int i;
1780 fprintf(yyTraceFILE,"%sShift %d\n",yyTracePrompt,yyNewState);
1781 fprintf(yyTraceFILE,"%sStack:",yyTracePrompt);
1782 for(i=1; i<=yypParser->yyidx; i++)
1783 fprintf(yyTraceFILE," %s",yyTokenName[yypParser->yystack[i].major]);
1784 fprintf(yyTraceFILE,"\n");
1785 }
1786 #endif
1787 }
1788
1789 /* The following table contains information about every rule that
1790 ** is used during the reduce.
1791 */
1792 static const struct {
1793 YYCODETYPE lhs; /* Symbol on the left-hand side of the rule */
1794 unsigned char nrhs; /* Number of right-hand side symbols in the rule */
1795 } yyRuleInfo[] = {
1796 { 162, 2 },
1797 { 162, 2 },
1798 { 163, 3 },
1799 { 165, 3 },
1800 { 164, 1 },
1801 { 164, 1 },
1802 { 163, 1 },
1803 { 163, 3 },
1804 { 163, 4 },
1805 { 163, 3 },
1806 { 163, 2 },
1807 { 163, 3 },
1808 { 163, 3 },
1809 { 163, 5 },
1810 { 163, 5 },
1811 { 163, 4 },
1812 { 163, 4 },
1813 { 163, 3 },
1814 { 163, 2 },
1815 { 163, 3 },
1816 { 163, 3 },
1817 { 163, 5 },
1818 { 163, 3 },
1819 { 163, 4 },
1820 { 163, 2 },
1821 { 163, 3 },
1822 { 171, 2 },
1823 { 171, 2 },
1824 { 171, 2 },
1825 { 171, 2 },
1826 { 171, 3 },
1827 { 171, 3 },
1828 { 171, 3 },
1829 { 171, 3 },
1830 { 170, 0 },
1831 { 170, 1 },
1832 { 169, 0 },
1833 { 169, 1 },
1834 { 168, 3 },
1835 { 168, 4 },
1836 { 168, 4 },
1837 { 168, 4 },
1838 { 166, 0 },
1839 { 166, 1 },
1840 { 167, 1 },
1841 { 167, 1 },
1842 { 167, 1 },
1843 { 167, 2 },
1844 { 167, 2 },
1845 { 163, 2 },
1846 { 163, 3 },
1847 { 163, 2 },
1848 { 163, 4 },
1849 { 163, 5 },
1850 { 163, 9 },
1851 { 163, 10 },
1852 { 163, 6 },
1853 { 173, 0 },
1854 { 173, 2 },
1855 { 177, 5 },
1856 { 177, 4 },
1857 { 175, 0 },
1858 { 175, 3 },
1859 { 178, 3 },
1860 { 178, 1 },
1861 { 163, 4 },
1862 { 179, 0 },
1863 { 179, 2 },
1864 { 163, 6 },
1865 { 181, 5 },
1866 { 181, 3 },
1867 { 165, 1 },
1868 { 165, 4 },
1869 { 165, 4 },
1870 { 165, 4 },
1871 { 183, 0 },
1872 { 183, 1 },
1873 { 182, 9 },
1874 { 190, 0 },
1875 { 190, 2 },
1876 { 190, 4 },
1877 { 190, 4 },
1878 { 189, 0 },
1879 { 189, 3 },
1880 { 191, 4 },
1881 { 191, 2 },
1882 { 192, 1 },
1883 { 192, 1 },
1884 { 192, 0 },
1885 { 188, 0 },
1886 { 188, 2 },
1887 { 187, 0 },
1888 { 187, 3 },
1889 { 186, 0 },
1890 { 186, 2 },
1891 { 194, 4 },
1892 { 198, 4 },
1893 { 198, 0 },
1894 { 195, 0 },
1895 { 195, 2 },
1896 { 197, 2 },
1897 { 197, 0 },
1898 { 199, 1 },
1899 { 199, 1 },
1900 { 199, 2 },
1901 { 199, 2 },
1902 { 199, 2 },
1903 { 199, 2 },
1904 { 199, 3 },
1905 { 199, 2 },
1906 { 199, 3 },
1907 { 199, 2 },
1908 { 199, 3 },
1909 { 196, 2 },
1910 { 196, 2 },
1911 { 196, 4 },
1912 { 196, 4 },
1913 { 201, 2 },
1914 { 201, 0 },
1915 { 185, 3 },
1916 { 185, 2 },
1917 { 202, 1 },
1918 { 202, 3 },
1919 { 202, 5 },
1920 { 200, 2 },
1921 { 200, 2 },
1922 { 200, 0 },
1923 { 184, 0 },
1924 { 184, 1 },
1925 { 184, 1 },
1926 { 184, 3 },
1927 { 193, 3 },
1928 { 193, 1 },
1929 { 176, 0 },
1930 { 176, 3 },
1931 { 176, 1 },
1932 { 180, 1 },
1933 { 180, 1 },
1934 { 180, 3 },
1935 { 180, 1 },
1936 { 180, 4 },
1937 { 180, 4 },
1938 { 180, 4 },
1939 { 180, 6 },
1940 { 180, 3 },
1941 { 180, 3 },
1942 { 180, 3 },
1943 { 180, 3 },
1944 { 180, 3 },
1945 { 180, 2 },
1946 { 180, 2 },
1947 { 180, 3 },
1948 { 180, 3 },
1949 { 180, 3 },
1950 { 180, 3 },
1951 { 180, 3 },
1952 { 180, 3 },
1953 { 180, 3 },
1954 { 180, 3 },
1955 { 180, 3 },
1956 { 180, 3 },
1957 { 180, 5 },
1958 { 180, 6 },
1959 { 180, 2 },
1960 { 180, 2 },
1961 { 180, 2 },
1962 { 180, 3 },
1963 { 180, 3 },
1964 { 180, 5 },
1965 { 180, 5 },
1966 { 180, 6 },
1967 { 180, 6 },
1968 { 180, 5 },
1969 { 206, 1 },
1970 { 206, 0 },
1971 { 207, 5 },
1972 { 207, 4 },
1973 { 208, 2 },
1974 { 208, 0 },
1975 { 205, 1 },
1976 { 205, 2 },
1977 { 203, 1 },
1978 { 203, 1 },
1979 { 203, 1 },
1980 { 203, 1 },
1981 { 204, 4 },
1982 { 204, 4 },
1983 { 204, 1 },
1984 { 209, 0 },
1985 { 209, 2 },
1986 { 209, 2 },
1987 { 209, 2 },
1988 { 209, 2 },
1989 { 172, 1 },
1990 { 172, 1 },
1991 { 172, 1 },
1992 { 172, 1 },
1993 { 174, 1 },
1994 { 174, 3 },
1995 { 174, 5 },
1996 };
1997
1998 static void yy_accept(yyParser*); /* Forward Declaration */
1999
2000 /*
2001 ** Perform a reduce action and the shift that must immediately
2002 ** follow the reduce.
2003 */
yy_reduce(yyParser * yypParser,int yyruleno)2004 static void yy_reduce(
2005 yyParser *yypParser, /* The parser */
2006 int yyruleno /* Number of the rule by which to reduce */
2007 ){
2008 int yygoto; /* The next state */
2009 int yyact; /* The next action */
2010 YYMINORTYPE yygotominor; /* The LHS of the rule reduced */
2011 yyStackEntry *yymsp; /* The top of the parser's stack */
2012 int yysize; /* Amount to pop the stack */
2013 priv_gda_sql_parserARG_FETCH;
2014 yymsp = &yypParser->yystack[yypParser->yyidx];
2015 #ifndef NDEBUG
2016 if( yyTraceFILE && yyruleno>=0
2017 && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){
2018 fprintf(yyTraceFILE, "%sReduce [%s].\n", yyTracePrompt,
2019 yyRuleName[yyruleno]);
2020 }
2021 #endif /* NDEBUG */
2022
2023 /* Silence complaints from purify about yygotominor being uninitialized
2024 ** in some cases when it is copied into the stack after the following
2025 ** switch. yygotominor is uninitialized when a rule reduces that does
2026 ** not set the value of its left-hand side nonterminal. Leaving the
2027 ** value of the nonterminal uninitialized is utterly harmless as long
2028 ** as the value is never used. So really the only thing this code
2029 ** accomplishes is to quieten purify.
2030 **
2031 ** 2007-01-16: The wireshark project (www.wireshark.org) reports that
2032 ** without this code, their parser segfaults. I'm not sure what there
2033 ** parser is doing to make this happen. This is the second bug report
2034 ** from wireshark this week. Clearly they are stressing Lemon in ways
2035 ** that it has not been previously stressed... (SQLite ticket #2172)
2036 */
2037 /*memset(&yygotominor, 0, sizeof(yygotominor));*/
2038 yygotominor = yyzerominor;
2039
2040
2041 switch( yyruleno ){
2042 /* Beginning here are the reduction cases. A typical example
2043 ** follows:
2044 ** case 0:
2045 ** #line <lineno> <grammarfile>
2046 ** { ... } // User supplied code
2047 ** #line <lineno> <thisfile>
2048 ** break;
2049 */
2050 case 0: /* stmt ::= cmd eos */
2051 #line 281 "./parser.y"
2052 {pdata->parsed_statement = yymsp[-1].minor.yy116;}
2053 #line 2054 "parser.c"
2054 break;
2055 case 1: /* stmt ::= compound eos */
2056 #line 282 "./parser.y"
2057 {
2058 GdaSqlStatementCompound *scompound = (GdaSqlStatementCompound *) yymsp[-1].minor.yy116->contents;
2059 if (scompound->stmt_list->next)
2060 /* real compound (multiple statements) */
2061 pdata->parsed_statement = yymsp[-1].minor.yy116;
2062 else {
2063 /* false compound (only 1 select) */
2064 pdata->parsed_statement = (GdaSqlStatement*) scompound->stmt_list->data;
2065 GDA_SQL_ANY_PART (pdata->parsed_statement->contents)->parent = NULL;
2066 g_slist_free (scompound->stmt_list);
2067 scompound->stmt_list = NULL;
2068 gda_sql_statement_free (yymsp[-1].minor.yy116);
2069 }
2070 }
2071 #line 2072 "parser.c"
2072 break;
2073 case 2: /* cmd ::= LP cmd RP */
2074 case 3: /* compound ::= LP compound RP */ yytestcase(yyruleno==3);
2075 #line 296 "./parser.y"
2076 {yygotominor.yy116 = yymsp[-1].minor.yy116; yy_destructor(yypParser,105,&yymsp[-2].minor);
2077 yy_destructor(yypParser,106,&yymsp[0].minor);
2078 }
2079 #line 2080 "parser.c"
2080 break;
2081 case 4: /* eos ::= SEMI */
2082 #line 299 "./parser.y"
2083 {
2084 yy_destructor(yypParser,120,&yymsp[0].minor);
2085 }
2086 #line 2087 "parser.c"
2087 break;
2088 case 5: /* eos ::= END_OF_FILE */
2089 #line 300 "./parser.y"
2090 {
2091 yy_destructor(yypParser,121,&yymsp[0].minor);
2092 }
2093 #line 2094 "parser.c"
2094 break;
2095 case 6: /* cmd ::= BEGIN */
2096 #line 308 "./parser.y"
2097 {yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_BEGIN); yy_destructor(yypParser,8,&yymsp[0].minor);
2098 }
2099 #line 2100 "parser.c"
2100 break;
2101 case 7: /* cmd ::= BEGIN TRANSACTION nm_opt */
2102 #line 309 "./parser.y"
2103 {yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_BEGIN);
2104 gda_sql_statement_trans_take_name (yygotominor.yy116, yymsp[0].minor.yy0);
2105 yy_destructor(yypParser,8,&yymsp[-2].minor);
2106 yy_destructor(yypParser,122,&yymsp[-1].minor);
2107 }
2108 #line 2109 "parser.c"
2109 break;
2110 case 8: /* cmd ::= BEGIN transtype TRANSACTION nm_opt */
2111 #line 313 "./parser.y"
2112 {yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_BEGIN);
2113 gda_sql_statement_trans_take_mode (yygotominor.yy116, yymsp[-2].minor.yy0);
2114 gda_sql_statement_trans_take_name (yygotominor.yy116, yymsp[0].minor.yy0);
2115 yy_destructor(yypParser,8,&yymsp[-3].minor);
2116 yy_destructor(yypParser,122,&yymsp[-1].minor);
2117 }
2118 #line 2119 "parser.c"
2119 break;
2120 case 9: /* cmd ::= BEGIN transtype nm_opt */
2121 #line 318 "./parser.y"
2122 {yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_BEGIN);
2123 gda_sql_statement_trans_take_mode (yygotominor.yy116, yymsp[-1].minor.yy0);
2124 gda_sql_statement_trans_take_name (yygotominor.yy116, yymsp[0].minor.yy0);
2125 yy_destructor(yypParser,8,&yymsp[-2].minor);
2126 }
2127 #line 2128 "parser.c"
2128 break;
2129 case 10: /* cmd ::= BEGIN transilev */
2130 #line 323 "./parser.y"
2131 {yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_BEGIN);
2132 gda_sql_statement_trans_set_isol_level (yygotominor.yy116, yymsp[0].minor.yy169);
2133 yy_destructor(yypParser,8,&yymsp[-1].minor);
2134 }
2135 #line 2136 "parser.c"
2136 break;
2137 case 11: /* cmd ::= BEGIN TRANSACTION transilev */
2138 #line 327 "./parser.y"
2139 {yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_BEGIN);
2140 gda_sql_statement_trans_set_isol_level (yygotominor.yy116, yymsp[0].minor.yy169);
2141 yy_destructor(yypParser,8,&yymsp[-2].minor);
2142 yy_destructor(yypParser,122,&yymsp[-1].minor);
2143 }
2144 #line 2145 "parser.c"
2145 break;
2146 case 12: /* cmd ::= BEGIN TRANSACTION transtype */
2147 #line 331 "./parser.y"
2148 {yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_BEGIN);
2149 gda_sql_statement_trans_take_mode (yygotominor.yy116, yymsp[0].minor.yy0);
2150 yy_destructor(yypParser,8,&yymsp[-2].minor);
2151 yy_destructor(yypParser,122,&yymsp[-1].minor);
2152 }
2153 #line 2154 "parser.c"
2154 break;
2155 case 13: /* cmd ::= BEGIN TRANSACTION transtype opt_comma transilev */
2156 #line 335 "./parser.y"
2157 {yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_BEGIN);
2158 gda_sql_statement_trans_take_mode (yygotominor.yy116, yymsp[-2].minor.yy0);
2159 gda_sql_statement_trans_set_isol_level (yygotominor.yy116, yymsp[0].minor.yy169);
2160 yy_destructor(yypParser,8,&yymsp[-4].minor);
2161 yy_destructor(yypParser,122,&yymsp[-3].minor);
2162 }
2163 #line 2164 "parser.c"
2164 break;
2165 case 14: /* cmd ::= BEGIN TRANSACTION transilev opt_comma transtype */
2166 #line 340 "./parser.y"
2167 {yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_BEGIN);
2168 gda_sql_statement_trans_take_mode (yygotominor.yy116, yymsp[0].minor.yy0);
2169 gda_sql_statement_trans_set_isol_level (yygotominor.yy116, yymsp[-2].minor.yy169);
2170 yy_destructor(yypParser,8,&yymsp[-4].minor);
2171 yy_destructor(yypParser,122,&yymsp[-3].minor);
2172 }
2173 #line 2174 "parser.c"
2174 break;
2175 case 15: /* cmd ::= BEGIN transtype opt_comma transilev */
2176 #line 345 "./parser.y"
2177 {yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_BEGIN);
2178 gda_sql_statement_trans_take_mode (yygotominor.yy116, yymsp[-2].minor.yy0);
2179 gda_sql_statement_trans_set_isol_level (yygotominor.yy116, yymsp[0].minor.yy169);
2180 yy_destructor(yypParser,8,&yymsp[-3].minor);
2181 }
2182 #line 2183 "parser.c"
2183 break;
2184 case 16: /* cmd ::= BEGIN transilev opt_comma transtype */
2185 #line 350 "./parser.y"
2186 {yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_BEGIN);
2187 gda_sql_statement_trans_take_mode (yygotominor.yy116, yymsp[0].minor.yy0);
2188 gda_sql_statement_trans_set_isol_level (yygotominor.yy116, yymsp[-2].minor.yy169);
2189 yy_destructor(yypParser,8,&yymsp[-3].minor);
2190 }
2191 #line 2192 "parser.c"
2192 break;
2193 case 17: /* cmd ::= END trans_opt_kw nm_opt */
2194 #line 355 "./parser.y"
2195 {yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_COMMIT);
2196 gda_sql_statement_trans_take_name (yygotominor.yy116, yymsp[0].minor.yy0);
2197 yy_destructor(yypParser,17,&yymsp[-2].minor);
2198 }
2199 #line 2200 "parser.c"
2200 break;
2201 case 18: /* cmd ::= COMMIT nm_opt */
2202 #line 359 "./parser.y"
2203 {yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_COMMIT);
2204 gda_sql_statement_trans_take_name (yygotominor.yy116, yymsp[0].minor.yy0);
2205 yy_destructor(yypParser,49,&yymsp[-1].minor);
2206 }
2207 #line 2208 "parser.c"
2208 break;
2209 case 19: /* cmd ::= COMMIT TRANSACTION nm_opt */
2210 #line 363 "./parser.y"
2211 {yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_COMMIT);
2212 gda_sql_statement_trans_take_name (yygotominor.yy116, yymsp[0].minor.yy0);
2213 yy_destructor(yypParser,49,&yymsp[-2].minor);
2214 yy_destructor(yypParser,122,&yymsp[-1].minor);
2215 }
2216 #line 2217 "parser.c"
2217 break;
2218 case 20: /* cmd ::= COMMIT FORCE STRING */
2219 #line 367 "./parser.y"
2220 {yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_COMMIT); yy_destructor(yypParser,49,&yymsp[-2].minor);
2221 yy_destructor(yypParser,63,&yymsp[-1].minor);
2222 yy_destructor(yypParser,68,&yymsp[0].minor);
2223 }
2224 #line 2225 "parser.c"
2225 break;
2226 case 21: /* cmd ::= COMMIT FORCE STRING COMMA INTEGER */
2227 #line 368 "./parser.y"
2228 {yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_COMMIT); yy_destructor(yypParser,49,&yymsp[-4].minor);
2229 yy_destructor(yypParser,63,&yymsp[-3].minor);
2230 yy_destructor(yypParser,68,&yymsp[-2].minor);
2231 yy_destructor(yypParser,123,&yymsp[-1].minor);
2232 yy_destructor(yypParser,124,&yymsp[0].minor);
2233 }
2234 #line 2235 "parser.c"
2235 break;
2236 case 22: /* cmd ::= COMMIT COMMENT STRING */
2237 #line 369 "./parser.y"
2238 {yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_COMMIT); yy_destructor(yypParser,49,&yymsp[-2].minor);
2239 yy_destructor(yypParser,62,&yymsp[-1].minor);
2240 yy_destructor(yypParser,68,&yymsp[0].minor);
2241 }
2242 #line 2243 "parser.c"
2243 break;
2244 case 23: /* cmd ::= COMMIT COMMENT STRING ora_commit_write */
2245 #line 370 "./parser.y"
2246 {yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_COMMIT); yy_destructor(yypParser,49,&yymsp[-3].minor);
2247 yy_destructor(yypParser,62,&yymsp[-2].minor);
2248 yy_destructor(yypParser,68,&yymsp[-1].minor);
2249 }
2250 #line 2251 "parser.c"
2251 break;
2252 case 24: /* cmd ::= COMMIT ora_commit_write */
2253 #line 371 "./parser.y"
2254 {yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_COMMIT); yy_destructor(yypParser,49,&yymsp[-1].minor);
2255 }
2256 #line 2257 "parser.c"
2257 break;
2258 case 25: /* cmd ::= ROLLBACK trans_opt_kw nm_opt */
2259 #line 373 "./parser.y"
2260 {yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_ROLLBACK);
2261 gda_sql_statement_trans_take_name (yygotominor.yy116, yymsp[0].minor.yy0);
2262 yy_destructor(yypParser,50,&yymsp[-2].minor);
2263 }
2264 #line 2265 "parser.c"
2265 break;
2266 case 26: /* ora_commit_write ::= WRITE IMMEDIATE */
2267 #line 377 "./parser.y"
2268 {
2269 yy_destructor(yypParser,58,&yymsp[-1].minor);
2270 yy_destructor(yypParser,23,&yymsp[0].minor);
2271 }
2272 #line 2273 "parser.c"
2273 break;
2274 case 27: /* ora_commit_write ::= WRITE BATCH */
2275 #line 378 "./parser.y"
2276 {
2277 yy_destructor(yypParser,58,&yymsp[-1].minor);
2278 yy_destructor(yypParser,66,&yymsp[0].minor);
2279 }
2280 #line 2281 "parser.c"
2281 break;
2282 case 28: /* ora_commit_write ::= WRITE WAIT */
2283 #line 379 "./parser.y"
2284 {
2285 yy_destructor(yypParser,58,&yymsp[-1].minor);
2286 yy_destructor(yypParser,64,&yymsp[0].minor);
2287 }
2288 #line 2289 "parser.c"
2289 break;
2290 case 29: /* ora_commit_write ::= WRITE NOWAIT */
2291 #line 380 "./parser.y"
2292 {
2293 yy_destructor(yypParser,58,&yymsp[-1].minor);
2294 yy_destructor(yypParser,65,&yymsp[0].minor);
2295 }
2296 #line 2297 "parser.c"
2297 break;
2298 case 30: /* ora_commit_write ::= WRITE IMMEDIATE WAIT */
2299 #line 381 "./parser.y"
2300 {
2301 yy_destructor(yypParser,58,&yymsp[-2].minor);
2302 yy_destructor(yypParser,23,&yymsp[-1].minor);
2303 yy_destructor(yypParser,64,&yymsp[0].minor);
2304 }
2305 #line 2306 "parser.c"
2306 break;
2307 case 31: /* ora_commit_write ::= WRITE IMMEDIATE NOWAIT */
2308 #line 382 "./parser.y"
2309 {
2310 yy_destructor(yypParser,58,&yymsp[-2].minor);
2311 yy_destructor(yypParser,23,&yymsp[-1].minor);
2312 yy_destructor(yypParser,65,&yymsp[0].minor);
2313 }
2314 #line 2315 "parser.c"
2315 break;
2316 case 32: /* ora_commit_write ::= WRITE BATCH WAIT */
2317 #line 383 "./parser.y"
2318 {
2319 yy_destructor(yypParser,58,&yymsp[-2].minor);
2320 yy_destructor(yypParser,66,&yymsp[-1].minor);
2321 yy_destructor(yypParser,64,&yymsp[0].minor);
2322 }
2323 #line 2324 "parser.c"
2324 break;
2325 case 33: /* ora_commit_write ::= WRITE BATCH NOWAIT */
2326 #line 384 "./parser.y"
2327 {
2328 yy_destructor(yypParser,58,&yymsp[-2].minor);
2329 yy_destructor(yypParser,66,&yymsp[-1].minor);
2330 yy_destructor(yypParser,65,&yymsp[0].minor);
2331 }
2332 #line 2333 "parser.c"
2333 break;
2334 case 35: /* trans_opt_kw ::= TRANSACTION */
2335 #line 387 "./parser.y"
2336 {
2337 yy_destructor(yypParser,122,&yymsp[0].minor);
2338 }
2339 #line 2340 "parser.c"
2340 break;
2341 case 37: /* opt_comma ::= COMMA */
2342 #line 390 "./parser.y"
2343 {
2344 yy_destructor(yypParser,123,&yymsp[0].minor);
2345 }
2346 #line 2347 "parser.c"
2347 break;
2348 case 38: /* transilev ::= ISOLATION LEVEL SERIALIZABLE */
2349 #line 393 "./parser.y"
2350 {yygotominor.yy169 = GDA_TRANSACTION_ISOLATION_SERIALIZABLE; yy_destructor(yypParser,51,&yymsp[-2].minor);
2351 yy_destructor(yypParser,52,&yymsp[-1].minor);
2352 yy_destructor(yypParser,53,&yymsp[0].minor);
2353 }
2354 #line 2355 "parser.c"
2355 break;
2356 case 39: /* transilev ::= ISOLATION LEVEL REPEATABLE READ */
2357 #line 394 "./parser.y"
2358 {yygotominor.yy169 = GDA_TRANSACTION_ISOLATION_REPEATABLE_READ; yy_destructor(yypParser,51,&yymsp[-3].minor);
2359 yy_destructor(yypParser,52,&yymsp[-2].minor);
2360 yy_destructor(yypParser,57,&yymsp[-1].minor);
2361 yy_destructor(yypParser,54,&yymsp[0].minor);
2362 }
2363 #line 2364 "parser.c"
2364 break;
2365 case 40: /* transilev ::= ISOLATION LEVEL READ COMMITTED */
2366 #line 395 "./parser.y"
2367 {yygotominor.yy169 = GDA_TRANSACTION_ISOLATION_READ_COMMITTED; yy_destructor(yypParser,51,&yymsp[-3].minor);
2368 yy_destructor(yypParser,52,&yymsp[-2].minor);
2369 yy_destructor(yypParser,54,&yymsp[-1].minor);
2370 yy_destructor(yypParser,55,&yymsp[0].minor);
2371 }
2372 #line 2373 "parser.c"
2373 break;
2374 case 41: /* transilev ::= ISOLATION LEVEL READ UNCOMMITTED */
2375 #line 396 "./parser.y"
2376 {yygotominor.yy169 = GDA_TRANSACTION_ISOLATION_READ_UNCOMMITTED; yy_destructor(yypParser,51,&yymsp[-3].minor);
2377 yy_destructor(yypParser,52,&yymsp[-2].minor);
2378 yy_destructor(yypParser,54,&yymsp[-1].minor);
2379 yy_destructor(yypParser,56,&yymsp[0].minor);
2380 }
2381 #line 2382 "parser.c"
2382 break;
2383 case 42: /* nm_opt ::= */
2384 case 57: /* opt_on_conflict ::= */ yytestcase(yyruleno==57);
2385 case 126: /* as ::= */ yytestcase(yyruleno==126);
2386 #line 398 "./parser.y"
2387 {yygotominor.yy0 = NULL;}
2388 #line 2389 "parser.c"
2389 break;
2390 case 43: /* nm_opt ::= nm */
2391 case 44: /* transtype ::= DEFERRED */ yytestcase(yyruleno==44);
2392 case 45: /* transtype ::= IMMEDIATE */ yytestcase(yyruleno==45);
2393 case 46: /* transtype ::= EXCLUSIVE */ yytestcase(yyruleno==46);
2394 case 121: /* starname ::= STAR */ yytestcase(yyruleno==121);
2395 case 182: /* value ::= STRING */ yytestcase(yyruleno==182);
2396 case 183: /* value ::= INTEGER */ yytestcase(yyruleno==183);
2397 case 184: /* value ::= FLOAT */ yytestcase(yyruleno==184);
2398 case 193: /* nm ::= JOIN */ yytestcase(yyruleno==193);
2399 case 194: /* nm ::= ID */ yytestcase(yyruleno==194);
2400 case 195: /* nm ::= TEXTUAL */ yytestcase(yyruleno==195);
2401 case 196: /* nm ::= LIMIT */ yytestcase(yyruleno==196);
2402 case 197: /* fullname ::= nm */ yytestcase(yyruleno==197);
2403 #line 399 "./parser.y"
2404 {yygotominor.yy0 = yymsp[0].minor.yy0;}
2405 #line 2406 "parser.c"
2406 break;
2407 case 47: /* transtype ::= READ WRITE */
2408 #line 404 "./parser.y"
2409 {yygotominor.yy0 = g_new0 (GValue, 1);
2410 g_value_init (yygotominor.yy0, G_TYPE_STRING);
2411 g_value_set_string (yygotominor.yy0, "READ_WRITE");
2412 yy_destructor(yypParser,54,&yymsp[-1].minor);
2413 yy_destructor(yypParser,58,&yymsp[0].minor);
2414 }
2415 #line 2416 "parser.c"
2416 break;
2417 case 48: /* transtype ::= READ ONLY */
2418 #line 408 "./parser.y"
2419 {yygotominor.yy0 = g_new0 (GValue, 1);
2420 g_value_init (yygotominor.yy0, G_TYPE_STRING);
2421 g_value_set_string (yygotominor.yy0, "READ_ONLY");
2422 yy_destructor(yypParser,54,&yymsp[-1].minor);
2423 yy_destructor(yypParser,59,&yymsp[0].minor);
2424 }
2425 #line 2426 "parser.c"
2426 break;
2427 case 49: /* cmd ::= SAVEPOINT nm */
2428 #line 416 "./parser.y"
2429 {yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_SAVEPOINT);
2430 gda_sql_statement_trans_take_name (yygotominor.yy116, yymsp[0].minor.yy0);
2431 yy_destructor(yypParser,60,&yymsp[-1].minor);
2432 }
2433 #line 2434 "parser.c"
2434 break;
2435 case 50: /* cmd ::= RELEASE SAVEPOINT nm */
2436 #line 420 "./parser.y"
2437 {yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_DELETE_SAVEPOINT);
2438 gda_sql_statement_trans_take_name (yygotominor.yy116, yymsp[0].minor.yy0);
2439 yy_destructor(yypParser,61,&yymsp[-2].minor);
2440 yy_destructor(yypParser,60,&yymsp[-1].minor);
2441 }
2442 #line 2443 "parser.c"
2443 break;
2444 case 51: /* cmd ::= RELEASE nm */
2445 #line 424 "./parser.y"
2446 {yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_DELETE_SAVEPOINT);
2447 gda_sql_statement_trans_take_name (yygotominor.yy116, yymsp[0].minor.yy0);
2448 yy_destructor(yypParser,61,&yymsp[-1].minor);
2449 }
2450 #line 2451 "parser.c"
2451 break;
2452 case 52: /* cmd ::= ROLLBACK trans_opt_kw TO nm */
2453 #line 428 "./parser.y"
2454 {yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_ROLLBACK_SAVEPOINT);
2455 gda_sql_statement_trans_take_name (yygotominor.yy116, yymsp[0].minor.yy0);
2456 yy_destructor(yypParser,50,&yymsp[-3].minor);
2457 yy_destructor(yypParser,125,&yymsp[-1].minor);
2458 }
2459 #line 2460 "parser.c"
2460 break;
2461 case 53: /* cmd ::= ROLLBACK trans_opt_kw TO SAVEPOINT nm */
2462 #line 432 "./parser.y"
2463 {yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_ROLLBACK_SAVEPOINT);
2464 gda_sql_statement_trans_take_name (yygotominor.yy116, yymsp[0].minor.yy0);
2465 yy_destructor(yypParser,50,&yymsp[-4].minor);
2466 yy_destructor(yypParser,125,&yymsp[-2].minor);
2467 yy_destructor(yypParser,60,&yymsp[-1].minor);
2468 }
2469 #line 2470 "parser.c"
2470 break;
2471 case 54: /* cmd ::= INSERT opt_on_conflict INTO fullname inscollist_opt VALUES LP rexprlist RP */
2472 #line 439 "./parser.y"
2473 {
2474 yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_INSERT);
2475 gda_sql_statement_insert_take_table_name (yygotominor.yy116, yymsp[-5].minor.yy0);
2476 gda_sql_statement_insert_take_fields_list (yygotominor.yy116, yymsp[-4].minor.yy333);
2477 gda_sql_statement_insert_take_1_values_list (yygotominor.yy116, g_slist_reverse (yymsp[-1].minor.yy325));
2478 gda_sql_statement_insert_take_on_conflict (yygotominor.yy116, yymsp[-7].minor.yy0);
2479 yy_destructor(yypParser,126,&yymsp[-8].minor);
2480 yy_destructor(yypParser,127,&yymsp[-6].minor);
2481 yy_destructor(yypParser,128,&yymsp[-3].minor);
2482 yy_destructor(yypParser,105,&yymsp[-2].minor);
2483 yy_destructor(yypParser,106,&yymsp[0].minor);
2484 }
2485 #line 2486 "parser.c"
2486 break;
2487 case 55: /* cmd ::= INSERT opt_on_conflict INTO fullname inscollist_opt VALUES LP rexprlist RP ins_extra_values */
2488 #line 447 "./parser.y"
2489 {
2490 yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_INSERT);
2491 gda_sql_statement_insert_take_table_name (yygotominor.yy116, yymsp[-6].minor.yy0);
2492 gda_sql_statement_insert_take_fields_list (yygotominor.yy116, yymsp[-5].minor.yy333);
2493 gda_sql_statement_insert_take_1_values_list (yygotominor.yy116, g_slist_reverse (yymsp[-2].minor.yy325));
2494 gda_sql_statement_insert_take_extra_values_list (yygotominor.yy116, yymsp[0].minor.yy333);
2495 gda_sql_statement_insert_take_on_conflict (yygotominor.yy116, yymsp[-8].minor.yy0);
2496 yy_destructor(yypParser,126,&yymsp[-9].minor);
2497 yy_destructor(yypParser,127,&yymsp[-7].minor);
2498 yy_destructor(yypParser,128,&yymsp[-4].minor);
2499 yy_destructor(yypParser,105,&yymsp[-3].minor);
2500 yy_destructor(yypParser,106,&yymsp[-1].minor);
2501 }
2502 #line 2503 "parser.c"
2503 break;
2504 case 56: /* cmd ::= INSERT opt_on_conflict INTO fullname inscollist_opt compound */
2505 #line 456 "./parser.y"
2506 {
2507 yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_INSERT);
2508 gda_sql_statement_insert_take_table_name (yygotominor.yy116, yymsp[-2].minor.yy0);
2509 gda_sql_statement_insert_take_fields_list (yygotominor.yy116, yymsp[-1].minor.yy333);
2510 gda_sql_statement_insert_take_select (yygotominor.yy116, yymsp[0].minor.yy116);
2511 gda_sql_statement_insert_take_on_conflict (yygotominor.yy116, yymsp[-4].minor.yy0);
2512 yy_destructor(yypParser,126,&yymsp[-5].minor);
2513 yy_destructor(yypParser,127,&yymsp[-3].minor);
2514 }
2515 #line 2516 "parser.c"
2516 break;
2517 case 58: /* opt_on_conflict ::= OR ID */
2518 #line 466 "./parser.y"
2519 {yygotominor.yy0 = yymsp[0].minor.yy0; yy_destructor(yypParser,69,&yymsp[-1].minor);
2520 }
2521 #line 2522 "parser.c"
2522 break;
2523 case 59: /* ins_extra_values ::= ins_extra_values COMMA LP rexprlist RP */
2524 #line 476 "./parser.y"
2525 {yygotominor.yy333 = g_slist_append (yymsp[-4].minor.yy333, g_slist_reverse (yymsp[-1].minor.yy325)); yy_destructor(yypParser,123,&yymsp[-3].minor);
2526 yy_destructor(yypParser,105,&yymsp[-2].minor);
2527 yy_destructor(yypParser,106,&yymsp[0].minor);
2528 }
2529 #line 2530 "parser.c"
2530 break;
2531 case 60: /* ins_extra_values ::= COMMA LP rexprlist RP */
2532 #line 477 "./parser.y"
2533 {yygotominor.yy333 = g_slist_append (NULL, g_slist_reverse (yymsp[-1].minor.yy325)); yy_destructor(yypParser,123,&yymsp[-3].minor);
2534 yy_destructor(yypParser,105,&yymsp[-2].minor);
2535 yy_destructor(yypParser,106,&yymsp[0].minor);
2536 }
2537 #line 2538 "parser.c"
2538 break;
2539 case 61: /* inscollist_opt ::= */
2540 case 97: /* using_opt ::= */ yytestcase(yyruleno==97);
2541 #line 481 "./parser.y"
2542 {yygotominor.yy333 = NULL;}
2543 #line 2544 "parser.c"
2544 break;
2545 case 62: /* inscollist_opt ::= LP inscollist RP */
2546 #line 482 "./parser.y"
2547 {yygotominor.yy333 = yymsp[-1].minor.yy333; yy_destructor(yypParser,105,&yymsp[-2].minor);
2548 yy_destructor(yypParser,106,&yymsp[0].minor);
2549 }
2550 #line 2551 "parser.c"
2551 break;
2552 case 63: /* inscollist ::= inscollist COMMA fullname */
2553 #line 486 "./parser.y"
2554 {GdaSqlField *field;
2555 field = gda_sql_field_new (NULL);
2556 gda_sql_field_take_name (field, yymsp[0].minor.yy0);
2557 yygotominor.yy333 = g_slist_append (yymsp[-2].minor.yy333, field);
2558 yy_destructor(yypParser,123,&yymsp[-1].minor);
2559 }
2560 #line 2561 "parser.c"
2561 break;
2562 case 64: /* inscollist ::= fullname */
2563 #line 491 "./parser.y"
2564 {GdaSqlField *field = gda_sql_field_new (NULL);
2565 gda_sql_field_take_name (field, yymsp[0].minor.yy0);
2566 yygotominor.yy333 = g_slist_prepend (NULL, field);
2567 }
2568 #line 2569 "parser.c"
2569 break;
2570 case 65: /* cmd ::= DELETE FROM fullname where_opt */
2571 #line 497 "./parser.y"
2572 {yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_DELETE);
2573 gda_sql_statement_delete_take_table_name (yygotominor.yy116, yymsp[-1].minor.yy0);
2574 gda_sql_statement_delete_take_condition (yygotominor.yy116, yymsp[0].minor.yy70); yy_destructor(yypParser,129,&yymsp[-3].minor);
2575 yy_destructor(yypParser,130,&yymsp[-2].minor);
2576 }
2577 #line 2578 "parser.c"
2578 break;
2579 case 66: /* where_opt ::= */
2580 case 89: /* having_opt ::= */ yytestcase(yyruleno==89);
2581 case 101: /* on_cond ::= */ yytestcase(yyruleno==101);
2582 #line 503 "./parser.y"
2583 {yygotominor.yy70 = NULL;}
2584 #line 2585 "parser.c"
2585 break;
2586 case 67: /* where_opt ::= WHERE expr */
2587 #line 504 "./parser.y"
2588 {yygotominor.yy70 = yymsp[0].minor.yy70; yy_destructor(yypParser,131,&yymsp[-1].minor);
2589 }
2590 #line 2591 "parser.c"
2591 break;
2592 case 68: /* cmd ::= UPDATE opt_on_conflict fullname SET setlist where_opt */
2593 #line 507 "./parser.y"
2594 {
2595 GSList *list;
2596 yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_UPDATE);
2597 gda_sql_statement_update_take_table_name (yygotominor.yy116, yymsp[-3].minor.yy0);
2598 gda_sql_statement_update_take_on_conflict (yygotominor.yy116, yymsp[-4].minor.yy0);
2599 gda_sql_statement_update_take_condition (yygotominor.yy116, yymsp[0].minor.yy70);
2600 for (list = yymsp[-1].minor.yy333; list; list = list->next) {
2601 UpdateSet *set = (UpdateSet*) list->data;
2602 gda_sql_statement_update_take_set_value (yygotominor.yy116, set->fname, set->expr);
2603 g_free (set);
2604 }
2605 g_slist_free (yymsp[-1].minor.yy333);
2606 yy_destructor(yypParser,132,&yymsp[-5].minor);
2607 yy_destructor(yypParser,133,&yymsp[-2].minor);
2608 }
2609 #line 2610 "parser.c"
2610 break;
2611 case 69: /* setlist ::= setlist COMMA fullname EQ expr */
2612 #line 531 "./parser.y"
2613 {UpdateSet *set;
2614 set = g_new (UpdateSet, 1);
2615 set->fname = yymsp[-2].minor.yy0;
2616 set->expr = yymsp[0].minor.yy70;
2617 yygotominor.yy333 = g_slist_append (yymsp[-4].minor.yy333, set);
2618 yy_destructor(yypParser,123,&yymsp[-3].minor);
2619 yy_destructor(yypParser,79,&yymsp[-1].minor);
2620 }
2621 #line 2622 "parser.c"
2622 break;
2623 case 70: /* setlist ::= fullname EQ expr */
2624 #line 537 "./parser.y"
2625 {UpdateSet *set;
2626 set = g_new (UpdateSet, 1);
2627 set->fname = yymsp[-2].minor.yy0;
2628 set->expr = yymsp[0].minor.yy70;
2629 yygotominor.yy333 = g_slist_append (NULL, set);
2630 yy_destructor(yypParser,79,&yymsp[-1].minor);
2631 }
2632 #line 2633 "parser.c"
2633 break;
2634 case 71: /* compound ::= selectcmd */
2635 #line 548 "./parser.y"
2636 {
2637 yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_COMPOUND);
2638 gda_sql_statement_compound_take_stmt (yygotominor.yy116, yymsp[0].minor.yy116);
2639 }
2640 #line 2641 "parser.c"
2641 break;
2642 case 72: /* compound ::= compound UNION opt_compound_all compound */
2643 #line 552 "./parser.y"
2644 {
2645 yygotominor.yy116 = compose_multiple_compounds (yymsp[-1].minor.yy276 ? GDA_SQL_STATEMENT_COMPOUND_UNION_ALL : GDA_SQL_STATEMENT_COMPOUND_UNION,
2646 yymsp[-3].minor.yy116, yymsp[0].minor.yy116);
2647 yy_destructor(yypParser,114,&yymsp[-2].minor);
2648 }
2649 #line 2650 "parser.c"
2650 break;
2651 case 73: /* compound ::= compound EXCEPT opt_compound_all compound */
2652 #line 557 "./parser.y"
2653 {
2654 yygotominor.yy116 = compose_multiple_compounds (yymsp[-1].minor.yy276 ? GDA_SQL_STATEMENT_COMPOUND_EXCEPT_ALL : GDA_SQL_STATEMENT_COMPOUND_EXCEPT,
2655 yymsp[-3].minor.yy116, yymsp[0].minor.yy116);
2656 yy_destructor(yypParser,115,&yymsp[-2].minor);
2657 }
2658 #line 2659 "parser.c"
2659 break;
2660 case 74: /* compound ::= compound INTERSECT opt_compound_all compound */
2661 #line 562 "./parser.y"
2662 {
2663 yygotominor.yy116 = compose_multiple_compounds (yymsp[-1].minor.yy276 ? GDA_SQL_STATEMENT_COMPOUND_INTERSECT_ALL : GDA_SQL_STATEMENT_COMPOUND_INTERSECT,
2664 yymsp[-3].minor.yy116, yymsp[0].minor.yy116);
2665 yy_destructor(yypParser,116,&yymsp[-2].minor);
2666 }
2667 #line 2668 "parser.c"
2668 break;
2669 case 75: /* opt_compound_all ::= */
2670 #line 568 "./parser.y"
2671 {yygotominor.yy276 = FALSE;}
2672 #line 2673 "parser.c"
2673 break;
2674 case 76: /* opt_compound_all ::= ALL */
2675 #line 569 "./parser.y"
2676 {yygotominor.yy276 = TRUE; yy_destructor(yypParser,134,&yymsp[0].minor);
2677 }
2678 #line 2679 "parser.c"
2679 break;
2680 case 77: /* selectcmd ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
2681 #line 576 "./parser.y"
2682 {
2683 yygotominor.yy116 = gda_sql_statement_new (GDA_SQL_STATEMENT_SELECT);
2684 if (yymsp[-7].minor.yy297) {
2685 gda_sql_statement_select_take_distinct (yygotominor.yy116, yymsp[-7].minor.yy297->distinct, yymsp[-7].minor.yy297->expr);
2686 g_free (yymsp[-7].minor.yy297);
2687 }
2688 gda_sql_statement_select_take_expr_list (yygotominor.yy116, yymsp[-6].minor.yy325);
2689 gda_sql_statement_select_take_from (yygotominor.yy116, yymsp[-5].minor.yy191);
2690 gda_sql_statement_select_take_where_cond (yygotominor.yy116, yymsp[-4].minor.yy70);
2691 gda_sql_statement_select_take_group_by (yygotominor.yy116, yymsp[-3].minor.yy333);
2692 gda_sql_statement_select_take_having_cond (yygotominor.yy116, yymsp[-2].minor.yy70);
2693 gda_sql_statement_select_take_order_by (yygotominor.yy116, yymsp[-1].minor.yy325);
2694 gda_sql_statement_select_take_limits (yygotominor.yy116, yymsp[0].minor.yy44.count, yymsp[0].minor.yy44.offset);
2695 yy_destructor(yypParser,135,&yymsp[-8].minor);
2696 }
2697 #line 2698 "parser.c"
2698 break;
2699 case 78: /* limit_opt ::= */
2700 #line 593 "./parser.y"
2701 {yygotominor.yy44.count = NULL; yygotominor.yy44.offset = NULL;}
2702 #line 2703 "parser.c"
2703 break;
2704 case 79: /* limit_opt ::= LIMIT expr */
2705 #line 594 "./parser.y"
2706 {yygotominor.yy44.count = yymsp[0].minor.yy70; yygotominor.yy44.offset = NULL; yy_destructor(yypParser,136,&yymsp[-1].minor);
2707 }
2708 #line 2709 "parser.c"
2709 break;
2710 case 80: /* limit_opt ::= LIMIT expr OFFSET expr */
2711 #line 595 "./parser.y"
2712 {yygotominor.yy44.count = yymsp[-2].minor.yy70; yygotominor.yy44.offset = yymsp[0].minor.yy70; yy_destructor(yypParser,136,&yymsp[-3].minor);
2713 yy_destructor(yypParser,33,&yymsp[-1].minor);
2714 }
2715 #line 2716 "parser.c"
2716 break;
2717 case 81: /* limit_opt ::= LIMIT expr COMMA expr */
2718 #line 596 "./parser.y"
2719 {yygotominor.yy44.count = yymsp[-2].minor.yy70; yygotominor.yy44.offset = yymsp[0].minor.yy70; yy_destructor(yypParser,136,&yymsp[-3].minor);
2720 yy_destructor(yypParser,123,&yymsp[-1].minor);
2721 }
2722 #line 2723 "parser.c"
2723 break;
2724 case 82: /* orderby_opt ::= */
2725 #line 600 "./parser.y"
2726 {yygotominor.yy325 = 0;}
2727 #line 2728 "parser.c"
2728 break;
2729 case 83: /* orderby_opt ::= ORDER BY sortlist */
2730 #line 601 "./parser.y"
2731 {yygotominor.yy325 = yymsp[0].minor.yy325; yy_destructor(yypParser,137,&yymsp[-2].minor);
2732 yy_destructor(yypParser,138,&yymsp[-1].minor);
2733 }
2734 #line 2735 "parser.c"
2735 break;
2736 case 84: /* sortlist ::= sortlist COMMA expr sortorder */
2737 #line 605 "./parser.y"
2738 {GdaSqlSelectOrder *order;
2739 order = gda_sql_select_order_new (NULL);
2740 order->expr = yymsp[-1].minor.yy70;
2741 order->asc = yymsp[0].minor.yy276;
2742 yygotominor.yy325 = g_slist_append (yymsp[-3].minor.yy325, order);
2743 yy_destructor(yypParser,123,&yymsp[-2].minor);
2744 }
2745 #line 2746 "parser.c"
2746 break;
2747 case 85: /* sortlist ::= expr sortorder */
2748 #line 611 "./parser.y"
2749 {GdaSqlSelectOrder *order;
2750 order = gda_sql_select_order_new (NULL);
2751 order->expr = yymsp[-1].minor.yy70;
2752 order->asc = yymsp[0].minor.yy276;
2753 yygotominor.yy325 = g_slist_prepend (NULL, order);
2754 }
2755 #line 2756 "parser.c"
2756 break;
2757 case 86: /* sortorder ::= ASC */
2758 #line 619 "./parser.y"
2759 {yygotominor.yy276 = TRUE; yy_destructor(yypParser,5,&yymsp[0].minor);
2760 }
2761 #line 2762 "parser.c"
2762 break;
2763 case 87: /* sortorder ::= DESC */
2764 #line 620 "./parser.y"
2765 {yygotominor.yy276 = FALSE; yy_destructor(yypParser,14,&yymsp[0].minor);
2766 }
2767 #line 2768 "parser.c"
2768 break;
2769 case 88: /* sortorder ::= */
2770 #line 621 "./parser.y"
2771 {yygotominor.yy276 = TRUE;}
2772 #line 2773 "parser.c"
2773 break;
2774 case 90: /* having_opt ::= HAVING expr */
2775 #line 627 "./parser.y"
2776 {yygotominor.yy70 = yymsp[0].minor.yy70; yy_destructor(yypParser,139,&yymsp[-1].minor);
2777 }
2778 #line 2779 "parser.c"
2779 break;
2780 case 91: /* groupby_opt ::= */
2781 #line 631 "./parser.y"
2782 {yygotominor.yy333 = 0;}
2783 #line 2784 "parser.c"
2784 break;
2785 case 92: /* groupby_opt ::= GROUP BY rnexprlist */
2786 #line 632 "./parser.y"
2787 {yygotominor.yy333 = g_slist_reverse (yymsp[0].minor.yy325); yy_destructor(yypParser,140,&yymsp[-2].minor);
2788 yy_destructor(yypParser,138,&yymsp[-1].minor);
2789 }
2790 #line 2791 "parser.c"
2791 break;
2792 case 93: /* from ::= */
2793 case 98: /* stl_prefix ::= */ yytestcase(yyruleno==98);
2794 #line 636 "./parser.y"
2795 {yygotominor.yy191 = NULL;}
2796 #line 2797 "parser.c"
2797 break;
2798 case 94: /* from ::= FROM seltablist */
2799 #line 637 "./parser.y"
2800 {yygotominor.yy191 = yymsp[0].minor.yy191; yy_destructor(yypParser,130,&yymsp[-1].minor);
2801 }
2802 #line 2803 "parser.c"
2803 break;
2804 case 95: /* seltablist ::= stl_prefix seltarget on_cond using_opt */
2805 #line 644 "./parser.y"
2806 {
2807 GSList *last;
2808 if (yymsp[-3].minor.yy191)
2809 yygotominor.yy191 = yymsp[-3].minor.yy191;
2810 else
2811 yygotominor.yy191 = gda_sql_select_from_new (NULL);
2812 gda_sql_select_from_take_new_target (yygotominor.yy191, yymsp[-2].minor.yy134);
2813 last = g_slist_last (yygotominor.yy191->joins);
2814 if (last) {
2815 GdaSqlSelectJoin *join = (GdaSqlSelectJoin *) (last->data);
2816 join->expr = yymsp[-1].minor.yy70;
2817 join->position = g_slist_length (yygotominor.yy191->targets) - 1;
2818 join->use = yymsp[0].minor.yy333;
2819 }
2820 }
2821 #line 2822 "parser.c"
2822 break;
2823 case 96: /* using_opt ::= USING LP inscollist RP */
2824 #line 662 "./parser.y"
2825 {yygotominor.yy333 = yymsp[-1].minor.yy333; yy_destructor(yypParser,141,&yymsp[-3].minor);
2826 yy_destructor(yypParser,105,&yymsp[-2].minor);
2827 yy_destructor(yypParser,106,&yymsp[0].minor);
2828 }
2829 #line 2830 "parser.c"
2830 break;
2831 case 99: /* stl_prefix ::= seltablist jointype */
2832 #line 666 "./parser.y"
2833 {GdaSqlSelectJoin *join;
2834 yygotominor.yy191 = yymsp[-1].minor.yy191;
2835 join = gda_sql_select_join_new (GDA_SQL_ANY_PART (yygotominor.yy191));
2836 join->type = yymsp[0].minor.yy371;
2837 gda_sql_select_from_take_new_join (yygotominor.yy191, join);
2838 }
2839 #line 2840 "parser.c"
2840 break;
2841 case 100: /* on_cond ::= ON expr */
2842 #line 676 "./parser.y"
2843 {yygotominor.yy70 = yymsp[0].minor.yy70; yy_destructor(yypParser,142,&yymsp[-1].minor);
2844 }
2845 #line 2846 "parser.c"
2846 break;
2847 case 102: /* jointype ::= COMMA */
2848 #line 680 "./parser.y"
2849 {yygotominor.yy371 = GDA_SQL_SELECT_JOIN_CROSS; yy_destructor(yypParser,123,&yymsp[0].minor);
2850 }
2851 #line 2852 "parser.c"
2852 break;
2853 case 103: /* jointype ::= JOIN */
2854 #line 681 "./parser.y"
2855 {yygotominor.yy371 = GDA_SQL_SELECT_JOIN_INNER; yy_destructor(yypParser,107,&yymsp[0].minor);
2856 }
2857 #line 2858 "parser.c"
2858 break;
2859 case 104: /* jointype ::= CROSS JOIN */
2860 #line 682 "./parser.y"
2861 {yygotominor.yy371 = GDA_SQL_SELECT_JOIN_CROSS; yy_destructor(yypParser,113,&yymsp[-1].minor);
2862 yy_destructor(yypParser,107,&yymsp[0].minor);
2863 }
2864 #line 2865 "parser.c"
2865 break;
2866 case 105: /* jointype ::= INNER JOIN */
2867 #line 683 "./parser.y"
2868 {yygotominor.yy371 = GDA_SQL_SELECT_JOIN_INNER; yy_destructor(yypParser,108,&yymsp[-1].minor);
2869 yy_destructor(yypParser,107,&yymsp[0].minor);
2870 }
2871 #line 2872 "parser.c"
2872 break;
2873 case 106: /* jointype ::= NATURAL JOIN */
2874 #line 684 "./parser.y"
2875 {yygotominor.yy371 = GDA_SQL_SELECT_JOIN_NATURAL; yy_destructor(yypParser,109,&yymsp[-1].minor);
2876 yy_destructor(yypParser,107,&yymsp[0].minor);
2877 }
2878 #line 2879 "parser.c"
2879 break;
2880 case 107: /* jointype ::= LEFT JOIN */
2881 #line 685 "./parser.y"
2882 {yygotominor.yy371 = GDA_SQL_SELECT_JOIN_LEFT; yy_destructor(yypParser,110,&yymsp[-1].minor);
2883 yy_destructor(yypParser,107,&yymsp[0].minor);
2884 }
2885 #line 2886 "parser.c"
2886 break;
2887 case 108: /* jointype ::= LEFT OUTER JOIN */
2888 #line 686 "./parser.y"
2889 {yygotominor.yy371 = GDA_SQL_SELECT_JOIN_LEFT; yy_destructor(yypParser,110,&yymsp[-2].minor);
2890 yy_destructor(yypParser,143,&yymsp[-1].minor);
2891 yy_destructor(yypParser,107,&yymsp[0].minor);
2892 }
2893 #line 2894 "parser.c"
2894 break;
2895 case 109: /* jointype ::= RIGHT JOIN */
2896 #line 687 "./parser.y"
2897 {yygotominor.yy371 = GDA_SQL_SELECT_JOIN_RIGHT; yy_destructor(yypParser,111,&yymsp[-1].minor);
2898 yy_destructor(yypParser,107,&yymsp[0].minor);
2899 }
2900 #line 2901 "parser.c"
2901 break;
2902 case 110: /* jointype ::= RIGHT OUTER JOIN */
2903 #line 688 "./parser.y"
2904 {yygotominor.yy371 = GDA_SQL_SELECT_JOIN_RIGHT; yy_destructor(yypParser,111,&yymsp[-2].minor);
2905 yy_destructor(yypParser,143,&yymsp[-1].minor);
2906 yy_destructor(yypParser,107,&yymsp[0].minor);
2907 }
2908 #line 2909 "parser.c"
2909 break;
2910 case 111: /* jointype ::= FULL JOIN */
2911 #line 689 "./parser.y"
2912 {yygotominor.yy371 = GDA_SQL_SELECT_JOIN_FULL; yy_destructor(yypParser,112,&yymsp[-1].minor);
2913 yy_destructor(yypParser,107,&yymsp[0].minor);
2914 }
2915 #line 2916 "parser.c"
2916 break;
2917 case 112: /* jointype ::= FULL OUTER JOIN */
2918 #line 690 "./parser.y"
2919 {yygotominor.yy371 = GDA_SQL_SELECT_JOIN_FULL; yy_destructor(yypParser,112,&yymsp[-2].minor);
2920 yy_destructor(yypParser,143,&yymsp[-1].minor);
2921 yy_destructor(yypParser,107,&yymsp[0].minor);
2922 }
2923 #line 2924 "parser.c"
2924 break;
2925 case 113: /* seltarget ::= fullname as */
2926 #line 695 "./parser.y"
2927 {yygotominor.yy134 = gda_sql_select_target_new (NULL);
2928 gda_sql_select_target_take_alias (yygotominor.yy134, yymsp[0].minor.yy0);
2929 gda_sql_select_target_take_table_name (yygotominor.yy134, yymsp[-1].minor.yy0);
2930 }
2931 #line 2932 "parser.c"
2932 break;
2933 case 114: /* seltarget ::= fullname ID */
2934 #line 699 "./parser.y"
2935 {yygotominor.yy134 = gda_sql_select_target_new (NULL);
2936 gda_sql_select_target_take_alias (yygotominor.yy134, yymsp[0].minor.yy0);
2937 gda_sql_select_target_take_table_name (yygotominor.yy134, yymsp[-1].minor.yy0);
2938 }
2939 #line 2940 "parser.c"
2940 break;
2941 case 115: /* seltarget ::= LP compound RP as */
2942 case 116: /* seltarget ::= LP compound RP ID */ yytestcase(yyruleno==116);
2943 #line 703 "./parser.y"
2944 {yygotominor.yy134 = gda_sql_select_target_new (NULL);
2945 gda_sql_select_target_take_alias (yygotominor.yy134, yymsp[0].minor.yy0);
2946 gda_sql_select_target_take_select (yygotominor.yy134, yymsp[-2].minor.yy116);
2947 yy_destructor(yypParser,105,&yymsp[-3].minor);
2948 yy_destructor(yypParser,106,&yymsp[-1].minor);
2949 }
2950 #line 2951 "parser.c"
2951 break;
2952 case 117: /* sclp ::= selcollist COMMA */
2953 #line 716 "./parser.y"
2954 {yygotominor.yy325 = yymsp[-1].minor.yy325; yy_destructor(yypParser,123,&yymsp[0].minor);
2955 }
2956 #line 2957 "parser.c"
2957 break;
2958 case 118: /* sclp ::= */
2959 case 133: /* rexprlist ::= */ yytestcase(yyruleno==133);
2960 #line 717 "./parser.y"
2961 {yygotominor.yy325 = NULL;}
2962 #line 2963 "parser.c"
2963 break;
2964 case 119: /* selcollist ::= sclp expr as */
2965 #line 719 "./parser.y"
2966 {GdaSqlSelectField *field;
2967 field = gda_sql_select_field_new (NULL);
2968 gda_sql_select_field_take_expr (field, yymsp[-1].minor.yy70);
2969 gda_sql_select_field_take_alias (field, yymsp[0].minor.yy0);
2970 yygotominor.yy325 = g_slist_append (yymsp[-2].minor.yy325, field);}
2971 #line 2972 "parser.c"
2972 break;
2973 case 120: /* selcollist ::= sclp starname */
2974 #line 724 "./parser.y"
2975 {GdaSqlSelectField *field;
2976 field = gda_sql_select_field_new (NULL);
2977 gda_sql_select_field_take_star_value (field, yymsp[0].minor.yy0);
2978 yygotominor.yy325 = g_slist_append (yymsp[-1].minor.yy325, field);}
2979 #line 2980 "parser.c"
2980 break;
2981 case 122: /* starname ::= nm DOT STAR */
2982 case 198: /* fullname ::= nm DOT nm */ yytestcase(yyruleno==198);
2983 #line 730 "./parser.y"
2984 {gchar *str;
2985 str = g_strdup_printf ("%s.%s", g_value_get_string (yymsp[-2].minor.yy0), g_value_get_string (yymsp[0].minor.yy0));
2986 yygotominor.yy0 = g_new0 (GValue, 1);
2987 g_value_init (yygotominor.yy0, G_TYPE_STRING);
2988 g_value_take_string (yygotominor.yy0, str);
2989 g_value_reset (yymsp[-2].minor.yy0); g_free (yymsp[-2].minor.yy0);
2990 g_value_reset (yymsp[0].minor.yy0); g_free (yymsp[0].minor.yy0);
2991 yy_destructor(yypParser,144,&yymsp[-1].minor);
2992 }
2993 #line 2994 "parser.c"
2994 break;
2995 case 123: /* starname ::= nm DOT nm DOT STAR */
2996 case 199: /* fullname ::= nm DOT nm DOT nm */ yytestcase(yyruleno==199);
2997 #line 739 "./parser.y"
2998 {gchar *str;
2999 str = g_strdup_printf ("%s.%s.%s", g_value_get_string (yymsp[-4].minor.yy0),
3000 g_value_get_string (yymsp[-2].minor.yy0), g_value_get_string (yymsp[0].minor.yy0));
3001 yygotominor.yy0 = g_new0 (GValue, 1);
3002 g_value_init (yygotominor.yy0, G_TYPE_STRING);
3003 g_value_take_string (yygotominor.yy0, str);
3004 g_value_reset (yymsp[-4].minor.yy0); g_free (yymsp[-4].minor.yy0);
3005 g_value_reset (yymsp[-2].minor.yy0); g_free (yymsp[-2].minor.yy0);
3006 g_value_reset (yymsp[0].minor.yy0); g_free (yymsp[0].minor.yy0);
3007 yy_destructor(yypParser,144,&yymsp[-3].minor);
3008 yy_destructor(yypParser,144,&yymsp[-1].minor);
3009 }
3010 #line 3011 "parser.c"
3011 break;
3012 case 124: /* as ::= AS fullname */
3013 case 125: /* as ::= AS value */ yytestcase(yyruleno==125);
3014 #line 750 "./parser.y"
3015 {yygotominor.yy0 = yymsp[0].minor.yy0; yy_destructor(yypParser,145,&yymsp[-1].minor);
3016 }
3017 #line 3018 "parser.c"
3018 break;
3019 case 127: /* distinct ::= */
3020 #line 756 "./parser.y"
3021 {yygotominor.yy297 = NULL;}
3022 #line 3023 "parser.c"
3023 break;
3024 case 128: /* distinct ::= ALL */
3025 #line 757 "./parser.y"
3026 {yygotominor.yy297 = NULL; yy_destructor(yypParser,134,&yymsp[0].minor);
3027 }
3028 #line 3029 "parser.c"
3029 break;
3030 case 129: /* distinct ::= DISTINCT */
3031 #line 758 "./parser.y"
3032 {yygotominor.yy297 = g_new0 (Distinct, 1); yygotominor.yy297->distinct = TRUE; yy_destructor(yypParser,146,&yymsp[0].minor);
3033 }
3034 #line 3035 "parser.c"
3035 break;
3036 case 130: /* distinct ::= DISTINCT ON expr */
3037 #line 759 "./parser.y"
3038 {yygotominor.yy297 = g_new0 (Distinct, 1); yygotominor.yy297->distinct = TRUE; yygotominor.yy297->expr = yymsp[0].minor.yy70; yy_destructor(yypParser,146,&yymsp[-2].minor);
3039 yy_destructor(yypParser,142,&yymsp[-1].minor);
3040 }
3041 #line 3042 "parser.c"
3042 break;
3043 case 131: /* rnexprlist ::= rnexprlist COMMA expr */
3044 case 134: /* rexprlist ::= rexprlist COMMA expr */ yytestcase(yyruleno==134);
3045 #line 764 "./parser.y"
3046 {yygotominor.yy325 = g_slist_prepend (yymsp[-2].minor.yy325, yymsp[0].minor.yy70); yy_destructor(yypParser,123,&yymsp[-1].minor);
3047 }
3048 #line 3049 "parser.c"
3049 break;
3050 case 132: /* rnexprlist ::= expr */
3051 case 135: /* rexprlist ::= expr */ yytestcase(yyruleno==135);
3052 #line 765 "./parser.y"
3053 {yygotominor.yy325 = g_slist_append (NULL, yymsp[0].minor.yy70);}
3054 #line 3055 "parser.c"
3055 break;
3056 case 136: /* expr ::= pvalue */
3057 #line 777 "./parser.y"
3058 {yygotominor.yy70 = yymsp[0].minor.yy70;}
3059 #line 3060 "parser.c"
3060 break;
3061 case 137: /* expr ::= value */
3062 case 139: /* expr ::= fullname */ yytestcase(yyruleno==139);
3063 #line 778 "./parser.y"
3064 {yygotominor.yy70 = gda_sql_expr_new (NULL); yygotominor.yy70->value = yymsp[0].minor.yy0;}
3065 #line 3066 "parser.c"
3066 break;
3067 case 138: /* expr ::= LP expr RP */
3068 #line 779 "./parser.y"
3069 {yygotominor.yy70 = yymsp[-1].minor.yy70; yy_destructor(yypParser,105,&yymsp[-2].minor);
3070 yy_destructor(yypParser,106,&yymsp[0].minor);
3071 }
3072 #line 3073 "parser.c"
3073 break;
3074 case 140: /* expr ::= fullname LP rexprlist RP */
3075 #line 781 "./parser.y"
3076 {GdaSqlFunction *func;
3077 yygotominor.yy70 = gda_sql_expr_new (NULL);
3078 func = gda_sql_function_new (GDA_SQL_ANY_PART (yygotominor.yy70));
3079 gda_sql_function_take_name (func, yymsp[-3].minor.yy0);
3080 gda_sql_function_take_args_list (func, g_slist_reverse (yymsp[-1].minor.yy325));
3081 yygotominor.yy70->func = func; yy_destructor(yypParser,105,&yymsp[-2].minor);
3082 yy_destructor(yypParser,106,&yymsp[0].minor);
3083 }
3084 #line 3085 "parser.c"
3085 break;
3086 case 141: /* expr ::= fullname LP compound RP */
3087 #line 787 "./parser.y"
3088 {GdaSqlFunction *func;
3089 GdaSqlExpr *expr;
3090 yygotominor.yy70 = gda_sql_expr_new (NULL);
3091 func = gda_sql_function_new (GDA_SQL_ANY_PART (yygotominor.yy70));
3092 gda_sql_function_take_name (func, yymsp[-3].minor.yy0);
3093 expr = gda_sql_expr_new (GDA_SQL_ANY_PART (func));
3094 gda_sql_expr_take_select (expr, yymsp[-1].minor.yy116);
3095 gda_sql_function_take_args_list (func, g_slist_prepend (NULL, expr));
3096 yygotominor.yy70->func = func; yy_destructor(yypParser,105,&yymsp[-2].minor);
3097 yy_destructor(yypParser,106,&yymsp[0].minor);
3098 }
3099 #line 3100 "parser.c"
3100 break;
3101 case 142: /* expr ::= fullname LP starname RP */
3102 #line 796 "./parser.y"
3103 {GdaSqlFunction *func;
3104 GdaSqlExpr *expr;
3105 yygotominor.yy70 = gda_sql_expr_new (NULL);
3106 func = gda_sql_function_new (GDA_SQL_ANY_PART (yygotominor.yy70));
3107 gda_sql_function_take_name (func, yymsp[-3].minor.yy0);
3108 expr = gda_sql_expr_new (GDA_SQL_ANY_PART (func));
3109 expr->value = yymsp[-1].minor.yy0;
3110 gda_sql_function_take_args_list (func, g_slist_prepend (NULL, expr));
3111 yygotominor.yy70->func = func; yy_destructor(yypParser,105,&yymsp[-2].minor);
3112 yy_destructor(yypParser,106,&yymsp[0].minor);
3113 }
3114 #line 3115 "parser.c"
3115 break;
3116 case 143: /* expr ::= CAST LP expr AS fullname RP */
3117 #line 805 "./parser.y"
3118 {yygotominor.yy70 = yymsp[-3].minor.yy70;
3119 yymsp[-3].minor.yy70->cast_as = g_value_dup_string (yymsp[-1].minor.yy0);
3120 g_value_reset (yymsp[-1].minor.yy0);
3121 g_free (yymsp[-1].minor.yy0); yy_destructor(yypParser,10,&yymsp[-5].minor);
3122 yy_destructor(yypParser,105,&yymsp[-4].minor);
3123 yy_destructor(yypParser,145,&yymsp[-2].minor);
3124 yy_destructor(yypParser,106,&yymsp[0].minor);
3125 }
3126 #line 3127 "parser.c"
3127 break;
3128 case 144: /* expr ::= expr PGCAST fullname */
3129 #line 809 "./parser.y"
3130 {yygotominor.yy70 = yymsp[-2].minor.yy70;
3131 yymsp[-2].minor.yy70->cast_as = g_value_dup_string (yymsp[0].minor.yy0);
3132 g_value_reset (yymsp[0].minor.yy0);
3133 g_free (yymsp[0].minor.yy0); yy_destructor(yypParser,117,&yymsp[-1].minor);
3134 }
3135 #line 3136 "parser.c"
3136 break;
3137 case 145: /* expr ::= expr PLUS|MINUS expr */
3138 #line 814 "./parser.y"
3139 {yygotominor.yy70 = compose_multiple_expr (string_to_op_type (yymsp[-1].minor.yy0), yymsp[-2].minor.yy70, yymsp[0].minor.yy70);}
3140 #line 3141 "parser.c"
3141 break;
3142 case 146: /* expr ::= expr STAR expr */
3143 #line 815 "./parser.y"
3144 {yygotominor.yy70 = compose_multiple_expr (GDA_SQL_OPERATOR_TYPE_STAR, yymsp[-2].minor.yy70, yymsp[0].minor.yy70); yy_destructor(yypParser,97,&yymsp[-1].minor);
3145 }
3146 #line 3147 "parser.c"
3147 break;
3148 case 147: /* expr ::= expr SLASH|REM expr */
3149 case 148: /* expr ::= expr BITAND|BITOR expr */ yytestcase(yyruleno==148);
3150 case 154: /* expr ::= expr GT|LEQ|GEQ|LT expr */ yytestcase(yyruleno==154);
3151 case 155: /* expr ::= expr DIFF|EQ expr */ yytestcase(yyruleno==155);
3152 case 160: /* expr ::= expr REGEXP|REGEXP_CI|NOT_REGEXP|NOT_REGEXP_CI|SIMILAR expr */ yytestcase(yyruleno==160);
3153 #line 816 "./parser.y"
3154 {yygotominor.yy70 = create_two_expr (string_to_op_type (yymsp[-1].minor.yy0), yymsp[-2].minor.yy70, yymsp[0].minor.yy70);}
3155 #line 3156 "parser.c"
3156 break;
3157 case 149: /* expr ::= MINUS expr */
3158 #line 819 "./parser.y"
3159 {yygotominor.yy70 = create_uni_expr (GDA_SQL_OPERATOR_TYPE_MINUS, yymsp[0].minor.yy70); yy_destructor(yypParser,96,&yymsp[-1].minor);
3160 }
3161 #line 3162 "parser.c"
3162 break;
3163 case 150: /* expr ::= PLUS expr */
3164 #line 820 "./parser.y"
3165 {yygotominor.yy70 = create_uni_expr (GDA_SQL_OPERATOR_TYPE_PLUS, yymsp[0].minor.yy70); yy_destructor(yypParser,95,&yymsp[-1].minor);
3166 }
3167 #line 3168 "parser.c"
3168 break;
3169 case 151: /* expr ::= expr AND expr */
3170 #line 822 "./parser.y"
3171 {yygotominor.yy70 = compose_multiple_expr (GDA_SQL_OPERATOR_TYPE_AND, yymsp[-2].minor.yy70, yymsp[0].minor.yy70); yy_destructor(yypParser,70,&yymsp[-1].minor);
3172 }
3173 #line 3174 "parser.c"
3174 break;
3175 case 152: /* expr ::= expr OR expr */
3176 #line 823 "./parser.y"
3177 {yygotominor.yy70 = compose_multiple_expr (GDA_SQL_OPERATOR_TYPE_OR, yymsp[-2].minor.yy70, yymsp[0].minor.yy70); yy_destructor(yypParser,69,&yymsp[-1].minor);
3178 }
3179 #line 3180 "parser.c"
3180 break;
3181 case 153: /* expr ::= expr CONCAT expr */
3182 #line 824 "./parser.y"
3183 {yygotominor.yy70 = compose_multiple_expr (GDA_SQL_OPERATOR_TYPE_CONCAT, yymsp[-2].minor.yy70, yymsp[0].minor.yy70); yy_destructor(yypParser,100,&yymsp[-1].minor);
3184 }
3185 #line 3186 "parser.c"
3186 break;
3187 case 156: /* expr ::= expr LIKE expr */
3188 #line 828 "./parser.y"
3189 {yygotominor.yy70 = create_two_expr (GDA_SQL_OPERATOR_TYPE_LIKE, yymsp[-2].minor.yy70, yymsp[0].minor.yy70); yy_destructor(yypParser,26,&yymsp[-1].minor);
3190 }
3191 #line 3192 "parser.c"
3192 break;
3193 case 157: /* expr ::= expr ILIKE expr */
3194 #line 829 "./parser.y"
3195 {yygotominor.yy70 = create_two_expr (GDA_SQL_OPERATOR_TYPE_ILIKE, yymsp[-2].minor.yy70, yymsp[0].minor.yy70); yy_destructor(yypParser,27,&yymsp[-1].minor);
3196 }
3197 #line 3198 "parser.c"
3198 break;
3199 case 158: /* expr ::= expr NOTLIKE expr */
3200 #line 830 "./parser.y"
3201 {yygotominor.yy70 = create_two_expr (GDA_SQL_OPERATOR_TYPE_NOTLIKE, yymsp[-2].minor.yy70, yymsp[0].minor.yy70); yy_destructor(yypParser,73,&yymsp[-1].minor);
3202 }
3203 #line 3204 "parser.c"
3204 break;
3205 case 159: /* expr ::= expr NOTILIKE expr */
3206 #line 831 "./parser.y"
3207 {yygotominor.yy70 = create_two_expr (GDA_SQL_OPERATOR_TYPE_NOTILIKE, yymsp[-2].minor.yy70, yymsp[0].minor.yy70); yy_destructor(yypParser,74,&yymsp[-1].minor);
3208 }
3209 #line 3210 "parser.c"
3210 break;
3211 case 161: /* expr ::= expr BETWEEN expr AND expr */
3212 #line 833 "./parser.y"
3213 {GdaSqlOperation *cond;
3214 yygotominor.yy70 = gda_sql_expr_new (NULL);
3215 cond = gda_sql_operation_new (GDA_SQL_ANY_PART (yygotominor.yy70));
3216 yygotominor.yy70->cond = cond;
3217 cond->operator_type = GDA_SQL_OPERATOR_TYPE_BETWEEN;
3218 cond->operands = g_slist_append (NULL, yymsp[-4].minor.yy70);
3219 GDA_SQL_ANY_PART (yymsp[-4].minor.yy70)->parent = GDA_SQL_ANY_PART (cond);
3220 cond->operands = g_slist_append (cond->operands, yymsp[-2].minor.yy70);
3221 GDA_SQL_ANY_PART (yymsp[-2].minor.yy70)->parent = GDA_SQL_ANY_PART (cond);
3222 cond->operands = g_slist_append (cond->operands, yymsp[0].minor.yy70);
3223 GDA_SQL_ANY_PART (yymsp[0].minor.yy70)->parent = GDA_SQL_ANY_PART (cond);
3224 yy_destructor(yypParser,80,&yymsp[-3].minor);
3225 yy_destructor(yypParser,70,&yymsp[-1].minor);
3226 }
3227 #line 3228 "parser.c"
3228 break;
3229 case 162: /* expr ::= expr NOT BETWEEN expr AND expr */
3230 #line 846 "./parser.y"
3231 {GdaSqlOperation *cond;
3232 GdaSqlExpr *expr;
3233 expr = gda_sql_expr_new (NULL);
3234 cond = gda_sql_operation_new (GDA_SQL_ANY_PART (expr));
3235 expr->cond = cond;
3236 cond->operator_type = GDA_SQL_OPERATOR_TYPE_BETWEEN;
3237 cond->operands = g_slist_append (NULL, yymsp[-5].minor.yy70);
3238 GDA_SQL_ANY_PART (yymsp[-5].minor.yy70)->parent = GDA_SQL_ANY_PART (cond);
3239 cond->operands = g_slist_append (cond->operands, yymsp[-2].minor.yy70);
3240 GDA_SQL_ANY_PART (yymsp[-2].minor.yy70)->parent = GDA_SQL_ANY_PART (cond);
3241 cond->operands = g_slist_append (cond->operands, yymsp[0].minor.yy70);
3242 GDA_SQL_ANY_PART (yymsp[0].minor.yy70)->parent = GDA_SQL_ANY_PART (cond);
3243
3244 yygotominor.yy70 = gda_sql_expr_new (NULL);
3245 cond = gda_sql_operation_new (GDA_SQL_ANY_PART (yygotominor.yy70));
3246 yygotominor.yy70->cond = cond;
3247 cond->operator_type = GDA_SQL_OPERATOR_TYPE_NOT;
3248 cond->operands = g_slist_prepend (NULL, expr);
3249 GDA_SQL_ANY_PART (expr)->parent = GDA_SQL_ANY_PART (cond);
3250 yy_destructor(yypParser,71,&yymsp[-4].minor);
3251 yy_destructor(yypParser,80,&yymsp[-3].minor);
3252 yy_destructor(yypParser,70,&yymsp[-1].minor);
3253 }
3254 #line 3255 "parser.c"
3255 break;
3256 case 163: /* expr ::= NOT expr */
3257 #line 867 "./parser.y"
3258 {yygotominor.yy70 = create_uni_expr (GDA_SQL_OPERATOR_TYPE_NOT, yymsp[0].minor.yy70); yy_destructor(yypParser,71,&yymsp[-1].minor);
3259 }
3260 #line 3261 "parser.c"
3261 break;
3262 case 164: /* expr ::= BITNOT expr */
3263 #line 868 "./parser.y"
3264 {yygotominor.yy70 = create_uni_expr (GDA_SQL_OPERATOR_TYPE_BITNOT, yymsp[0].minor.yy70); yy_destructor(yypParser,104,&yymsp[-1].minor);
3265 }
3266 #line 3267 "parser.c"
3267 break;
3268 case 165: /* expr ::= expr uni_op */
3269 #line 869 "./parser.y"
3270 {yygotominor.yy70 = create_uni_expr (yymsp[0].minor.yy147, yymsp[-1].minor.yy70);}
3271 #line 3272 "parser.c"
3272 break;
3273 case 166: /* expr ::= expr IS expr */
3274 #line 871 "./parser.y"
3275 {yygotominor.yy70 = create_two_expr (GDA_SQL_OPERATOR_TYPE_IS, yymsp[-2].minor.yy70, yymsp[0].minor.yy70); yy_destructor(yypParser,72,&yymsp[-1].minor);
3276 }
3277 #line 3278 "parser.c"
3278 break;
3279 case 167: /* expr ::= LP compound RP */
3280 #line 872 "./parser.y"
3281 {yygotominor.yy70 = gda_sql_expr_new (NULL); gda_sql_expr_take_select (yygotominor.yy70, yymsp[-1].minor.yy116); yy_destructor(yypParser,105,&yymsp[-2].minor);
3282 yy_destructor(yypParser,106,&yymsp[0].minor);
3283 }
3284 #line 3285 "parser.c"
3285 break;
3286 case 168: /* expr ::= expr IN LP rexprlist RP */
3287 #line 873 "./parser.y"
3288 {GdaSqlOperation *cond;
3289 GSList *list;
3290 yygotominor.yy70 = gda_sql_expr_new (NULL);
3291 cond = gda_sql_operation_new (GDA_SQL_ANY_PART (yygotominor.yy70));
3292 yygotominor.yy70->cond = cond;
3293 cond->operator_type = GDA_SQL_OPERATOR_TYPE_IN;
3294 cond->operands = g_slist_prepend (g_slist_reverse (yymsp[-1].minor.yy325), yymsp[-4].minor.yy70);
3295 for (list = cond->operands; list; list = list->next)
3296 GDA_SQL_ANY_PART (list->data)->parent = GDA_SQL_ANY_PART (cond);
3297 yy_destructor(yypParser,75,&yymsp[-3].minor);
3298 yy_destructor(yypParser,105,&yymsp[-2].minor);
3299 yy_destructor(yypParser,106,&yymsp[0].minor);
3300 }
3301 #line 3302 "parser.c"
3302 break;
3303 case 169: /* expr ::= expr IN LP compound RP */
3304 #line 883 "./parser.y"
3305 {GdaSqlOperation *cond;
3306 GdaSqlExpr *expr;
3307 yygotominor.yy70 = gda_sql_expr_new (NULL);
3308 cond = gda_sql_operation_new (GDA_SQL_ANY_PART (yygotominor.yy70));
3309 yygotominor.yy70->cond = cond;
3310 cond->operator_type = GDA_SQL_OPERATOR_TYPE_IN;
3311
3312 expr = gda_sql_expr_new (GDA_SQL_ANY_PART (cond));
3313 gda_sql_expr_take_select (expr, yymsp[-1].minor.yy116);
3314 cond->operands = g_slist_prepend (NULL, expr);
3315 cond->operands = g_slist_prepend (cond->operands, yymsp[-4].minor.yy70);
3316 GDA_SQL_ANY_PART (yymsp[-4].minor.yy70)->parent = GDA_SQL_ANY_PART (cond);
3317 yy_destructor(yypParser,75,&yymsp[-3].minor);
3318 yy_destructor(yypParser,105,&yymsp[-2].minor);
3319 yy_destructor(yypParser,106,&yymsp[0].minor);
3320 }
3321 #line 3322 "parser.c"
3322 break;
3323 case 170: /* expr ::= expr NOT IN LP rexprlist RP */
3324 #line 896 "./parser.y"
3325 {GdaSqlOperation *cond;
3326 GSList *list;
3327 yygotominor.yy70 = gda_sql_expr_new (NULL);
3328 cond = gda_sql_operation_new (GDA_SQL_ANY_PART (yygotominor.yy70));
3329 yygotominor.yy70->cond = cond;
3330 cond->operator_type = GDA_SQL_OPERATOR_TYPE_NOTIN;
3331 cond->operands = g_slist_prepend (g_slist_reverse (yymsp[-1].minor.yy325), yymsp[-5].minor.yy70);
3332 for (list = cond->operands; list; list = list->next)
3333 GDA_SQL_ANY_PART (list->data)->parent = GDA_SQL_ANY_PART (cond);
3334 yy_destructor(yypParser,71,&yymsp[-4].minor);
3335 yy_destructor(yypParser,75,&yymsp[-3].minor);
3336 yy_destructor(yypParser,105,&yymsp[-2].minor);
3337 yy_destructor(yypParser,106,&yymsp[0].minor);
3338 }
3339 #line 3340 "parser.c"
3340 break;
3341 case 171: /* expr ::= expr NOT IN LP compound RP */
3342 #line 906 "./parser.y"
3343 {GdaSqlOperation *cond;
3344 GdaSqlExpr *expr;
3345 yygotominor.yy70 = gda_sql_expr_new (NULL);
3346 cond = gda_sql_operation_new (GDA_SQL_ANY_PART (yygotominor.yy70));
3347 yygotominor.yy70->cond = cond;
3348 cond->operator_type = GDA_SQL_OPERATOR_TYPE_NOTIN;
3349
3350 expr = gda_sql_expr_new (GDA_SQL_ANY_PART (cond));
3351 gda_sql_expr_take_select (expr, yymsp[-1].minor.yy116);
3352 cond->operands = g_slist_prepend (NULL, expr);
3353 cond->operands = g_slist_prepend (cond->operands, yymsp[-5].minor.yy70);
3354 GDA_SQL_ANY_PART (yymsp[-5].minor.yy70)->parent = GDA_SQL_ANY_PART (cond);
3355 yy_destructor(yypParser,71,&yymsp[-4].minor);
3356 yy_destructor(yypParser,75,&yymsp[-3].minor);
3357 yy_destructor(yypParser,105,&yymsp[-2].minor);
3358 yy_destructor(yypParser,106,&yymsp[0].minor);
3359 }
3360 #line 3361 "parser.c"
3361 break;
3362 case 172: /* expr ::= CASE case_operand case_exprlist case_else END */
3363 #line 919 "./parser.y"
3364 {
3365 GdaSqlCase *sc;
3366 GSList *list;
3367 yygotominor.yy70 = gda_sql_expr_new (NULL);
3368 sc = gda_sql_case_new (GDA_SQL_ANY_PART (yygotominor.yy70));
3369 sc->base_expr = yymsp[-3].minor.yy146;
3370 sc->else_expr = yymsp[-1].minor.yy146;
3371 sc->when_expr_list = yymsp[-2].minor.yy59.when_list;
3372 sc->then_expr_list = yymsp[-2].minor.yy59.then_list;
3373 yygotominor.yy70->case_s = sc;
3374 for (list = sc->when_expr_list; list; list = list->next)
3375 GDA_SQL_ANY_PART (list->data)->parent = GDA_SQL_ANY_PART (sc);
3376 for (list = sc->then_expr_list; list; list = list->next)
3377 GDA_SQL_ANY_PART (list->data)->parent = GDA_SQL_ANY_PART (sc);
3378 yy_destructor(yypParser,147,&yymsp[-4].minor);
3379 yy_destructor(yypParser,17,&yymsp[0].minor);
3380 }
3381 #line 3382 "parser.c"
3382 break;
3383 case 173: /* case_operand ::= expr */
3384 #line 937 "./parser.y"
3385 {yygotominor.yy146 = yymsp[0].minor.yy70;}
3386 #line 3387 "parser.c"
3387 break;
3388 case 174: /* case_operand ::= */
3389 case 178: /* case_else ::= */ yytestcase(yyruleno==178);
3390 #line 938 "./parser.y"
3391 {yygotominor.yy146 = NULL;}
3392 #line 3393 "parser.c"
3393 break;
3394 case 175: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
3395 #line 944 "./parser.y"
3396 {
3397 yygotominor.yy59.when_list = g_slist_append (yymsp[-4].minor.yy59.when_list, yymsp[-2].minor.yy70);
3398 yygotominor.yy59.then_list = g_slist_append (yymsp[-4].minor.yy59.then_list, yymsp[0].minor.yy70);
3399 yy_destructor(yypParser,148,&yymsp[-3].minor);
3400 yy_destructor(yypParser,149,&yymsp[-1].minor);
3401 }
3402 #line 3403 "parser.c"
3403 break;
3404 case 176: /* case_exprlist ::= WHEN expr THEN expr */
3405 #line 948 "./parser.y"
3406 {
3407 yygotominor.yy59.when_list = g_slist_prepend (NULL, yymsp[-2].minor.yy70);
3408 yygotominor.yy59.then_list = g_slist_prepend (NULL, yymsp[0].minor.yy70);
3409 yy_destructor(yypParser,148,&yymsp[-3].minor);
3410 yy_destructor(yypParser,149,&yymsp[-1].minor);
3411 }
3412 #line 3413 "parser.c"
3413 break;
3414 case 177: /* case_else ::= ELSE expr */
3415 #line 955 "./parser.y"
3416 {yygotominor.yy146 = yymsp[0].minor.yy70; yy_destructor(yypParser,150,&yymsp[-1].minor);
3417 }
3418 #line 3419 "parser.c"
3419 break;
3420 case 179: /* uni_op ::= ISNULL */
3421 #line 959 "./parser.y"
3422 {yygotominor.yy147 = GDA_SQL_OPERATOR_TYPE_ISNULL; yy_destructor(yypParser,76,&yymsp[0].minor);
3423 }
3424 #line 3425 "parser.c"
3425 break;
3426 case 180: /* uni_op ::= IS NOTNULL */
3427 #line 960 "./parser.y"
3428 {yygotominor.yy147 = GDA_SQL_OPERATOR_TYPE_ISNOTNULL; yy_destructor(yypParser,72,&yymsp[-1].minor);
3429 yy_destructor(yypParser,77,&yymsp[0].minor);
3430 }
3431 #line 3432 "parser.c"
3432 break;
3433 case 181: /* value ::= NULL */
3434 #line 964 "./parser.y"
3435 {yygotominor.yy0 = NULL; yy_destructor(yypParser,151,&yymsp[0].minor);
3436 }
3437 #line 3438 "parser.c"
3438 break;
3439 case 185: /* pvalue ::= UNSPECVAL LSBRACKET paramspec RSBRACKET */
3440 #line 973 "./parser.y"
3441 {yygotominor.yy70 = gda_sql_expr_new (NULL); yygotominor.yy70->param_spec = yymsp[-1].minor.yy339; yy_destructor(yypParser,153,&yymsp[-3].minor);
3442 yy_destructor(yypParser,154,&yymsp[-2].minor);
3443 yy_destructor(yypParser,155,&yymsp[0].minor);
3444 }
3445 #line 3446 "parser.c"
3446 break;
3447 case 186: /* pvalue ::= value LSBRACKET paramspec RSBRACKET */
3448 #line 974 "./parser.y"
3449 {yygotominor.yy70 = gda_sql_expr_new (NULL); yygotominor.yy70->value = yymsp[-3].minor.yy0; yygotominor.yy70->param_spec = yymsp[-1].minor.yy339; yy_destructor(yypParser,154,&yymsp[-2].minor);
3450 yy_destructor(yypParser,155,&yymsp[0].minor);
3451 }
3452 #line 3453 "parser.c"
3453 break;
3454 case 187: /* pvalue ::= SIMPLEPARAM */
3455 #line 975 "./parser.y"
3456 {yygotominor.yy70 = gda_sql_expr_new (NULL); yygotominor.yy70->param_spec = gda_sql_param_spec_new (yymsp[0].minor.yy0);}
3457 #line 3458 "parser.c"
3458 break;
3459 case 188: /* paramspec ::= */
3460 #line 980 "./parser.y"
3461 {yygotominor.yy339 = NULL;}
3462 #line 3463 "parser.c"
3463 break;
3464 case 189: /* paramspec ::= paramspec PNAME */
3465 #line 981 "./parser.y"
3466 {if (!yymsp[-1].minor.yy339) yygotominor.yy339 = gda_sql_param_spec_new (NULL); else yygotominor.yy339 = yymsp[-1].minor.yy339;
3467 gda_sql_param_spec_take_name (yygotominor.yy339, yymsp[0].minor.yy0);}
3468 #line 3469 "parser.c"
3469 break;
3470 case 190: /* paramspec ::= paramspec PDESCR */
3471 #line 983 "./parser.y"
3472 {if (!yymsp[-1].minor.yy339) yygotominor.yy339 = gda_sql_param_spec_new (NULL); else yygotominor.yy339 = yymsp[-1].minor.yy339;
3473 gda_sql_param_spec_take_descr (yygotominor.yy339, yymsp[0].minor.yy0);}
3474 #line 3475 "parser.c"
3475 break;
3476 case 191: /* paramspec ::= paramspec PTYPE */
3477 #line 985 "./parser.y"
3478 {if (!yymsp[-1].minor.yy339) yygotominor.yy339 = gda_sql_param_spec_new (NULL); else yygotominor.yy339 = yymsp[-1].minor.yy339;
3479 gda_sql_param_spec_take_type (yygotominor.yy339, yymsp[0].minor.yy0);}
3480 #line 3481 "parser.c"
3481 break;
3482 case 192: /* paramspec ::= paramspec PNULLOK */
3483 #line 987 "./parser.y"
3484 {if (!yymsp[-1].minor.yy339) yygotominor.yy339 = gda_sql_param_spec_new (NULL); else yygotominor.yy339 = yymsp[-1].minor.yy339;
3485 gda_sql_param_spec_take_nullok (yygotominor.yy339, yymsp[0].minor.yy0);}
3486 #line 3487 "parser.c"
3487 break;
3488 default:
3489 /* (34) trans_opt_kw ::= */ yytestcase(yyruleno==34);
3490 /* (36) opt_comma ::= */ yytestcase(yyruleno==36);
3491 break;
3492 };
3493 yygoto = yyRuleInfo[yyruleno].lhs;
3494 yysize = yyRuleInfo[yyruleno].nrhs;
3495 yypParser->yyidx -= yysize;
3496 yyact = yy_find_reduce_action(yymsp[-yysize].stateno,(YYCODETYPE)yygoto);
3497 if( yyact < YYNSTATE ){
3498 #ifdef NDEBUG
3499 /* If we are not debugging and the reduce action popped at least
3500 ** one element off the stack, then we can push the new element back
3501 ** onto the stack here, and skip the stack overflow test in yy_shift().
3502 ** That gives a significant speed improvement. */
3503 if( yysize ){
3504 yypParser->yyidx++;
3505 yymsp -= yysize-1;
3506 yymsp->stateno = (YYACTIONTYPE)yyact;
3507 yymsp->major = (YYCODETYPE)yygoto;
3508 yymsp->minor = yygotominor;
3509 }else
3510 #endif
3511 {
3512 yy_shift(yypParser,yyact,yygoto,&yygotominor);
3513 }
3514 }else{
3515 assert( yyact == YYNSTATE + YYNRULE + 1 );
3516 yy_accept(yypParser);
3517 }
3518 }
3519
3520 /*
3521 ** The following code executes when the parse fails
3522 */
3523 #ifndef YYNOERRORRECOVERY
yy_parse_failed(yyParser * yypParser)3524 static void yy_parse_failed(
3525 yyParser *yypParser /* The parser */
3526 ){
3527 priv_gda_sql_parserARG_FETCH;
3528 #ifndef NDEBUG
3529 if( yyTraceFILE ){
3530 fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt);
3531 }
3532 #endif
3533 while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
3534 /* Here code is inserted which will be executed whenever the
3535 ** parser fails */
3536 priv_gda_sql_parserARG_STORE; /* Suppress warning about unused %extra_argument variable */
3537 }
3538 #endif /* YYNOERRORRECOVERY */
3539
3540 /*
3541 ** The following code executes when a syntax error first occurs.
3542 */
yy_syntax_error(yyParser * yypParser,int yymajor,YYMINORTYPE yyminor)3543 static void yy_syntax_error(
3544 yyParser *yypParser, /* The parser */
3545 int yymajor, /* The major type of the error token */
3546 YYMINORTYPE yyminor /* The minor type of the error token */
3547 ){
3548 priv_gda_sql_parserARG_FETCH;
3549 #define TOKEN (yyminor.yy0)
3550 #line 22 "./parser.y"
3551
3552 gda_sql_parser_set_syntax_error (pdata->parser);
3553 #line 3554 "parser.c"
3554 priv_gda_sql_parserARG_STORE; /* Suppress warning about unused %extra_argument variable */
3555 }
3556
3557 /*
3558 ** The following is executed when the parser accepts
3559 */
yy_accept(yyParser * yypParser)3560 static void yy_accept(
3561 yyParser *yypParser /* The parser */
3562 ){
3563 priv_gda_sql_parserARG_FETCH;
3564 #ifndef NDEBUG
3565 if( yyTraceFILE ){
3566 fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt);
3567 }
3568 #endif
3569 while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
3570 /* Here code is inserted which will be executed whenever the
3571 ** parser accepts */
3572 priv_gda_sql_parserARG_STORE; /* Suppress warning about unused %extra_argument variable */
3573 }
3574
3575 /* The main parser program.
3576 ** The first argument is a pointer to a structure obtained from
3577 ** "priv_gda_sql_parserAlloc" which describes the current state of the parser.
3578 ** The second argument is the major token number. The third is
3579 ** the minor token. The fourth optional argument is whatever the
3580 ** user wants (and specified in the grammar) and is available for
3581 ** use by the action routines.
3582 **
3583 ** Inputs:
3584 ** <ul>
3585 ** <li> A pointer to the parser (an opaque structure.)
3586 ** <li> The major token number.
3587 ** <li> The minor token number.
3588 ** <li> An option argument of a grammar-specified type.
3589 ** </ul>
3590 **
3591 ** Outputs:
3592 ** None.
3593 */
priv_gda_sql_parser(void * yyp,int yymajor,priv_gda_sql_parserTOKENTYPE yyminor priv_gda_sql_parserARG_PDECL)3594 void priv_gda_sql_parser(
3595 void *yyp, /* The parser */
3596 int yymajor, /* The major token code number */
3597 priv_gda_sql_parserTOKENTYPE yyminor /* The value for the token */
3598 priv_gda_sql_parserARG_PDECL /* Optional %extra_argument parameter */
3599 ){
3600 YYMINORTYPE yyminorunion;
3601 int yyact; /* The parser action. */
3602 int yyendofinput; /* True if we are at the end of input */
3603 #ifdef YYERRORSYMBOL
3604 int yyerrorhit = 0; /* True if yymajor has invoked an error */
3605 #endif
3606 yyParser *yypParser; /* The parser */
3607
3608 /* (re)initialize the parser, if necessary */
3609 yypParser = (yyParser*)yyp;
3610 if( yypParser->yyidx<0 ){
3611 #if YYSTACKDEPTH<=0
3612 if( yypParser->yystksz <=0 ){
3613 /*memset(&yyminorunion, 0, sizeof(yyminorunion));*/
3614 yyminorunion = yyzerominor;
3615 yyStackOverflow(yypParser, &yyminorunion);
3616 return;
3617 }
3618 #endif
3619 yypParser->yyidx = 0;
3620 yypParser->yyerrcnt = -1;
3621 yypParser->yystack[0].stateno = 0;
3622 yypParser->yystack[0].major = 0;
3623 }
3624 yyminorunion.yy0 = yyminor;
3625 yyendofinput = (yymajor==0);
3626 priv_gda_sql_parserARG_STORE;
3627
3628 #ifndef NDEBUG
3629 if( yyTraceFILE ){
3630 fprintf(yyTraceFILE,"%sInput %s\n",yyTracePrompt,yyTokenName[yymajor]);
3631 }
3632 #endif
3633
3634 do{
3635 yyact = yy_find_shift_action(yypParser,(YYCODETYPE)yymajor);
3636 if( yyact<YYNSTATE ){
3637 assert( !yyendofinput ); /* Impossible to shift the $ token */
3638 yy_shift(yypParser,yyact,yymajor,&yyminorunion);
3639 yypParser->yyerrcnt--;
3640 yymajor = YYNOCODE;
3641 }else if( yyact < YYNSTATE + YYNRULE ){
3642 yy_reduce(yypParser,yyact-YYNSTATE);
3643 }else{
3644 assert( yyact == YY_ERROR_ACTION );
3645 #ifdef YYERRORSYMBOL
3646 int yymx;
3647 #endif
3648 #ifndef NDEBUG
3649 if( yyTraceFILE ){
3650 fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt);
3651 }
3652 #endif
3653 #ifdef YYERRORSYMBOL
3654 /* A syntax error has occurred.
3655 ** The response to an error depends upon whether or not the
3656 ** grammar defines an error token "ERROR".
3657 **
3658 ** This is what we do if the grammar does define ERROR:
3659 **
3660 ** * Call the %syntax_error function.
3661 **
3662 ** * Begin popping the stack until we enter a state where
3663 ** it is legal to shift the error symbol, then shift
3664 ** the error symbol.
3665 **
3666 ** * Set the error count to three.
3667 **
3668 ** * Begin accepting and shifting new tokens. No new error
3669 ** processing will occur until three tokens have been
3670 ** shifted successfully.
3671 **
3672 */
3673 if( yypParser->yyerrcnt<0 ){
3674 yy_syntax_error(yypParser,yymajor,yyminorunion);
3675 }
3676 yymx = yypParser->yystack[yypParser->yyidx].major;
3677 if( yymx==YYERRORSYMBOL || yyerrorhit ){
3678 #ifndef NDEBUG
3679 if( yyTraceFILE ){
3680 fprintf(yyTraceFILE,"%sDiscard input token %s\n",
3681 yyTracePrompt,yyTokenName[yymajor]);
3682 }
3683 #endif
3684 yy_destructor(yypParser, (YYCODETYPE)yymajor,&yyminorunion);
3685 yymajor = YYNOCODE;
3686 }else{
3687 while(
3688 yypParser->yyidx >= 0 &&
3689 yymx != YYERRORSYMBOL &&
3690 (yyact = yy_find_reduce_action(
3691 yypParser->yystack[yypParser->yyidx].stateno,
3692 YYERRORSYMBOL)) >= YYNSTATE
3693 ){
3694 yy_pop_parser_stack(yypParser);
3695 }
3696 if( yypParser->yyidx < 0 || yymajor==0 ){
3697 yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
3698 yy_parse_failed(yypParser);
3699 yymajor = YYNOCODE;
3700 }else if( yymx!=YYERRORSYMBOL ){
3701 YYMINORTYPE u2;
3702 u2.YYERRSYMDT = 0;
3703 yy_shift(yypParser,yyact,YYERRORSYMBOL,&u2);
3704 }
3705 }
3706 yypParser->yyerrcnt = 3;
3707 yyerrorhit = 1;
3708 #elif defined(YYNOERRORRECOVERY)
3709 /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
3710 ** do any kind of error recovery. Instead, simply invoke the syntax
3711 ** error routine and continue going as if nothing had happened.
3712 **
3713 ** Applications can set this macro (for example inside %include) if
3714 ** they intend to abandon the parse upon the first syntax error seen.
3715 */
3716 yy_syntax_error(yypParser,yymajor,yyminorunion);
3717 yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
3718 yymajor = YYNOCODE;
3719
3720 #else /* YYERRORSYMBOL is not defined */
3721 /* This is what we do if the grammar does not define ERROR:
3722 **
3723 ** * Report an error message, and throw away the input token.
3724 **
3725 ** * If the input token is $, then fail the parse.
3726 **
3727 ** As before, subsequent error messages are suppressed until
3728 ** three input tokens have been successfully shifted.
3729 */
3730 if( yypParser->yyerrcnt<=0 ){
3731 yy_syntax_error(yypParser,yymajor,yyminorunion);
3732 }
3733 yypParser->yyerrcnt = 3;
3734 yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
3735 if( yyendofinput ){
3736 yy_parse_failed(yypParser);
3737 }
3738 yymajor = YYNOCODE;
3739 #endif
3740 }
3741 }while( yymajor!=YYNOCODE && yypParser->yyidx>=0 );
3742 return;
3743 }
3744