1: /* Driver template for the LEMON parser generator.
2: ** The author disclaims copyright to this source code.
3: */
4: /* First off, code is included that follows the "include" declaration
5: ** in the input grammar file. */
6: #include <stdio.h>
7: %%
8: /* Next is all token values, in a form suitable for use by makeheaders.
9: ** This section will be null unless lemon is run with the -m switch.
10: */
11: /*
12: ** These constants (all generated automatically by the parser generator)
13: ** specify the various kinds of tokens (terminals) that the parser
14: ** understands.
15: **
16: ** Each symbol here is a terminal symbol in the grammar.
17: */
18: %%
19: /* Make sure the INTERFACE macro is defined.
20: */
21: #ifndef INTERFACE
22: # define INTERFACE 1
23: #endif
24: /* The next thing included is series of defines which control
25: ** various aspects of the generated parser.
26: ** YYCODETYPE is the data type used for storing terminal
27: ** and nonterminal numbers. "unsigned char" is
28: ** used if there are fewer than 250 terminals
29: ** and nonterminals. "int" is used otherwise.
30: ** YYNOCODE is a number of type YYCODETYPE which corresponds
31: ** to no legal terminal or nonterminal number. This
32: ** number is used to fill in empty slots of the hash
33: ** table.
34: ** YYFALLBACK If defined, this indicates that one or more tokens
35: ** have fall-back values which should be used if the
36: ** original value of the token will not parse.
37: ** YYACTIONTYPE is the data type used for storing terminal
38: ** and nonterminal numbers. "unsigned char" is
39: ** used if there are fewer than 250 rules and
40: ** states combined. "int" is used otherwise.
41: ** ParseTOKENTYPE is the data type used for minor tokens given
42: ** directly to the parser from the tokenizer.
43: ** YYMINORTYPE is the data type used for all minor tokens.
44: ** This is typically a union of many types, one of
45: ** which is ParseTOKENTYPE. The entry in the union
46: ** for base tokens is called "yy0".
47: ** YYSTACKDEPTH is the maximum depth of the parser's stack. If
48: ** zero the stack is dynamically sized using realloc()
49: ** ParseARG_SDECL A static variable declaration for the %extra_argument
50: ** ParseARG_PDECL A parameter declaration for the %extra_argument
51: ** ParseARG_STORE Code to store %extra_argument into yypParser
52: ** ParseARG_FETCH Code to extract %extra_argument from yypParser
53: ** YYNSTATE the combined number of states.
54: ** YYNRULE the number of rules in the grammar
55: ** YYERRORSYMBOL is the code number of the error symbol. If not
56: ** defined, then do no error processing.
57: */
58: %%
59: #define YY_NO_ACTION (YYNSTATE+YYNRULE+2)
60: #define YY_ACCEPT_ACTION (YYNSTATE+YYNRULE+1)
61: #define YY_ERROR_ACTION (YYNSTATE+YYNRULE)
62:
63: /* The yyzerominor constant is used to initialize instances of
64: ** YYMINORTYPE objects to zero. */
65: static const YYMINORTYPE yyzerominor = { 0 };
66:
67: /* Define the yytestcase() macro to be a no-op if is not already defined
68: ** otherwise.
69: **
70: ** Applications can choose to define yytestcase() in the %include section
71: ** to a macro that can assist in verifying code coverage. For production
72: ** code the yytestcase() macro should be turned off. But it is useful
73: ** for testing.
74: */
75: #ifndef yytestcase
76: # define yytestcase(X)
77: #endif
78:
79:
80: /* Next are the tables used to determine what action to take based on the
81: ** current state and lookahead token. These tables are used to implement
82: ** functions that take a state number and lookahead value and return an
83: ** action integer.
84: **
85: ** Suppose the action integer is N. Then the action is determined as
86: ** follows
87: **
88: ** 0 <= N < YYNSTATE Shift N. That is, push the lookahead
89: ** token onto the stack and goto state N.
90: **
91: ** YYNSTATE <= N < YYNSTATE+YYNRULE Reduce by rule N-YYNSTATE.
92: **
93: ** N == YYNSTATE+YYNRULE A syntax error has occurred.
94: **
95: ** N == YYNSTATE+YYNRULE+1 The parser accepts its input.
96: **
97: ** N == YYNSTATE+YYNRULE+2 No such action. Denotes unused
98: ** slots in the yy_action[] table.
99: **
100: ** The action table is constructed as a single large table named yy_action[].
101: ** Given state S and lookahead X, the action is computed as
102: **
103: ** yy_action[ yy_shift_ofst[S] + X ]
104: **
105: ** If the index value yy_shift_ofst[S]+X is out of range or if the value
106: ** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X or if yy_shift_ofst[S]
107: ** is equal to YY_SHIFT_USE_DFLT, it means that the action is not in the table
108: ** and that yy_default[S] should be used instead.
109: **
110: ** The formula above is for computing the action when the lookahead is
111: ** a terminal symbol. If the lookahead is a non-terminal (as occurs after
112: ** a reduce action) then the yy_reduce_ofst[] array is used in place of
113: ** the yy_shift_ofst[] array and YY_REDUCE_USE_DFLT is used in place of
114: ** YY_SHIFT_USE_DFLT.
115: **
116: ** The following are the tables generated in this section:
117: **
118: ** yy_action[] A single table containing all actions.
119: ** yy_lookahead[] A table containing the lookahead for each entry in
120: ** yy_action. Used to detect hash collisions.
121: ** yy_shift_ofst[] For each state, the offset into yy_action for
122: ** shifting terminals.
123: ** yy_reduce_ofst[] For each state, the offset into yy_action for
124: ** shifting non-terminals after a reduce.
125: ** yy_default[] Default action for each state.
126: */
127: %%
128:
129: /* The next table maps tokens into fallback tokens. If a construct
130: ** like the following:
131: **
132: ** %fallback ID X Y Z.
133: **
134: ** appears in the grammar, then ID becomes a fallback token for X, Y,
135: ** and Z. Whenever one of the tokens X, Y, or Z is input to the parser
136: ** but it does not parse, the type of the token is changed to ID and
137: ** the parse is retried before an error is thrown.
138: */
139: #ifdef YYFALLBACK
140: static const YYCODETYPE yyFallback[] = {
141: %%
142: };
143: #endif /* YYFALLBACK */
144:
145: /* The following structure represents a single element of the
146: ** parser's stack. Information stored includes:
147: **
148: ** + The state number for the parser at this level of the stack.
149: **
150: ** + The value of the token stored at this level of the stack.
151: ** (In other words, the "major" token.)
152: **
153: ** + The semantic value stored at this level of the stack. This is
154: ** the information used by the action routines in the grammar.
155: ** It is sometimes called the "minor" token.
156: */
157: struct yyStackEntry {
158: YYACTIONTYPE stateno; /* The state-number */
159: YYCODETYPE major; /* The major token value. This is the code
160: ** number for the token at this stack level */
161: YYMINORTYPE minor; /* The user-supplied minor token value. This
162: ** is the value of the token */
163: };
164: typedef struct yyStackEntry yyStackEntry;
165:
166: /* The state of the parser is completely contained in an instance of
167: ** the following structure */
168: struct yyParser {
169: int yyidx; /* Index of top element in stack */
170: #ifdef YYTRACKMAXSTACKDEPTH
171: int yyidxMax; /* Maximum value of yyidx */
172: #endif
173: int yyerrcnt; /* Shifts left before out of the error */
174: ParseARG_SDECL /* A place to hold %extra_argument */
175: #if YYSTACKDEPTH<=0
176: int yystksz; /* Current side of the stack */
177: yyStackEntry *yystack; /* The parser's stack */
178: #else
179: yyStackEntry yystack[YYSTACKDEPTH]; /* The parser's stack */
180: #endif
181: };
182: typedef struct yyParser yyParser;
183:
184: #ifndef NDEBUG
185: #include <stdio.h>
186: static FILE *yyTraceFILE = 0;
187: static char *yyTracePrompt = 0;
188: #endif /* NDEBUG */
189:
190: #ifndef NDEBUG
191: /*
192: ** Turn parser tracing on by giving a stream to which to write the trace
193: ** and a prompt to preface each trace message. Tracing is turned off
194: ** by making either argument NULL
195: **
196: ** Inputs:
197: ** <ul>
198: ** <li> A FILE* to which trace output should be written.
199: ** If NULL, then tracing is turned off.
200: ** <li> A prefix string written at the beginning of every
201: ** line of trace output. If NULL, then tracing is
202: ** turned off.
203: ** </ul>
204: **
205: ** Outputs:
206: ** None.
207: */
208: void ParseTrace(FILE *TraceFILE, char *zTracePrompt){
209: yyTraceFILE = TraceFILE;
210: yyTracePrompt = zTracePrompt;
211: if( yyTraceFILE==0 ) yyTracePrompt = 0;
212: else if( yyTracePrompt==0 ) yyTraceFILE = 0;
213: }
214: #endif /* NDEBUG */
215:
216: #ifndef NDEBUG
217: /* For tracing shifts, the names of all terminals and nonterminals
218: ** are required. The following table supplies these names */
219: static const char *const yyTokenName[] = {
220: %%
221: };
222: #endif /* NDEBUG */
223:
224: #ifndef NDEBUG
225: /* For tracing reduce actions, the names of all rules are required.
226: */
227: static const char *const yyRuleName[] = {
228: %%
229: };
230: #endif /* NDEBUG */
231:
232:
233: #if YYSTACKDEPTH<=0
234: /*
235: ** Try to increase the size of the parser stack.
236: */
237: static void yyGrowStack(yyParser *p){
238: int newSize;
239: yyStackEntry *pNew;
240:
241: newSize = p->yystksz*2 + 100;
242: pNew = realloc(p->yystack, newSize*sizeof(pNew[0]));
243: if( pNew ){
244: p->yystack = pNew;
245: p->yystksz = newSize;
246: #ifndef NDEBUG
247: if( yyTraceFILE ){
248: fprintf(yyTraceFILE,"%sStack grows to %d entries!\n",
249: yyTracePrompt, p->yystksz);
250: }
251: #endif
252: }
253: }
254: #endif
255:
256: /*
257: ** This function allocates a new parser.
258: ** The only argument is a pointer to a function which works like
259: ** malloc.
260: **
261: ** Inputs:
262: ** A pointer to the function used to allocate memory.
263: **
264: ** Outputs:
265: ** A pointer to a parser. This pointer is used in subsequent calls
266: ** to Parse and ParseFree.
267: */
268: void *ParseAlloc(void *(*mallocProc)(size_t)){
269: yyParser *pParser;
270: pParser = (yyParser*)(*mallocProc)( (size_t)sizeof(yyParser) );
271: if( pParser ){
272: pParser->yyidx = -1;
273: #ifdef YYTRACKMAXSTACKDEPTH
274: pParser->yyidxMax = 0;
275: #endif
276: #if YYSTACKDEPTH<=0
277: pParser->yystack = NULL;
278: pParser->yystksz = 0;
279: yyGrowStack(pParser);
280: #endif
281: }
282: return pParser;
283: }
284:
285: /* The following function deletes the value associated with a
286: ** symbol. The symbol can be either a terminal or nonterminal.
287: ** "yymajor" is the symbol code, and "yypminor" is a pointer to
288: ** the value.
289: */
290: static void yy_destructor(
291: yyParser *yypParser, /* The parser */
292: YYCODETYPE yymajor, /* Type code for object to destroy */
293: YYMINORTYPE *yypminor /* The object to be destroyed */
294: ){
295: ParseARG_FETCH;
296: switch( yymajor ){
297: /* Here is inserted the actions which take place when a
298: ** terminal or non-terminal is destroyed. This can happen
299: ** when the symbol is popped from the stack during a
300: ** reduce or during error processing or when a parser is
301: ** being destroyed before it is finished parsing.
302: **
303: ** Note: during a reduce, the only symbols destroyed are those
304: ** which appear on the RHS of the rule, but which are not used
305: ** inside the C code.
306: */
307: %%
308: default: break; /* If no destructor action specified: do nothing */
309: }
310: }
311:
312: /*
313: ** Pop the parser's stack once.
314: **
315: ** If there is a destructor routine associated with the token which
316: ** is popped from the stack, then call it.
317: **
318: ** Return the major token number for the symbol popped.
319: */
320: static int yy_pop_parser_stack(yyParser *pParser){
321: YYCODETYPE yymajor;
322: yyStackEntry *yytos = &pParser->yystack[pParser->yyidx];
323:
324: if( pParser->yyidx<0 ) return 0;
325: #ifndef NDEBUG
326: if( yyTraceFILE && pParser->yyidx>=0 ){
327: fprintf(yyTraceFILE,"%sPopping %s\n",
328: yyTracePrompt,
329: yyTokenName[yytos->major]);
330: }
331: #endif
332: yymajor = yytos->major;
333: yy_destructor(pParser, yymajor, &yytos->minor);
334: pParser->yyidx--;
335: return yymajor;
336: }
337:
338: /*
339: ** Deallocate and destroy a parser. Destructors are all called for
340: ** all stack elements before shutting the parser down.
341: **
342: ** Inputs:
343: ** <ul>
344: ** <li> A pointer to the parser. This should be a pointer
345: ** obtained from ParseAlloc.
346: ** <li> A pointer to a function used to reclaim memory obtained
347: ** from malloc.
348: ** </ul>
349: */
350: void ParseFree(
351: void *p, /* The parser to be deleted */
352: void (*freeProc)(void*) /* Function used to reclaim memory */
353: ){
354: yyParser *pParser = (yyParser*)p;
355: if( pParser==0 ) return;
356: while( pParser->yyidx>=0 ) yy_pop_parser_stack(pParser);
357: #if YYSTACKDEPTH<=0
358: free(pParser->yystack);
359: #endif
360: (*freeProc)((void*)pParser);
361: }
362:
363: /*
364: ** Return the peak depth of the stack for a parser.
365: */
366: #ifdef YYTRACKMAXSTACKDEPTH
367: int ParseStackPeak(void *p){
368: yyParser *pParser = (yyParser*)p;
369: return pParser->yyidxMax;
370: }
371: #endif
372:
373: /*
374: ** Find the appropriate action for a parser given the terminal
375: ** look-ahead token iLookAhead.
376: **
377: ** If the look-ahead token is YYNOCODE, then check to see if the action is
378: ** independent of the look-ahead. If it is, return the action, otherwise
379: ** return YY_NO_ACTION.
380: */
381: static int yy_find_shift_action(
382: yyParser *pParser, /* The parser */
383: YYCODETYPE iLookAhead /* The look-ahead token */
384: ){
385: int i;
386: int stateno = pParser->yystack[pParser->yyidx].stateno;
387:
388: if( stateno>YY_SHIFT_COUNT
389: || (i = yy_shift_ofst[stateno])==YY_SHIFT_USE_DFLT ){
390: return yy_default[stateno];
391: }
392: assert( iLookAhead!=YYNOCODE );
393: i += iLookAhead;
394: if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){
395: if( iLookAhead>0 ){
396: #ifdef YYFALLBACK
397: YYCODETYPE iFallback; /* Fallback token */
398: if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0])
399: && (iFallback = yyFallback[iLookAhead])!=0 ){
400: #ifndef NDEBUG
401: if( yyTraceFILE ){
402: fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",
403: yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]);
404: }
405: #endif
406: return yy_find_shift_action(pParser, iFallback);
407: }
408: #endif
409: #ifdef YYWILDCARD
410: {
411: int j = i - iLookAhead + YYWILDCARD;
412: if(
413: #if YY_SHIFT_MIN+YYWILDCARD<0
414: j>=0 &&
415: #endif
416: #if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT
417: j<YY_ACTTAB_COUNT &&
418: #endif
419: yy_lookahead[j]==YYWILDCARD
420: ){
421: #ifndef NDEBUG
422: if( yyTraceFILE ){
423: fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n",
424: yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[YYWILDCARD]);
425: }
426: #endif /* NDEBUG */
427: return yy_action[j];
428: }
429: }
430: #endif /* YYWILDCARD */
431: }
432: return yy_default[stateno];
433: }else{
434: return yy_action[i];
435: }
436: }
437:
438: /*
439: ** Find the appropriate action for a parser given the non-terminal
440: ** look-ahead token iLookAhead.
441: **
442: ** If the look-ahead token is YYNOCODE, then check to see if the action is
443: ** independent of the look-ahead. If it is, return the action, otherwise
444: ** return YY_NO_ACTION.
445: */
446: static int yy_find_reduce_action(
447: int stateno, /* Current state number */
448: YYCODETYPE iLookAhead /* The look-ahead token */
449: ){
450: int i;
451: #ifdef YYERRORSYMBOL
452: if( stateno>YY_REDUCE_COUNT ){
453: return yy_default[stateno];
454: }
455: #else
456: assert( stateno<=YY_REDUCE_COUNT );
457: #endif
458: i = yy_reduce_ofst[stateno];
459: assert( i!=YY_REDUCE_USE_DFLT );
460: assert( iLookAhead!=YYNOCODE );
461: i += iLookAhead;
462: #ifdef YYERRORSYMBOL
463: if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){
464: return yy_default[stateno];
465: }
466: #else
467: assert( i>=0 && i<YY_ACTTAB_COUNT );
468: assert( yy_lookahead[i]==iLookAhead );
469: #endif
470: return yy_action[i];
471: }
472:
473: /*
474: ** The following routine is called if the stack overflows.
475: */
476: static void yyStackOverflow(yyParser *yypParser, YYMINORTYPE *yypMinor){
477: ParseARG_FETCH;
478: yypParser->yyidx--;
479: #ifndef NDEBUG
480: if( yyTraceFILE ){
481: fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
482: }
483: #endif
484: while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
485: /* Here code is inserted which will execute if the parser
486: ** stack every overflows */
487: %%
488: ParseARG_STORE; /* Suppress warning about unused %extra_argument var */
489: }
490:
491: /*
492: ** Perform a shift action.
493: */
494: static void yy_shift(
495: yyParser *yypParser, /* The parser to be shifted */
496: int yyNewState, /* The new state to shift in */
497: int yyMajor, /* The major token to shift in */
498: YYMINORTYPE *yypMinor /* Pointer to the minor token to shift in */
499: ){
500: yyStackEntry *yytos;
501: yypParser->yyidx++;
502: #ifdef YYTRACKMAXSTACKDEPTH
503: if( yypParser->yyidx>yypParser->yyidxMax ){
504: yypParser->yyidxMax = yypParser->yyidx;
505: }
506: #endif
507: #if YYSTACKDEPTH>0
508: if( yypParser->yyidx>=YYSTACKDEPTH ){
509: yyStackOverflow(yypParser, yypMinor);
510: return;
511: }
512: #else
513: if( yypParser->yyidx>=yypParser->yystksz ){
514: yyGrowStack(yypParser);
515: if( yypParser->yyidx>=yypParser->yystksz ){
516: yyStackOverflow(yypParser, yypMinor);
517: return;
518: }
519: }
520: #endif
521: yytos = &yypParser->yystack[yypParser->yyidx];
522: yytos->stateno = (YYACTIONTYPE)yyNewState;
523: yytos->major = (YYCODETYPE)yyMajor;
524: yytos->minor = *yypMinor;
525: #ifndef NDEBUG
526: if( yyTraceFILE && yypParser->yyidx>0 ){
527: int i;
528: fprintf(yyTraceFILE,"%sShift %d\n",yyTracePrompt,yyNewState);
529: fprintf(yyTraceFILE,"%sStack:",yyTracePrompt);
530: for(i=1; i<=yypParser->yyidx; i++)
531: fprintf(yyTraceFILE," %s",yyTokenName[yypParser->yystack[i].major]);
532: fprintf(yyTraceFILE,"\n");
533: }
534: #endif
535: }
536:
537: /* The following table contains information about every rule that
538: ** is used during the reduce.
539: */
540: static const struct {
541: YYCODETYPE lhs; /* Symbol on the left-hand side of the rule */
542: unsigned char nrhs; /* Number of right-hand side symbols in the rule */
543: } yyRuleInfo[] = {
544: %%
545: };
546:
547: static void yy_accept(yyParser*); /* Forward Declaration */
548:
549: /*
550: ** Perform a reduce action and the shift that must immediately
551: ** follow the reduce.
552: */
553: static void yy_reduce(
554: yyParser *yypParser, /* The parser */
555: int yyruleno /* Number of the rule by which to reduce */
556: ){
557: int yygoto; /* The next state */
558: int yyact; /* The next action */
559: YYMINORTYPE yygotominor; /* The LHS of the rule reduced */
560: yyStackEntry *yymsp; /* The top of the parser's stack */
561: int yysize; /* Amount to pop the stack */
562: ParseARG_FETCH;
563: yymsp = &yypParser->yystack[yypParser->yyidx];
564: #ifndef NDEBUG
565: if( yyTraceFILE && yyruleno>=0
566: && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){
567: fprintf(yyTraceFILE, "%sReduce [%s].\n", yyTracePrompt,
568: yyRuleName[yyruleno]);
569: }
570: #endif /* NDEBUG */
571:
572: /* Silence complaints from purify about yygotominor being uninitialized
573: ** in some cases when it is copied into the stack after the following
574: ** switch. yygotominor is uninitialized when a rule reduces that does
575: ** not set the value of its left-hand side nonterminal. Leaving the
576: ** value of the nonterminal uninitialized is utterly harmless as long
577: ** as the value is never used. So really the only thing this code
578: ** accomplishes is to quieten purify.
579: **
580: ** 2007-01-16: The wireshark project (www.wireshark.org) reports that
581: ** without this code, their parser segfaults. I'm not sure what there
582: ** parser is doing to make this happen. This is the second bug report
583: ** from wireshark this week. Clearly they are stressing Lemon in ways
584: ** that it has not been previously stressed... (SQLite ticket #2172)
585: */
586: /*memset(&yygotominor, 0, sizeof(yygotominor));*/
587: yygotominor = yyzerominor;
588:
589:
590: switch( yyruleno ){
591: /* Beginning here are the reduction cases. A typical example
592: ** follows:
593: ** case 0:
594: ** #line <lineno> <grammarfile>
595: ** { ... } // User supplied code
596: ** #line <lineno> <thisfile>
597: ** break;
598: */
599: %%
600: };
601: yygoto = yyRuleInfo[yyruleno].lhs;
602: yysize = yyRuleInfo[yyruleno].nrhs;
603: yypParser->yyidx -= yysize;
604: yyact = yy_find_reduce_action(yymsp[-yysize].stateno,(YYCODETYPE)yygoto);
605: if( yyact < YYNSTATE ){
606: #ifdef NDEBUG
607: /* If we are not debugging and the reduce action popped at least
608: ** one element off the stack, then we can push the new element back
609: ** onto the stack here, and skip the stack overflow test in yy_shift().
610: ** That gives a significant speed improvement. */
611: if( yysize ){
612: yypParser->yyidx++;
613: yymsp -= yysize-1;
614: yymsp->stateno = (YYACTIONTYPE)yyact;
615: yymsp->major = (YYCODETYPE)yygoto;
616: yymsp->minor = yygotominor;
617: }else
618: #endif
619: {
620: yy_shift(yypParser,yyact,yygoto,&yygotominor);
621: }
622: }else{
623: assert( yyact == YYNSTATE + YYNRULE + 1 );
624: yy_accept(yypParser);
625: }
626: }
627:
628: /*
629: ** The following code executes when the parse fails
630: */
631: #ifndef YYNOERRORRECOVERY
632: static void yy_parse_failed(
633: yyParser *yypParser /* The parser */
634: ){
635: ParseARG_FETCH;
636: #ifndef NDEBUG
637: if( yyTraceFILE ){
638: fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt);
639: }
640: #endif
641: while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
642: /* Here code is inserted which will be executed whenever the
643: ** parser fails */
644: %%
645: ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
646: }
647: #endif /* YYNOERRORRECOVERY */
648:
649: /*
650: ** The following code executes when a syntax error first occurs.
651: */
652: static void yy_syntax_error(
653: yyParser *yypParser, /* The parser */
654: int yymajor, /* The major type of the error token */
655: YYMINORTYPE yyminor /* The minor type of the error token */
656: ){
657: ParseARG_FETCH;
658: #define TOKEN (yyminor.yy0)
659: %%
660: ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
661: }
662:
663: /*
664: ** The following is executed when the parser accepts
665: */
666: static void yy_accept(
667: yyParser *yypParser /* The parser */
668: ){
669: ParseARG_FETCH;
670: #ifndef NDEBUG
671: if( yyTraceFILE ){
672: fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt);
673: }
674: #endif
675: while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
676: /* Here code is inserted which will be executed whenever the
677: ** parser accepts */
678: %%
679: ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
680: }
681:
682: /* The main parser program.
683: ** The first argument is a pointer to a structure obtained from
684: ** "ParseAlloc" which describes the current state of the parser.
685: ** The second argument is the major token number. The third is
686: ** the minor token. The fourth optional argument is whatever the
687: ** user wants (and specified in the grammar) and is available for
688: ** use by the action routines.
689: **
690: ** Inputs:
691: ** <ul>
692: ** <li> A pointer to the parser (an opaque structure.)
693: ** <li> The major token number.
694: ** <li> The minor token number.
695: ** <li> An option argument of a grammar-specified type.
696: ** </ul>
697: **
698: ** Outputs:
699: ** None.
700: */
701: void Parse(
702: void *yyp, /* The parser */
703: int yymajor, /* The major token code number */
704: ParseTOKENTYPE yyminor /* The value for the token */
705: ParseARG_PDECL /* Optional %extra_argument parameter */
706: ){
707: YYMINORTYPE yyminorunion;
708: int yyact; /* The parser action. */
709: int yyendofinput; /* True if we are at the end of input */
710: #ifdef YYERRORSYMBOL
711: int yyerrorhit = 0; /* True if yymajor has invoked an error */
712: #endif
713: yyParser *yypParser; /* The parser */
714:
715: /* (re)initialize the parser, if necessary */
716: yypParser = (yyParser*)yyp;
717: if( yypParser->yyidx<0 ){
718: #if YYSTACKDEPTH<=0
719: if( yypParser->yystksz <=0 ){
720: /*memset(&yyminorunion, 0, sizeof(yyminorunion));*/
721: yyminorunion = yyzerominor;
722: yyStackOverflow(yypParser, &yyminorunion);
723: return;
724: }
725: #endif
726: yypParser->yyidx = 0;
727: yypParser->yyerrcnt = -1;
728: yypParser->yystack[0].stateno = 0;
729: yypParser->yystack[0].major = 0;
730: }
731: yyminorunion.yy0 = yyminor;
732: yyendofinput = (yymajor==0);
733: ParseARG_STORE;
734:
735: #ifndef NDEBUG
736: if( yyTraceFILE ){
737: fprintf(yyTraceFILE,"%sInput %s\n",yyTracePrompt,yyTokenName[yymajor]);
738: }
739: #endif
740:
741: do{
742: yyact = yy_find_shift_action(yypParser,(YYCODETYPE)yymajor);
743: if( yyact<YYNSTATE ){
744: assert( !yyendofinput ); /* Impossible to shift the $ token */
745: yy_shift(yypParser,yyact,yymajor,&yyminorunion);
746: yypParser->yyerrcnt--;
747: yymajor = YYNOCODE;
748: }else if( yyact < YYNSTATE + YYNRULE ){
749: yy_reduce(yypParser,yyact-YYNSTATE);
750: }else{
751: assert( yyact == YY_ERROR_ACTION );
752: #ifdef YYERRORSYMBOL
753: int yymx;
754: #endif
755: #ifndef NDEBUG
756: if( yyTraceFILE ){
757: fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt);
758: }
759: #endif
760: #ifdef YYERRORSYMBOL
761: /* A syntax error has occurred.
762: ** The response to an error depends upon whether or not the
763: ** grammar defines an error token "ERROR".
764: **
765: ** This is what we do if the grammar does define ERROR:
766: **
767: ** * Call the %syntax_error function.
768: **
769: ** * Begin popping the stack until we enter a state where
770: ** it is legal to shift the error symbol, then shift
771: ** the error symbol.
772: **
773: ** * Set the error count to three.
774: **
775: ** * Begin accepting and shifting new tokens. No new error
776: ** processing will occur until three tokens have been
777: ** shifted successfully.
778: **
779: */
780: if( yypParser->yyerrcnt<0 ){
781: yy_syntax_error(yypParser,yymajor,yyminorunion);
782: }
783: yymx = yypParser->yystack[yypParser->yyidx].major;
784: if( yymx==YYERRORSYMBOL || yyerrorhit ){
785: #ifndef NDEBUG
786: if( yyTraceFILE ){
787: fprintf(yyTraceFILE,"%sDiscard input token %s\n",
788: yyTracePrompt,yyTokenName[yymajor]);
789: }
790: #endif
791: yy_destructor(yypParser, (YYCODETYPE)yymajor,&yyminorunion);
792: yymajor = YYNOCODE;
793: }else{
794: while(
795: yypParser->yyidx >= 0 &&
796: yymx != YYERRORSYMBOL &&
797: (yyact = yy_find_reduce_action(
798: yypParser->yystack[yypParser->yyidx].stateno,
799: YYERRORSYMBOL)) >= YYNSTATE
800: ){
801: yy_pop_parser_stack(yypParser);
802: }
803: if( yypParser->yyidx < 0 || yymajor==0 ){
804: yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
805: yy_parse_failed(yypParser);
806: yymajor = YYNOCODE;
807: }else if( yymx!=YYERRORSYMBOL ){
808: YYMINORTYPE u2;
809: u2.YYERRSYMDT = 0;
810: yy_shift(yypParser,yyact,YYERRORSYMBOL,&u2);
811: }
812: }
813: yypParser->yyerrcnt = 3;
814: yyerrorhit = 1;
815: #elif defined(YYNOERRORRECOVERY)
816: /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
817: ** do any kind of error recovery. Instead, simply invoke the syntax
818: ** error routine and continue going as if nothing had happened.
819: **
820: ** Applications can set this macro (for example inside %include) if
821: ** they intend to abandon the parse upon the first syntax error seen.
822: */
823: yy_syntax_error(yypParser,yymajor,yyminorunion);
824: yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
825: yymajor = YYNOCODE;
826:
827: #else /* YYERRORSYMBOL is not defined */
828: /* This is what we do if the grammar does not define ERROR:
829: **
830: ** * Report an error message, and throw away the input token.
831: **
832: ** * If the input token is $, then fail the parse.
833: **
834: ** As before, subsequent error messages are suppressed until
835: ** three input tokens have been successfully shifted.
836: */
837: if( yypParser->yyerrcnt<=0 ){
838: yy_syntax_error(yypParser,yymajor,yyminorunion);
839: }
840: yypParser->yyerrcnt = 3;
841: yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
842: if( yyendofinput ){
843: yy_parse_failed(yypParser);
844: }
845: yymajor = YYNOCODE;
846: #endif
847: }
848: }while( yymajor!=YYNOCODE && yypParser->yyidx>=0 );
849: return;
850: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to lempar.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / tool