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