diff options
author | David Walter Seikel | 2012-01-24 00:17:38 +1000 |
---|---|---|
committer | David Walter Seikel | 2012-01-24 00:17:38 +1000 |
commit | 6eb12c56c62201b4426fc817493e3a290388033e (patch) | |
tree | 80eb9871d8d8a4854559c2a9b72609f54d91acc2 /LuaSL/src/lempar.c | |
parent | Update .gitignore for the new libraries. (diff) | |
download | SledjHamr-6eb12c56c62201b4426fc817493e3a290388033e.zip SledjHamr-6eb12c56c62201b4426fc817493e3a290388033e.tar.gz SledjHamr-6eb12c56c62201b4426fc817493e3a290388033e.tar.bz2 SledjHamr-6eb12c56c62201b4426fc817493e3a290388033e.tar.xz |
Move the lemon source to the libraries directory.
Diffstat (limited to 'LuaSL/src/lempar.c')
-rw-r--r-- | LuaSL/src/lempar.c | 850 |
1 files changed, 0 insertions, 850 deletions
diff --git a/LuaSL/src/lempar.c b/LuaSL/src/lempar.c deleted file mode 100644 index fe56d2d..0000000 --- a/LuaSL/src/lempar.c +++ /dev/null | |||
@@ -1,850 +0,0 @@ | |||
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 | } | ||