| blob | ab5a2d2cd1425f09c5a3968a16fb4fd6cbc45bbf |
1 /*
2 ** 2000-05-29
3 **
4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
6 **
7 ** May you do good and not evil.
8 ** May you find forgiveness for yourself and forgive others.
9 ** May you share freely, never taking more than you give.
10 **
11 *************************************************************************
12 ** Driver template for the LEMON parser generator.
13 **
14 ** Synced with upstream:
15 ** https://www.sqlite.org/src/artifact/468a155e8729cfbccfe1d85bf60d064f1dab76167a51149ec5c7928a2de63953
16 **
17 ** The "lemon" program processes an LALR(1) input grammar file, then uses
18 ** this template to construct a parser. The "lemon" program inserts text
19 ** at each "%%" line. Also, any "P-a-r-s-e" identifier prefix (without the
20 ** interstitial "-" characters) contained in this template is changed into
21 ** the value of the %name directive from the grammar. Otherwise, the content
22 ** of this template is copied straight through into the generate parser
23 ** source file.
24 **
25 ** The following is the concatenation of all %include directives from the
26 ** input grammar file:
27 */
28 /************ Begin %include sections from the grammar ************************/
29 %%
30 /**************** End of %include directives **********************************/
31 /* These constants specify the various numeric values for terminal symbols
32 ** in a format understandable to "makeheaders". This section is blank unless
33 ** "lemon" is run with the "-m" command-line option.
34 ***************** Begin makeheaders token definitions *************************/
35 %%
36 /**************** End makeheaders token definitions ***************************/
38 /* The next section is a series of control #defines.
39 ** various aspects of the generated parser.
40 ** YYCODETYPE is the data type used to store the integer codes
41 ** that represent terminal and non-terminal symbols.
42 ** "unsigned char" is used if there are fewer than
43 ** 256 symbols. Larger types otherwise.
44 ** YYNOCODE is a number of type YYCODETYPE that is not used for
45 ** any terminal or nonterminal symbol.
46 ** YYFALLBACK If defined, this indicates that one or more tokens
47 ** (also known as: "terminal symbols") have fall-back
48 ** values which should be used if the original symbol
49 ** would not parse. This permits keywords to sometimes
50 ** be used as identifiers, for example.
51 ** YYACTIONTYPE is the data type used for "action codes" - numbers
52 ** that indicate what to do in response to the next
53 ** token.
54 ** ParseTOKENTYPE is the data type used for minor type for terminal
55 ** symbols. Background: A "minor type" is a semantic
56 ** value associated with a terminal or non-terminal
57 ** symbols. For example, for an "ID" terminal symbol,
58 ** the minor type might be the name of the identifier.
59 ** Each non-terminal can have a different minor type.
60 ** Terminal symbols all have the same minor type, though.
61 ** This macros defines the minor type for terminal
62 ** symbols.
63 ** YYMINORTYPE is the data type used for all minor types.
64 ** This is typically a union of many types, one of
65 ** which is ParseTOKENTYPE. The entry in the union
66 ** for terminal symbols is called "yy0".
67 ** YYSTACKDEPTH is the maximum depth of the parser's stack. If
68 ** zero the stack is dynamically sized using realloc()
69 ** ParseARG_SDECL A static variable declaration for the %extra_argument
70 ** ParseARG_PDECL A parameter declaration for the %extra_argument
71 ** ParseARG_STORE Code to store %extra_argument into yypParser
72 ** ParseARG_FETCH Code to extract %extra_argument from yypParser
73 ** YYERRORSYMBOL is the code number of the error symbol. If not
74 ** defined, then do no error processing.
75 ** YYNSTATE the combined number of states.
76 ** YYNRULE the number of rules in the grammar
77 ** YYNTOKEN Number of terminal symbols
78 ** YY_MAX_SHIFT Maximum value for shift actions
79 ** YY_MIN_SHIFTREDUCE Minimum value for shift-reduce actions
80 ** YY_MAX_SHIFTREDUCE Maximum value for shift-reduce actions
81 ** YY_ERROR_ACTION The yy_action[] code for syntax error
82 ** YY_ACCEPT_ACTION The yy_action[] code for accept
83 ** YY_NO_ACTION The yy_action[] code for no-op
84 ** YY_MIN_REDUCE Minimum value for reduce actions
85 ** YY_MAX_REDUCE Maximum value for reduce actions
86 */
87 #ifndef INTERFACE
88 # define INTERFACE 1
89 #endif
90 /************* Begin control #defines *****************************************/
91 %%
92 /************* End control #defines *******************************************/
94 /* Define the yytestcase() macro to be a no-op if is not already defined
95 ** otherwise.
96 **
97 ** Applications can choose to define yytestcase() in the %include section
98 ** to a macro that can assist in verifying code coverage. For production
99 ** code the yytestcase() macro should be turned off. But it is useful
100 ** for testing.
101 */
102 #ifndef yytestcase
103 # define yytestcase(X)
104 #endif
107 /* Next are the tables used to determine what action to take based on the
108 ** current state and lookahead token. These tables are used to implement
109 ** functions that take a state number and lookahead value and return an
110 ** action integer.
111 **
112 ** Suppose the action integer is N. Then the action is determined as
113 ** follows
114 **
115 ** 0 <= N <= YY_MAX_SHIFT Shift N. That is, push the lookahead
116 ** token onto the stack and goto state N.
117 **
118 ** N between YY_MIN_SHIFTREDUCE Shift to an arbitrary state then
119 ** and YY_MAX_SHIFTREDUCE reduce by rule N-YY_MIN_SHIFTREDUCE.
120 **
121 ** N == YY_ERROR_ACTION A syntax error has occurred.
122 **
123 ** N == YY_ACCEPT_ACTION The parser accepts its input.
124 **
125 ** N == YY_NO_ACTION No such action. Denotes unused
126 ** slots in the yy_action[] table.
127 **
128 ** N between YY_MIN_REDUCE Reduce by rule N-YY_MIN_REDUCE
129 ** and YY_MAX_REDUCE
130 **
131 ** The action table is constructed as a single large table named yy_action[].
132 ** Given state S and lookahead X, the action is computed as either:
133 **
134 ** (A) N = yy_action[ yy_shift_ofst[S] + X ]
135 ** (B) N = yy_default[S]
136 **
137 ** The (A) formula is preferred. The B formula is used instead if
138 ** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X.
139 **
140 ** The formulas above are for computing the action when the lookahead is
141 ** a terminal symbol. If the lookahead is a non-terminal (as occurs after
142 ** a reduce action) then the yy_reduce_ofst[] array is used in place of
143 ** the yy_shift_ofst[] array.
144 **
145 ** The following are the tables generated in this section:
146 **
147 ** yy_action[] A single table containing all actions.
148 ** yy_lookahead[] A table containing the lookahead for each entry in
149 ** yy_action. Used to detect hash collisions.
150 ** yy_shift_ofst[] For each state, the offset into yy_action for
151 ** shifting terminals.
152 ** yy_reduce_ofst[] For each state, the offset into yy_action for
153 ** shifting non-terminals after a reduce.
154 ** yy_default[] Default action for each state.
155 **
156 *********** Begin parsing tables **********************************************/
157 %%
158 /********** End of lemon-generated parsing tables *****************************/
160 /* The next table maps tokens (terminal symbols) into fallback tokens.
161 ** If a construct like the following:
162 **
163 ** %fallback ID X Y Z.
164 **
165 ** appears in the grammar, then ID becomes a fallback token for X, Y,
166 ** and Z. Whenever one of the tokens X, Y, or Z is input to the parser
167 ** but it does not parse, the type of the token is changed to ID and
168 ** the parse is retried before an error is thrown.
169 **
170 ** This feature can be used, for example, to cause some keywords in a language
171 ** to revert to identifiers if they keyword does not apply in the context where
172 ** it appears.
173 */
174 #ifdef YYFALLBACK
175 static const YYCODETYPE yyFallback[] = {
176 %%
177 };
178 #endif /* YYFALLBACK */
180 /* The following structure represents a single element of the
181 ** parser's stack. Information stored includes:
182 **
183 ** + The state number for the parser at this level of the stack.
184 **
185 ** + The value of the token stored at this level of the stack.
186 ** (In other words, the "major" token.)
187 **
188 ** + The semantic value stored at this level of the stack. This is
189 ** the information used by the action routines in the grammar.
190 ** It is sometimes called the "minor" token.
191 **
192 ** After the "shift" half of a SHIFTREDUCE action, the stateno field
193 ** actually contains the reduce action for the second half of the
194 ** SHIFTREDUCE.
195 */
196 struct yyStackEntry {
197 yyStackEntry() {
198 stateno = 0;
199 major = 0;
200 }
201 yyStackEntry(YYACTIONTYPE stateno_, YYCODETYPE major_, ParseTOKENTYPE minor_) {
202 stateno = stateno_;
203 major = major_;
204 minor.yy0 = minor_;
205 }
206 YYACTIONTYPE stateno; /* The state-number, or reduce action in SHIFTREDUCE */
207 YYCODETYPE major; /* The major token value. This is the code
208 ** number for the token at this stack level */
209 YYMINORTYPE minor; /* The user-supplied minor token value. This
210 ** is the value of the token */
211 };
213 static void ParseInit(yyParser *pParser);
214 static void ParseFinalize(yyParser *pParser);
216 /* The state of the parser is completely contained in an instance of
217 ** the following structure */
218 struct yyParser {
219 #ifdef YYTRACKMAXSTACKDEPTH
220 int yyhwm; /* High-water mark of the stack */
221 #endif
222 #ifndef YYNOERRORRECOVERY
223 int yyerrcnt; /* Shifts left before out of the error */
224 #endif
225 ParseARG_SDECL /* A place to hold %extra_argument */
226 vector<yyStackEntry> yystack; /* The parser's stack */
227 yyParser() {
228 ParseInit(this);
229 }
230 ~yyParser() {
231 ParseFinalize(this);
232 }
233 };
234 typedef struct yyParser yyParser;
236 #include "omassert.h"
237 #include "debuglog.h"
239 #if defined(YYCOVERAGE) || defined(XAPIAN_DEBUG_LOG)
240 /* For tracing shifts, the names of all terminals and nonterminals
241 ** are required. The following table supplies these names */
242 static const char *const yyTokenName[] = {
243 %%
244 };
246 /* For tracing reduce actions, the names of all rules are required.
247 */
248 static const char *const yyRuleName[] = {
249 %%
250 };
252 /*
253 ** This function returns the symbolic name associated with a token
254 ** value.
255 */
256 static const char *ParseTokenName(int tokenType){
257 if( tokenType>=0 && tokenType<(int)(sizeof(yyTokenName)/sizeof(yyTokenName[0])) ){
258 return yyTokenName[tokenType];
259 }
260 return "Unknown";
261 }
263 /*
264 ** This function returns the symbolic name associated with a rule
265 ** value.
266 */
267 static const char *ParseRuleName(int ruleNum){
268 if( ruleNum>=0 && ruleNum<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){
269 return yyRuleName[ruleNum];
270 }
271 return "Unknown";
272 }
273 #endif /* defined(YYCOVERAGE) || defined(XAPIAN_DEBUG_LOG) */
275 /* Datatype of the argument to the memory allocated passed as the
276 ** second argument to ParseAlloc() below. This can be changed by
277 ** putting an appropriate #define in the %include section of the input
278 ** grammar.
279 */
280 #ifndef YYMALLOCARGTYPE
281 # define YYMALLOCARGTYPE size_t
282 #endif
284 /* Initialize a new parser that has already been allocated.
285 */
286 static
287 void ParseInit(yyParser *pParser){
288 #ifdef YYTRACKMAXSTACKDEPTH
289 pParser->yyhwm = 0;
290 #endif
291 #if 0
292 #if YYSTACKDEPTH<=0
293 pParser->yytos = NULL;
294 pParser->yystack = NULL;
295 pParser->yystksz = 0;
296 if( yyGrowStack(pParser) ){
297 pParser->yystack = &pParser->yystk0;
298 pParser->yystksz = 1;
299 }
300 #endif
301 #endif
302 #ifndef YYNOERRORRECOVERY
303 pParser->yyerrcnt = -1;
304 #endif
305 #if 0
306 pParser->yytos = pParser->yystack;
307 pParser->yystack[0].stateno = 0;
308 pParser->yystack[0].major = 0;
309 #if YYSTACKDEPTH>0
310 pParser->yystackEnd = &pParser->yystack[YYSTACKDEPTH-1];
311 #endif
312 #else
313 pParser->yystack.push_back(yyStackEntry());
314 #endif
315 }
317 #ifndef Parse_ENGINEALWAYSONSTACK
318 /*
319 ** This function allocates a new parser.
320 **
321 ** Inputs:
322 ** None.
323 **
324 ** Outputs:
325 ** A pointer to a parser. This pointer is used in subsequent calls
326 ** to Parse and ParseFree.
327 */
328 static yyParser *ParseAlloc(void){
329 return new yyParser;
330 }
331 #endif /* Parse_ENGINEALWAYSONSTACK */
334 /* The following function deletes the "minor type" or semantic value
335 ** associated with a symbol. The symbol can be either a terminal
336 ** or nonterminal. "yymajor" is the symbol code, and "yypminor" is
337 ** a pointer to the value to be deleted. The code used to do the
338 ** deletions is derived from the %destructor and/or %token_destructor
339 ** directives of the input grammar.
340 */
341 static void yy_destructor(
342 yyParser *yypParser, /* The parser */
343 YYCODETYPE yymajor, /* Type code for object to destroy */
344 YYMINORTYPE *yypminor /* The object to be destroyed */
345 ){
346 ParseARG_FETCH;
347 switch( yymajor ){
348 /* Here is inserted the actions which take place when a
349 ** terminal or non-terminal is destroyed. This can happen
350 ** when the symbol is popped from the stack during a
351 ** reduce or during error processing or when a parser is
352 ** being destroyed before it is finished parsing.
353 **
354 ** Note: during a reduce, the only symbols destroyed are those
355 ** which appear on the RHS of the rule, but which are *not* used
356 ** inside the C code.
357 */
358 /********* Begin destructor definitions ***************************************/
359 %%
360 /********* End destructor definitions *****************************************/
361 default: break; /* If no destructor action specified: do nothing */
362 }
363 ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
364 }
366 /*
367 ** Pop the parser's stack once.
368 **
369 ** If there is a destructor routine associated with the token which
370 ** is popped from the stack, then call it.
371 */
372 static void yy_pop_parser_stack(yyParser *pParser){
373 Assert( pParser->yystack.size() > 1 );
374 yyStackEntry *yytos = &pParser->yystack.back();
376 LOGLINE(QUERYPARSER, "Popping " << ParseTokenName(yytos->major));
377 yy_destructor(pParser, yytos->major, &yytos->minor);
378 pParser->yystack.pop_back();
379 }
381 /*
382 ** Clear all secondary memory allocations from the parser
383 */
384 static
385 void ParseFinalize(yyParser *pParser){
386 while( pParser->yystack.size() > 1 ) yy_pop_parser_stack(pParser);
387 }
389 #ifndef Parse_ENGINEALWAYSONSTACK
390 /*
391 ** Deallocate and destroy a parser. Destructors are called for
392 ** all stack elements before shutting the parser down.
393 **
394 ** If the YYPARSEFREENEVERNULL macro exists (for example because it
395 ** is defined in a %include section of the input grammar) then it is
396 ** assumed that the input pointer is never NULL.
397 */
398 static
399 void ParseFree(
400 yyParser *pParser /* The parser to be deleted */
401 ){
402 delete pParser;
403 }
404 #endif /* Parse_ENGINEALWAYSONSTACK */
406 /*
407 ** Return the peak depth of the stack for a parser.
408 */
409 #ifdef YYTRACKMAXSTACKDEPTH
410 int ParseStackPeak(yyParser *pParser){
411 return pParser->yyhwm;
412 }
413 #endif
415 /* This array of booleans keeps track of the parser statement
416 ** coverage. The element yycoverage[X][Y] is set when the parser
417 ** is in state X and has a lookahead token Y. In a well-tested
418 ** systems, every element of this matrix should end up being set.
419 */
420 #if defined(YYCOVERAGE)
421 static unsigned char yycoverage[YYNSTATE][YYNTOKEN];
422 #endif
424 /*
425 ** Write into out a description of every state/lookahead combination that
426 **
427 ** (1) has not been used by the parser, and
428 ** (2) is not a syntax error.
429 **
430 ** Return the number of missed state/lookahead combinations.
431 */
432 #if defined(YYCOVERAGE)
433 int ParseCoverage(FILE *out){
434 int stateno, iLookAhead, i;
435 int nMissed = 0;
436 for(stateno=0; stateno<YYNSTATE; stateno++){
437 i = yy_shift_ofst[stateno];
438 for(iLookAhead=0; iLookAhead<YYNTOKEN; iLookAhead++){
439 if( yy_lookahead[i+iLookAhead]!=iLookAhead ) continue;
440 if( yycoverage[stateno][iLookAhead]==0 ) nMissed++;
441 if( out ){
442 fprintf(out,"State %d lookahead %s %s\n", stateno,
443 yyTokenName[iLookAhead],
444 yycoverage[stateno][iLookAhead] ? "ok" : "missed");
445 }
446 }
447 }
448 return nMissed;
449 }
450 #endif
452 /*
453 ** Find the appropriate action for a parser given the terminal
454 ** look-ahead token iLookAhead.
455 */
456 static unsigned int yy_find_shift_action(
457 yyParser *pParser, /* The parser */
458 YYCODETYPE iLookAhead /* The look-ahead token */
459 ){
460 int i;
461 int stateno = pParser->yystack.back().stateno;
463 if( stateno>YY_MAX_SHIFT ) return stateno;
464 Assert( stateno <= YY_SHIFT_COUNT );
465 #if defined(YYCOVERAGE)
466 yycoverage[stateno][iLookAhead] = 1;
467 #endif
468 do{
469 i = yy_shift_ofst[stateno];
470 Assert( i>=0 );
471 Assert( i+YYNTOKEN<=(int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])) );
472 Assert( iLookAhead!=YYNOCODE );
473 Assert( iLookAhead < YYNTOKEN );
474 i += iLookAhead;
475 if( yy_lookahead[i]!=iLookAhead ){
476 #ifdef YYFALLBACK
477 YYCODETYPE iFallback; /* Fallback token */
478 if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0])
479 && (iFallback = yyFallback[iLookAhead])!=0 ){
480 LOGLINE(QUERYPARSER,
481 "FALLBACK " << ParseTokenName(iLookAhead) << " => " <<
482 ParseTokenName(iFallback));
483 Assert( yyFallback[iFallback]==0 ); /* Fallback loop must terminate */
484 iLookAhead = iFallback;
485 continue;
486 }
487 #endif
488 #ifdef YYWILDCARD
489 {
490 int j = i - iLookAhead + YYWILDCARD;
491 if(
492 #if YY_SHIFT_MIN+YYWILDCARD<0
493 j>=0 &&
494 #endif
495 #if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT
496 j<YY_ACTTAB_COUNT &&
497 #endif
498 yy_lookahead[j]==YYWILDCARD && iLookAhead>0
499 ){
500 LOGLINE(QUERYPARSER,
501 "WILDCARD " << ParseTokenName(iLookAhead) << " => " <<
502 ParseTokenName(YYWILDCARD));
503 return yy_action[j];
504 }
505 }
506 #endif /* YYWILDCARD */
507 return yy_default[stateno];
508 }else{
509 return yy_action[i];
510 }
511 }while(1);
512 }
514 /*
515 ** Find the appropriate action for a parser given the non-terminal
516 ** look-ahead token iLookAhead.
517 */
518 static int yy_find_reduce_action(
519 int stateno, /* Current state number */
520 YYCODETYPE iLookAhead /* The look-ahead token */
521 ){
522 int i;
523 #ifdef YYERRORSYMBOL
524 if( stateno>YY_REDUCE_COUNT ){
525 return yy_default[stateno];
526 }
527 #else
528 Assert( stateno<=YY_REDUCE_COUNT );
529 #endif
530 i = yy_reduce_ofst[stateno];
531 Assert( iLookAhead!=YYNOCODE );
532 i += iLookAhead;
533 #ifdef YYERRORSYMBOL
534 if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){
535 return yy_default[stateno];
536 }
537 #else
538 Assert( i>=0 && i<YY_ACTTAB_COUNT );
539 Assert( yy_lookahead[i]==iLookAhead );
540 #endif
541 return yy_action[i];
542 }
544 /*
545 ** The following routine is called if the stack overflows.
546 ** In Xapian this can never happen as we use std::vector to provide a stack
547 ** of indefinite size.
548 */
549 #if 0
550 static void yyStackOverflow(yyParser *yypParser){
551 ParseARG_FETCH;
552 yypParser->yyidx--;
553 #ifndef NDEBUG
554 if( yyTraceFILE ){
555 fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
556 }
557 #endif
558 while( yypParser->yytos>yypParser->yystack ) yy_pop_parser_stack(yypParser);
559 /* Here code is inserted which will execute if the parser
560 ** stack ever overflows */
561 /******** Begin %stack_overflow code ******************************************/
562 %%
563 /******** End %stack_overflow code ********************************************/
564 ParseARG_STORE; /* Suppress warning about unused %extra_argument var */
565 }
566 #endif
568 /*
569 ** Print tracing information for a SHIFT action
570 */
571 #ifdef XAPIAN_DEBUG_LOG
572 static void yyTraceShift(yyParser *yypParser, int yyNewState, const char *zTag){
573 if( yyNewState<YYNSTATE ){
574 LOGLINE(QUERYPARSER, zTag << " '" <<
575 yyTokenName[yypParser->yystack.back().major] <<
576 "', go to state " << yyNewState);
577 }else{
578 LOGLINE(QUERYPARSER, zTag << " '" <<
579 yyTokenName[yypParser->yystack.back().major] <<
580 "', pending reduce " << yyNewState - YY_MIN_REDUCE);
581 }
582 }
583 #else
584 # define yyTraceShift(X,Y,Z)
585 #endif
587 /*
588 ** Perform a shift action.
589 */
590 static void yy_shift(
591 yyParser *yypParser, /* The parser to be shifted */
592 int yyNewState, /* The new state to shift in */
593 int yyMajor, /* The major token to shift in */
594 ParseTOKENTYPE yyMinor /* The minor token to shift in */
595 ){
596 if( yyNewState > YY_MAX_SHIFT ){
597 yyNewState += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE;
598 }
599 yypParser->yystack.push_back(yyStackEntry(yyNewState, yyMajor, yyMinor));
600 #ifdef YYTRACKMAXSTACKDEPTH
601 if( (int)(yypParser->yystack.size()>yypParser->yyhwm ){
602 yypParser->yyhwm++;
603 Assert( yypParser->yyhwm == (int)(yypParser->yystack.size() );
604 }
605 #endif
606 yyTraceShift(yypParser, yyNewState, "Shift");
607 }
609 /* The following table contains information about every rule that
610 ** is used during the reduce.
611 */
612 static const struct {
613 YYCODETYPE lhs; /* Symbol on the left-hand side of the rule */
614 signed char nrhs; /* Negative of the number of RHS symbols in the rule */
615 } yyRuleInfo[] = {
616 %%
617 };
619 static void yy_accept(yyParser*); /* Forward Declaration */
621 /*
622 ** Perform a reduce action and the shift that must immediately
623 ** follow the reduce.
624 **
625 ** The yyLookahead and yyLookaheadToken parameters provide reduce actions
626 ** access to the lookahead token (if any). The yyLookahead will be YYNOCODE
627 ** if the lookahead token has already been consumed. As this procedure is
628 ** only called from one place, optimizing compilers will in-line it, which
629 ** means that the extra parameters have no performance impact.
630 */
631 static void yy_reduce(
632 yyParser *yypParser, /* The parser */
633 unsigned int yyruleno, /* Number of the rule by which to reduce */
634 int yyLookahead, /* Lookahead token, or YYNOCODE if none */
635 ParseTOKENTYPE yyLookaheadToken /* Value of the lookahead token */
636 ){
637 int yygoto; /* The next state */
638 int yyact; /* The next action */
639 yyStackEntry *yymsp; /* The top of the parser's stack */
640 int yysize; /* Amount to pop the stack */
641 ParseARG_FETCH;
642 (void)yyLookahead;
643 (void)yyLookaheadToken;
644 yymsp = &yypParser->yystack.back();
645 Assert( yyruleno<sizeof(yyRuleInfo)/sizeof(yyRuleInfo[0]) );
646 #ifdef XAPIAN_DEBUG_LOG
647 {
648 yysize = yyRuleInfo[yyruleno].nrhs;
649 if( yysize ){
650 LOGLINE(QUERYPARSER, "Reduce " << yyruleno << " [" <<
651 ParseRuleName(yyruleno) << "], go to state " <<
652 yymsp[yysize].stateno);
653 } else {
654 LOGLINE(QUERYPARSER, "Reduce " << yyruleno << " [" <<
655 ParseRuleName(yyruleno) << "].");
656 }
657 }
658 #endif /* XAPIAN_DEBUG_LOG */
659 /* yygotominor = yyzerominor; */
661 /* Check that the stack is large enough to grow by a single entry
662 ** if the RHS of the rule is empty. This ensures that there is room
663 ** enough on the stack to push the LHS value without invalidating
664 ** pointers into the stack. */
665 if( yyRuleInfo[yyruleno].nrhs==0 ){
666 #if 1
667 yypParser->yystack.resize(yypParser->yystack.size() + 1);
668 yymsp = &(yypParser->yystack.back()) - 1;
669 #else
670 #ifdef YYTRACKMAXSTACKDEPTH
671 if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){
672 yypParser->yyhwm++;
673 Assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack));
674 }
675 #endif
676 #if YYSTACKDEPTH>0
677 if( yypParser->yytos>=yypParser->yystackEnd ){
678 yyStackOverflow(yypParser);
679 return;
680 }
681 #else
682 if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){
683 if( yyGrowStack(yypParser) ){
684 yyStackOverflow(yypParser);
685 return;
686 }
687 yymsp = yypParser->yytos;
688 }
689 #endif
690 #endif
691 }
693 switch( yyruleno ){
694 /* Beginning here are the reduction cases. A typical example
695 ** follows:
696 ** case 0:
697 ** #line <lineno> <grammarfile>
698 ** { ... } // User supplied code
699 ** #line <lineno> <thisfile>
700 ** break;
701 */
702 /********** Begin reduce actions **********************************************/
703 %%
704 /********** End reduce actions ************************************************/
705 }
706 Assert( yyruleno<sizeof(yyRuleInfo)/sizeof(yyRuleInfo[0]) );
707 yygoto = yyRuleInfo[yyruleno].lhs;
708 yysize = yyRuleInfo[yyruleno].nrhs;
709 yyact = yy_find_reduce_action(yymsp[yysize].stateno,static_cast<YYCODETYPE>(yygoto));
711 /* There are no SHIFTREDUCE actions on nonterminals because the table
712 ** generator has simplified them to pure REDUCE actions. */
713 Assert( !(yyact>YY_MAX_SHIFT && yyact<=YY_MAX_SHIFTREDUCE) );
715 /* It is not possible for a REDUCE to be followed by an error */
716 Assert( yyact!=YY_ERROR_ACTION );
718 yymsp += yysize+1;
719 if (yysize) {
720 yypParser->yystack.resize(UNSIGNED_OVERFLOW_OK(yypParser->yystack.size() +
721 (yysize+1)));
722 }
723 yymsp->stateno = static_cast<YYACTIONTYPE>(yyact);
724 yymsp->major = static_cast<YYCODETYPE>(yygoto);
725 yyTraceShift(yypParser, yyact, "... then shift");
726 }
728 /*
729 ** The following code executes when the parse fails
730 */
731 #ifndef YYNOERRORRECOVERY
732 static void yy_parse_failed(
733 yyParser *yypParser /* The parser */
734 ){
735 ParseARG_FETCH;
736 LOGLINE(QUERYPARSER, "Fail!");
737 while( yypParser->yystack.size() > 1 ) yy_pop_parser_stack(yypParser);
738 /* Here code is inserted which will be executed whenever the
739 ** parser fails */
740 /************ Begin %parse_failure code ***************************************/
741 %%
742 /************ End %parse_failure code *****************************************/
743 ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
744 }
745 #endif /* YYNOERRORRECOVERY */
747 /*
748 ** The following code executes when a syntax error first occurs.
749 */
750 static void yy_syntax_error(
751 yyParser *yypParser, /* The parser */
752 int yymajor, /* The major type of the error token */
753 ParseTOKENTYPE yyminor /* The minor type of the error token */
754 ){
755 ParseARG_FETCH;
756 (void)yymajor;
757 (void)yyminor;
758 #define TOKEN yyminor
759 /************ Begin %syntax_error code ****************************************/
760 %%
761 /************ End %syntax_error code ******************************************/
762 ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
763 }
765 /*
766 ** The following is executed when the parser accepts
767 */
768 static void yy_accept(
769 yyParser *yypParser /* The parser */
770 ){
771 ParseARG_FETCH;
772 LOGLINE(QUERYPARSER, "Accept!");
773 #ifndef YYNOERRORRECOVERY
774 yypParser->yyerrcnt = -1;
775 #endif
776 AssertEq( yypParser->yystack.size(), 1 );
777 /* Here code is inserted which will be executed whenever the
778 ** parser accepts */
779 /*********** Begin %parse_accept code *****************************************/
780 %%
781 /*********** End %parse_accept code *******************************************/
782 ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
783 }
785 /* The main parser program.
786 ** The first argument is a pointer to a structure obtained from
787 ** "ParseAlloc" which describes the current state of the parser.
788 ** The second argument is the major token number. The third is
789 ** the minor token. The fourth optional argument is whatever the
790 ** user wants (and specified in the grammar) and is available for
791 ** use by the action routines.
792 **
793 ** Inputs:
794 ** <ul>
795 ** <li> A pointer to the parser (an opaque structure.)
796 ** <li> The major token number.
797 ** <li> The minor token number.
798 ** <li> An option argument of a grammar-specified type.
799 ** </ul>
800 **
801 ** Outputs:
802 ** None.
803 */
804 static
805 void Parse(
806 yyParser *yypParser, /* The parser */
807 int yymajor, /* The major token code number */
808 ParseTOKENTYPE yyminor /* The value for the token */
809 ParseARG_PDECL /* Optional %extra_argument parameter */
810 ){
811 YYMINORTYPE yyminorunion;
812 unsigned int yyact; /* The parser action. */
813 #if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
814 int yyendofinput; /* True if we are at the end of input */
815 #endif
816 #ifdef YYERRORSYMBOL
817 int yyerrorhit = 0; /* True if yymajor has invoked an error */
818 #endif
820 #if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
821 yyendofinput = (yymajor==0);
822 #endif
823 ParseARG_STORE;
825 #ifdef XAPIAN_DEBUG_LOG
826 {
827 int stateno = yypParser->yystack.back().stateno;
828 if( stateno < YY_MIN_REDUCE ){
829 LOGLINE(QUERYPARSER, "Input '" << ParseTokenName(yymajor) <<
830 "'," << (yyminor ? yyminor->name : "<<null>>") <<
831 "in state " << stateno);
832 }else{
833 LOGLINE(QUERYPARSER, "Input '" << ParseTokenName(yymajor) <<
834 "'," << (yyminor ? yyminor->name : "<<null>>") <<
835 "with pending reduce " << stateno-YY_MIN_REDUCE);
836 }
837 }
838 #endif
840 do{
841 yyact = yy_find_shift_action(yypParser,static_cast<YYCODETYPE>(yymajor));
842 if( yyact >= YY_MIN_REDUCE ){
843 yy_reduce(yypParser,yyact-YY_MIN_REDUCE,yymajor,yyminor);
844 }else if( yyact <= YY_MAX_SHIFTREDUCE ){
845 yy_shift(yypParser,yyact,yymajor,yyminor);
846 #ifndef YYNOERRORRECOVERY
847 yypParser->yyerrcnt--;
848 #endif
849 yymajor = YYNOCODE;
850 }else if( yyact==YY_ACCEPT_ACTION ){
851 yypParser->yystack.pop_back();
852 yy_accept(yypParser);
853 return;
854 }else{
855 Assert( yyact == YY_ERROR_ACTION );
856 yyminorunion.yy0 = yyminor;
857 #ifdef YYERRORSYMBOL
858 int yymx;
859 #endif
860 LOGLINE(QUERYPARSER, "Syntax Error!");
861 #ifdef YYERRORSYMBOL
862 /* A syntax error has occurred.
863 ** The response to an error depends upon whether or not the
864 ** grammar defines an error token "ERROR".
865 **
866 ** This is what we do if the grammar does define ERROR:
867 **
868 ** * Call the %syntax_error function.
869 **
870 ** * Begin popping the stack until we enter a state where
871 ** it is legal to shift the error symbol, then shift
872 ** the error symbol.
873 **
874 ** * Set the error count to three.
875 **
876 ** * Begin accepting and shifting new tokens. No new error
877 ** processing will occur until three tokens have been
878 ** shifted successfully.
879 **
880 */
881 if( yypParser->yyerrcnt<0 ){
882 yy_syntax_error(yypParser,yymajor,yyminor);
883 }
884 yymx = yypParser->yystack.back().major;
885 if( yymx==YYERRORSYMBOL || yyerrorhit ){
886 LOGLINE(QUERYPARSER, "Discard input token " << ParseTokenName(yymajor));
887 yy_destructor(yypParser, static_cast<YYCODETYPE>(yymajor), &yyminorunion);
888 yymajor = YYNOCODE;
889 }else{
890 while( !yypParser->yystack.empty()
891 && yymx != YYERRORSYMBOL
892 && (yyact = yy_find_reduce_action(
893 yypParser->yystack.back().stateno,
894 YYERRORSYMBOL)) >= YY_MIN_REDUCE
895 ){
896 yy_pop_parser_stack(yypParser);
897 }
898 if( yypParser->yystack.empty() || yymajor==0 ){
899 yy_destructor(yypParser,static_cast<YYCODETYPE>(yymajor),&yyminorunion);
900 yy_parse_failed(yypParser);
901 #ifndef YYNOERRORRECOVERY
902 yypParser->yyerrcnt = -1;
903 #endif
904 yymajor = YYNOCODE;
905 }else if( yymx!=YYERRORSYMBOL ){
906 yy_shift(yypParser,yyact,YYERRORSYMBOL,yyminor);
907 }
908 }
909 yypParser->yyerrcnt = 3;
910 yyerrorhit = 1;
911 #elif defined(YYNOERRORRECOVERY)
912 /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
913 ** do any kind of error recovery. Instead, simply invoke the syntax
914 ** error routine and continue going as if nothing had happened.
915 **
916 ** Applications can set this macro (for example inside %include) if
917 ** they intend to abandon the parse upon the first syntax error seen.
918 */
919 yy_syntax_error(yypParser,yymajor, yyminor);
920 yy_destructor(yypParser,static_cast<YYCODETYPE>(yymajor),&yyminorunion);
921 yymajor = YYNOCODE;
923 #else /* YYERRORSYMBOL is not defined */
924 /* This is what we do if the grammar does not define ERROR:
925 **
926 ** * Report an error message, and throw away the input token.
927 **
928 ** * If the input token is $, then fail the parse.
929 **
930 ** As before, subsequent error messages are suppressed until
931 ** three input tokens have been successfully shifted.
932 */
933 if( yypParser->yyerrcnt<=0 ){
934 yy_syntax_error(yypParser,yymajor, yyminor);
935 }
936 yypParser->yyerrcnt = 3;
937 yy_destructor(yypParser,static_cast<YYCODETYPE>(yymajor),&yyminorunion);
938 if( yyendofinput ){
939 yy_parse_failed(yypParser);
940 #ifndef YYNOERRORRECOVERY
941 yypParser->yyerrcnt = -1;
942 #endif
943 }
944 yymajor = YYNOCODE;
945 #endif
946 }
947 }while( yymajor!=YYNOCODE && yypParser->yystack.size() > 1 );
948 #ifdef XAPIAN_DEBUG_LOG
949 {
950 int i;
951 LOGLINE(QUERYPARSER, "Return. Stack=");
952 for(i=1; i<=(int)yypParser->yystack.size(); i++)
953 LOGLINE(QUERYPARSER, yyTokenName[yypParser->yystack[i].major]);
954 }
955 #endif
956 return;
957 }
959 // Select C++ syntax highlighting in vim editor: vim: syntax=cpp