wasCSharpSQLite – Blame information for rev 4

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