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