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