Mercurial > audlegacy

comparison sqlite/parse.c @ 1434:b6b61becdf4e trunk

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