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