| blob | 64e930f27ede7608e71f85bdd5b47a19aa0ebd7d |
1 /* -*-C-*- Note some compilers choke on comments on `#line' lines. */\r
2 #line 3 "cfbison.simple"\r
3 /* This file comes from bison-1.28. */\r
4 \r
5 /* Skeleton output parser for bison,\r
6 Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.\r
7 \r
8 This program is free software; you can redistribute it and/or modify\r
9 it under the terms of the GNU General Public License as published by\r
10 the Free Software Foundation; either version 2, or (at your option)\r
11 any later version.\r
12 \r
13 This program is distributed in the hope that it will be useful,\r
14 but WITHOUT ANY WARRANTY; without even the implied warranty of\r
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r
16 GNU General Public License for more details.\r
17 \r
18 You should have received a copy of the GNU General Public License\r
19 along with this program; if not, write to the Free Software\r
20 Foundation, Inc., 59 Temple Place - Suite 330,\r
21 Boston, MA 02111-1307, USA. */\r
22 \r
23 /* As a special exception, when this file is copied by Bison into a\r
24 Bison output file, you may use that output file without restriction.\r
25 This special exception was added by the Free Software Foundation\r
26 in version 1.24 of Bison. */\r
27 \r
28 /* This is the parser code that is written into each bison parser\r
29 when the %semantic_parser declaration is not specified in the grammar.\r
30 It was written by Richard Stallman by simplifying the hairy parser\r
31 used when %semantic_parser is specified. */\r
32 \r
33 #ifndef YYSTACK_USE_ALLOCA\r
34 #ifdef alloca\r
35 #define YYSTACK_USE_ALLOCA\r
36 #else /* alloca not defined */\r
37 #ifdef __GNUC__\r
38 #define YYSTACK_USE_ALLOCA\r
39 #define alloca __builtin_alloca\r
40 #else /* not GNU C. */\r
41 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))\r
42 #define YYSTACK_USE_ALLOCA\r
43 #include <alloca.h>\r
44 #else /* not sparc */\r
45 /* We think this test detects Watcom and Microsoft C. */\r
46 /* This used to test MSDOS, but that is a bad idea\r
47 since that symbol is in the user namespace. */\r
48 #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)\r
49 #if 0 /* No need for malloc.h, which pollutes the namespace;\r
50 instead, just don't use alloca. */\r
51 #include <malloc.h>\r
52 #endif\r
53 #else /* not MSDOS, or __TURBOC__ */\r
54 #if defined(_AIX)\r
55 /* I don't know what this was needed for, but it pollutes the namespace.\r
56 So I turned it off. rms, 2 May 1997. */\r
57 /* #include <malloc.h> */\r
58 #pragma alloca\r
59 #define YYSTACK_USE_ALLOCA\r
60 #else /* not MSDOS, or __TURBOC__, or _AIX */\r
61 #if 0\r
62 #ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,\r
63 and on HPUX 10. Eventually we can turn this on. */\r
64 #define YYSTACK_USE_ALLOCA\r
65 #define alloca __builtin_alloca\r
66 #endif /* __hpux */\r
67 #endif\r
68 #endif /* not _AIX */\r
69 #endif /* not MSDOS, or __TURBOC__ */\r
70 #endif /* not sparc */\r
71 #endif /* not GNU C */\r
72 #endif /* alloca not defined */\r
73 #endif /* YYSTACK_USE_ALLOCA not defined */\r
74 \r
75 #ifdef YYSTACK_USE_ALLOCA\r
76 #define YYSTACK_ALLOC alloca\r
77 #else\r
78 #define YYSTACK_ALLOC malloc\r
79 #endif\r
80 \r
81 /* Note: there must be only one dollar sign in this file.\r
82 It is replaced by the list of actions, each action\r
83 as one case of the switch. */\r
84 \r
85 #define yyerrok (yyerrstatus = 0)\r
86 #define yyclearin (yychar = YYEMPTY)\r
87 #define YYEMPTY -2\r
88 #define YYEOF 0\r
89 #define YYACCEPT goto yyacceptlab\r
90 #define YYABORT goto yyabortlab\r
91 #define YYERROR goto yyerrlab1\r
92 /* Like YYERROR except do call yyerror.\r
93 This remains here temporarily to ease the\r
94 transition to the new meaning of YYERROR, for GCC.\r
95 Once GCC version 2 has supplanted version 1, this can go. */\r
96 #define YYFAIL goto yyerrlab\r
97 #define YYRECOVERING() (!!yyerrstatus)\r
98 #define YYBACKUP(token, value) \\r
99 do \\r
100 if (yychar == YYEMPTY && yylen == 1) \\r
101 { yychar = (token), yylval = (value); \\r
102 yychar1 = YYTRANSLATE (yychar); \\r
103 YYPOPSTACK; \\r
104 goto yybackup; \\r
105 } \\r
106 else \\r
107 { yyerror ("syntax error: cannot back up"); YYERROR; } \\r
108 while (0)\r
109 \r
110 #define YYTERROR 1\r
111 #define YYERRCODE 256\r
112 \r
113 #ifndef YYPURE\r
114 #define YYLEX yylex()\r
115 #endif\r
116 \r
117 #ifdef YYPURE\r
118 #ifdef YYLSP_NEEDED\r
119 #ifdef YYLEX_PARAM\r
120 #define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM)\r
121 #else\r
122 #define YYLEX yylex(&yylval, &yylloc)\r
123 #endif\r
124 #else /* not YYLSP_NEEDED */\r
125 #ifdef YYLEX_PARAM\r
126 #define YYLEX yylex(&yylval, YYLEX_PARAM)\r
127 #else\r
128 #define YYLEX yylex(&yylval)\r
129 #endif\r
130 #endif /* not YYLSP_NEEDED */\r
131 #endif\r
132 \r
133 /* If nonreentrant, generate the variables here */\r
134 \r
135 #ifndef YYPURE\r
136 \r
137 int yychar; /* the lookahead symbol */\r
138 YYSTYPE yylval; /* the semantic value of the */\r
139 /* lookahead symbol */\r
140 \r
141 #ifdef YYLSP_NEEDED\r
142 YYLTYPE yylloc; /* location data for the lookahead */\r
143 /* symbol */\r
144 #endif\r
145 \r
146 int yynerrs; /* number of parse errors so far */\r
147 #endif /* not YYPURE */\r
148 \r
149 #if YYDEBUG != 0\r
150 int yydebug; /* nonzero means print parse trace */\r
151 /* Since this is uninitialized, it does not stop multiple parsers\r
152 from coexisting. */\r
153 #endif\r
154 \r
155 /* YYINITDEPTH indicates the initial size of the parser's stacks */\r
156 \r
157 #ifndef YYINITDEPTH\r
158 #define YYINITDEPTH 200\r
159 #endif\r
160 \r
161 /* YYMAXDEPTH is the maximum size the stacks can grow to\r
162 (effective only if the built-in stack extension method is used). */\r
163 \r
164 #if YYMAXDEPTH == 0\r
165 #undef YYMAXDEPTH\r
166 #endif\r
167 \r
168 #ifndef YYMAXDEPTH\r
169 #define YYMAXDEPTH 10000\r
170 #endif\r
172 /* Define __yy_memcpy. Note that the size argument\r
173 should be passed with type unsigned int, because that is what the non-GCC\r
174 definitions require. With GCC, __builtin_memcpy takes an arg\r
175 of type size_t, but it can handle unsigned int. */\r
176 \r
177 #if __GNUC__ > 1 /* GNU C and GNU C++ define this. */\r
178 #define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT)\r
179 #else /* not GNU C or C++ */\r
180 #ifndef __cplusplus\r
181 \r
182 /* This is the most reliable way to avoid incompatibilities\r
183 in available built-in functions on various systems. */\r
184 static void\r
185 __yy_memcpy (to, from, count)\r
186 char *to;\r
187 char *from;\r
188 unsigned int count;\r
189 {\r
190 register char *f = from;\r
191 register char *t = to;\r
192 register int i = count;\r
193 \r
194 while (i-- > 0)\r
195 *t++ = *f++;\r
196 }\r
197 \r
198 #else /* __cplusplus */\r
199 \r
200 /* This is the most reliable way to avoid incompatibilities\r
201 in available built-in functions on various systems. */\r
202 static void\r
203 __yy_memcpy (char *to, char *from, unsigned int count)\r
204 {\r
205 register char *t = to;\r
206 register char *f = from;\r
207 register int i = count;\r
208 \r
209 while (i-- > 0)\r
210 *t++ = *f++;\r
211 }\r
212 \r
213 #endif\r
214 #endif\r
216 #line 217 "cfbison.simple"\r
217 \r
218 /* The user can define YYPARSE_PARAM as the name of an argument to be passed\r
219 into yyparse. The argument should have type void *.\r
220 It should actually point to an object.\r
221 Grammar actions can access the variable by casting it\r
222 to the proper pointer type. */\r
223 \r
224 #ifdef YYPARSE_PARAM\r
225 #ifdef __cplusplus\r
226 #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM\r
227 #define YYPARSE_PARAM_DECL\r
228 #else /* not __cplusplus */\r
229 #define YYPARSE_PARAM_ARG YYPARSE_PARAM\r
230 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;\r
231 #endif /* not __cplusplus */\r
232 #else /* not YYPARSE_PARAM */\r
233 #define YYPARSE_PARAM_ARG\r
234 #define YYPARSE_PARAM_DECL\r
235 #endif /* not YYPARSE_PARAM */\r
236 \r
237 /* Prevent warning if -Wstrict-prototypes. */\r
238 #ifdef __GNUC__\r
239 #ifdef YYPARSE_PARAM\r
240 int yyparse (void *);\r
241 #else\r
242 int yyparse (void);\r
243 #endif\r
244 #endif\r
245 \r
246 int\r
247 yyparse(YYPARSE_PARAM_ARG)\r
248 YYPARSE_PARAM_DECL\r
249 {\r
250 register int yystate;\r
251 register int yyn;\r
252 register short *yyssp;\r
253 register YYSTYPE *yyvsp;\r
254 int yyerrstatus; /* number of tokens to shift before error messages enabled */\r
255 int yychar1 = 0; /* lookahead token as an internal (translated) token number */\r
256 \r
257 short yyssa[YYINITDEPTH]; /* the state stack */\r
258 YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */\r
259 \r
260 short *yyss = yyssa; /* refer to the stacks thru separate pointers */\r
261 YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */\r
262 \r
263 #ifdef YYLSP_NEEDED\r
264 YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */\r
265 YYLTYPE *yyls = yylsa;\r
266 YYLTYPE *yylsp;\r
267 \r
268 #define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)\r
269 #else\r
270 #define YYPOPSTACK (yyvsp--, yyssp--)\r
271 #endif\r
272 \r
273 int yystacksize = YYINITDEPTH;\r
274 int yyfree_stacks = 0;\r
275 \r
276 #ifdef YYPURE\r
277 int yychar;\r
278 YYSTYPE yylval;\r
279 int yynerrs;\r
280 #ifdef YYLSP_NEEDED\r
281 YYLTYPE yylloc;\r
282 #endif\r
283 #endif\r
284 \r
285 YYSTYPE yyval; /* the variable used to return */\r
286 /* semantic values from the action */\r
287 /* routines */\r
288 // ace: big fake for VC7 because it checks if yyval is init or not\r
289 yyval.Val.Int = 0;\r
290 int yylen;\r
291 \r
292 #if YYDEBUG != 0\r
293 if (yydebug)\r
294 fprintf(stderr, "Starting parse\n");\r
295 #endif\r
296 \r
297 yystate = 0;\r
298 yyerrstatus = 0;\r
299 yynerrs = 0;\r
300 yychar = YYEMPTY; /* Cause a token to be read. */\r
301 \r
302 /* Initialize stack pointers.\r
303 Waste one element of value and location stack\r
304 so that they stay on the same level as the state stack.\r
305 The wasted elements are never initialized. */\r
306 \r
307 yyssp = yyss - 1;\r
308 yyvsp = yyvs;\r
309 #ifdef YYLSP_NEEDED\r
310 yylsp = yyls;\r
311 #endif\r
312 \r
313 /* Push a new state, which is found in yystate . */\r
314 /* In all cases, when you get here, the value and location stacks\r
315 have just been pushed. so pushing a state here evens the stacks. */\r
316 yynewstate:\r
317 \r
318 *++yyssp = yystate;\r
319 \r
320 if (yyssp >= yyss + yystacksize - 1)\r
321 {\r
322 /* Give user a chance to reallocate the stack */\r
323 /* Use copies of these so that the &'s don't force the real ones into memory. */\r
324 YYSTYPE *yyvs1 = yyvs;\r
325 short *yyss1 = yyss;\r
326 #ifdef YYLSP_NEEDED\r
327 YYLTYPE *yyls1 = yyls;\r
328 #endif\r
329 \r
330 /* Get the current used size of the three stacks, in elements. */\r
331 int size = (int)(yyssp - yyss + 1);\r
332 \r
333 #ifdef yyoverflow\r
334 /* Each stack pointer address is followed by the size of\r
335 the data in use in that stack, in bytes. */\r
336 #ifdef YYLSP_NEEDED\r
337 /* This used to be a conditional around just the two extra args,\r
338 but that might be undefined if yyoverflow is a macro. */\r
339 yyoverflow("parser stack overflow",\r
340 &yyss1, size * sizeof (*yyssp),\r
341 &yyvs1, size * sizeof (*yyvsp),\r
342 &yyls1, size * sizeof (*yylsp),\r
343 &yystacksize);\r
344 #else\r
345 yyoverflow("parser stack overflow",\r
346 &yyss1, size * sizeof (*yyssp),\r
347 &yyvs1, size * sizeof (*yyvsp),\r
348 &yystacksize);\r
349 #endif\r
350 \r
351 yyss = yyss1; yyvs = yyvs1;\r
352 #ifdef YYLSP_NEEDED\r
353 yyls = yyls1;\r
354 #endif\r
355 #else /* no yyoverflow */\r
356 /* Extend the stack our own way. */\r
357 if (yystacksize >= YYMAXDEPTH)\r
358 {\r
359 yyerror("parser stack overflow");\r
360 if (yyfree_stacks)\r
361 {\r
362 free (yyss);\r
363 free (yyvs);\r
364 #ifdef YYLSP_NEEDED\r
365 free (yyls);\r
366 #endif\r
367 }\r
368 return 2;\r
369 }\r
370 yystacksize *= 2;\r
371 if (yystacksize > YYMAXDEPTH)\r
372 yystacksize = YYMAXDEPTH;\r
373 #ifndef YYSTACK_USE_ALLOCA\r
374 yyfree_stacks = 1;\r
375 #endif\r
376 yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));\r
377 __yy_memcpy ((char *)yyss, (char *)yyss1,\r
378 size * (unsigned int) sizeof (*yyssp));\r
379 yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));\r
380 __yy_memcpy ((char *)yyvs, (char *)yyvs1,\r
381 size * (unsigned int) sizeof (*yyvsp));\r
382 #ifdef YYLSP_NEEDED\r
383 yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));\r
384 __yy_memcpy ((char *)yyls, (char *)yyls1,\r
385 size * (unsigned int) sizeof (*yylsp));\r
386 #endif\r
387 #endif /* no yyoverflow */\r
388 \r
389 yyssp = yyss + size - 1;\r
390 yyvsp = yyvs + size - 1;\r
391 #ifdef YYLSP_NEEDED\r
392 yylsp = yyls + size - 1;\r
393 #endif\r
394 \r
395 #if YYDEBUG != 0\r
396 if (yydebug)\r
397 fprintf(stderr, "Stack size increased to %d\n", yystacksize);\r
398 #endif\r
399 \r
400 if (yyssp >= yyss + yystacksize - 1)\r
401 YYABORT;\r
402 }\r
403 \r
404 #if YYDEBUG != 0\r
405 if (yydebug)\r
406 fprintf(stderr, "Entering state %d\n", yystate);\r
407 #endif\r
408 \r
409 goto yybackup;\r
410 yybackup:\r
411 \r
412 /* Do appropriate processing given the current state. */\r
413 /* Read a lookahead token if we need one and don't already have one. */\r
414 /* yyresume: */\r
415 \r
416 /* First try to decide what to do without reference to lookahead token. */\r
417 \r
418 yyn = yypact[yystate];\r
419 if (yyn == YYFLAG)\r
420 goto yydefault;\r
421 \r
422 /* Not known => get a lookahead token if don't already have one. */\r
423 \r
424 /* yychar is either YYEMPTY or YYEOF\r
425 or a valid token in external form. */\r
426 \r
427 if (yychar == YYEMPTY)\r
428 {\r
429 #if YYDEBUG != 0\r
430 if (yydebug)\r
431 fprintf(stderr, "Reading a token: ");\r
432 #endif\r
433 yychar = YYLEX;\r
434 }\r
435 \r
436 /* Convert token to internal form (in yychar1) for indexing tables with */\r
437 \r
438 if (yychar <= 0) /* This means end of input. */\r
439 {\r
440 yychar1 = 0;\r
441 yychar = YYEOF; /* Don't call YYLEX any more */\r
442 \r
443 #if YYDEBUG != 0\r
444 if (yydebug)\r
445 fprintf(stderr, "Now at end of input.\n");\r
446 #endif\r
447 }\r
448 else\r
449 {\r
450 yychar1 = YYTRANSLATE(yychar);\r
451 \r
452 #if YYDEBUG != 0\r
453 if (yydebug)\r
454 {\r
455 fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);\r
456 /* Give the individual parser a way to print the precise meaning\r
457 of a token, for further debugging info. */\r
458 #ifdef YYPRINT\r
459 YYPRINT (stderr, yychar, yylval);\r
460 #endif\r
461 fprintf (stderr, ")\n");\r
462 }\r
463 #endif\r
464 }\r
465 \r
466 yyn += yychar1;\r
467 if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)\r
468 goto yydefault;\r
469 \r
470 yyn = yytable[yyn];\r
471 \r
472 /* yyn is what to do for this token type in this state.\r
473 Negative => reduce, -yyn is rule number.\r
474 Positive => shift, yyn is new state.\r
475 New state is final state => don't bother to shift,\r
476 just return success.\r
477 0, or most negative number => error. */\r
478 \r
479 if (yyn < 0)\r
480 {\r
481 if (yyn == YYFLAG)\r
482 goto yyerrlab;\r
483 yyn = -yyn;\r
484 goto yyreduce;\r
485 }\r
486 else if (yyn == 0)\r
487 goto yyerrlab;\r
488 \r
489 if (yyn == YYFINAL)\r
490 YYACCEPT;\r
491 \r
492 /* Shift the lookahead token. */\r
493 \r
494 #if YYDEBUG != 0\r
495 if (yydebug)\r
496 fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);\r
497 #endif\r
498 \r
499 /* Discard the token being shifted unless it is eof. */\r
500 if (yychar != YYEOF)\r
501 yychar = YYEMPTY;\r
502 \r
503 *++yyvsp = yylval;\r
504 #ifdef YYLSP_NEEDED\r
505 *++yylsp = yylloc;\r
506 #endif\r
507 \r
508 /* count tokens shifted since error; after three, turn off error status. */\r
509 if (yyerrstatus) yyerrstatus--;\r
510 \r
511 yystate = yyn;\r
512 goto yynewstate;\r
513 \r
514 /* Do the default action for the current state. */\r
515 yydefault:\r
516 \r
517 yyn = yydefact[yystate];\r
518 if (yyn == 0)\r
519 goto yyerrlab;\r
520 \r
521 /* Do a reduction. yyn is the number of a rule to reduce with. */\r
522 yyreduce:\r
523 yylen = yyr2[yyn];\r
524 if (yylen > 0)\r
525 yyval = yyvsp[1-yylen]; /* implement default value of the action */\r
526 \r
527 #if YYDEBUG != 0\r
528 if (yydebug)\r
529 {\r
530 int i;\r
531 \r
532 fprintf (stderr, "Reducing via rule %d (line %d), ",\r
533 yyn, yyrline[yyn]);\r
534 \r
535 /* Print the symbols being reduced, and their result. */\r
536 for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)\r
537 fprintf (stderr, "%s ", yytname[yyrhs[i]]);\r
538 fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);\r
539 }\r
540 #endif\r
541 \r
542 $ /* the action file gets copied in in place of this dollarsign */\r
543 #line 543 "cfbison.simple"\r
545 yyvsp -= yylen;\r
546 yyssp -= yylen;\r
547 #ifdef YYLSP_NEEDED\r
548 yylsp -= yylen;\r
549 #endif\r
550 \r
551 #if YYDEBUG != 0\r
552 if (yydebug)\r
553 {\r
554 short *ssp1 = yyss - 1;\r
555 fprintf (stderr, "state stack now");\r
556 while (ssp1 != yyssp)\r
557 fprintf (stderr, " %d", *++ssp1);\r
558 fprintf (stderr, "\n");\r
559 }\r
560 #endif\r
561 \r
562 *++yyvsp = yyval;\r
563 \r
564 #ifdef YYLSP_NEEDED\r
565 yylsp++;\r
566 if (yylen == 0)\r
567 {\r
568 yylsp->first_line = yylloc.first_line;\r
569 yylsp->first_column = yylloc.first_column;\r
570 yylsp->last_line = (yylsp-1)->last_line;\r
571 yylsp->last_column = (yylsp-1)->last_column;\r
572 yylsp->text = 0;\r
573 }\r
574 else\r
575 {\r
576 yylsp->last_line = (yylsp+yylen-1)->last_line;\r
577 yylsp->last_column = (yylsp+yylen-1)->last_column;\r
578 }\r
579 #endif\r
580 \r
581 /* Now "shift" the result of the reduction.\r
582 Determine what state that goes to,\r
583 based on the state we popped back to\r
584 and the rule number reduced by. */\r
585 \r
586 yyn = yyr1[yyn];\r
587 \r
588 yystate = yypgoto[yyn - YYNTBASE] + *yyssp;\r
589 if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)\r
590 yystate = yytable[yystate];\r
591 else\r
592 yystate = yydefgoto[yyn - YYNTBASE];\r
593 \r
594 goto yynewstate;\r
595 \r
596 yyerrlab: /* here on detecting error */\r
597 \r
598 if (! yyerrstatus)\r
599 /* If not already recovering from an error, report this error. */\r
600 {\r
601 ++yynerrs;\r
602 \r
603 #ifdef YYERROR_VERBOSE\r
604 yyn = yypact[yystate];\r
605 \r
606 if (yyn > YYFLAG && yyn < YYLAST)\r
607 {\r
608 int size = 0;\r
609 char *msg;\r
610 int x, count;\r
611 \r
612 count = 0;\r
613 /* Start X at -yyn if nec to avoid negative indexes in yycheck. */\r
614 for (x = (yyn < 0 ? -yyn : 0);\r
615 x < (sizeof(yytname) / sizeof(char *)); x++)\r
616 if (yycheck[x + yyn] == x)\r
617 size += strlen(yytname[x]) + 15, count++;\r
618 msg = (char *) malloc(size + 15);\r
619 if (msg != 0)\r
620 {\r
621 strcpy(msg, "parse error");\r
622 \r
623 if (count < 5)\r
624 {\r
625 count = 0;\r
626 for (x = (yyn < 0 ? -yyn : 0);\r
627 x < (sizeof(yytname) / sizeof(char *)); x++)\r
628 if (yycheck[x + yyn] == x)\r
629 {\r
630 strcat(msg, count == 0 ? ", expecting `" : " or `");\r
631 strcat(msg, yytname[x]);\r
632 strcat(msg, "'");\r
633 count++;\r
634 }\r
635 }\r
636 yyerror(msg);\r
637 free(msg);\r
638 }\r
639 else\r
640 yyerror ("parse error; also virtual memory exceeded");\r
641 }\r
642 else\r
643 #endif /* YYERROR_VERBOSE */\r
644 yyerror("parse error");\r
645 }\r
646 \r
647 goto yyerrlab1;\r
648 yyerrlab1: /* here on error raised explicitly by an action */\r
649 \r
650 if (yyerrstatus == 3)\r
651 {\r
652 /* if just tried and failed to reuse lookahead token after an error, discard it. */\r
653 \r
654 /* return failure if at end of input */\r
655 if (yychar == YYEOF)\r
656 YYABORT;\r
657 \r
658 #if YYDEBUG != 0\r
659 if (yydebug)\r
660 fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);\r
661 #endif\r
662 \r
663 yychar = YYEMPTY;\r
664 }\r
665 \r
666 /* Else will try to reuse lookahead token\r
667 after shifting the error token. */\r
668 \r
669 yyerrstatus = 3; /* Each real token shifted decrements this */\r
670 \r
671 goto yyerrhandle;\r
672 \r
673 yyerrdefault: /* current state does not do anything special for the error token. */\r
674 \r
675 #if 0\r
676 /* This is wrong; only states that explicitly want error tokens\r
677 should shift them. */\r
678 yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/\r
679 if (yyn) goto yydefault;\r
680 #endif\r
681 \r
682 yyerrpop: /* pop the current state because it cannot handle the error token */\r
683 \r
684 if (yyssp == yyss) YYABORT;\r
685 yyvsp--;\r
686 yystate = *--yyssp;\r
687 #ifdef YYLSP_NEEDED\r
688 yylsp--;\r
689 #endif\r
690 \r
691 #if YYDEBUG != 0\r
692 if (yydebug)\r
693 {\r
694 short *ssp1 = yyss - 1;\r
695 fprintf (stderr, "Error: state stack now");\r
696 while (ssp1 != yyssp)\r
697 fprintf (stderr, " %d", *++ssp1);\r
698 fprintf (stderr, "\n");\r
699 }\r
700 #endif\r
701 \r
702 yyerrhandle:\r
703 \r
704 yyn = yypact[yystate];\r
705 if (yyn == YYFLAG)\r
706 goto yyerrdefault;\r
707 \r
708 yyn += YYTERROR;\r
709 if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)\r
710 goto yyerrdefault;\r
711 \r
712 yyn = yytable[yyn];\r
713 if (yyn < 0)\r
714 {\r
715 if (yyn == YYFLAG)\r
716 goto yyerrpop;\r
717 yyn = -yyn;\r
718 goto yyreduce;\r
719 }\r
720 else if (yyn == 0)\r
721 goto yyerrpop;\r
722 \r
723 if (yyn == YYFINAL)\r
724 YYACCEPT;\r
725 \r
726 #if YYDEBUG != 0\r
727 if (yydebug)\r
728 fprintf(stderr, "Shifting error token, ");\r
729 #endif\r
730 \r
731 *++yyvsp = yylval;\r
732 #ifdef YYLSP_NEEDED\r
733 *++yylsp = yylloc;\r
734 #endif\r
735 \r
736 yystate = yyn;\r
737 goto yynewstate;\r
738 \r
739 yyacceptlab:\r
740 /* YYACCEPT comes here. */\r
741 if (yyfree_stacks)\r
742 {\r
743 free (yyss);\r
744 free (yyvs);\r
745 #ifdef YYLSP_NEEDED\r
746 free (yyls);\r
747 #endif\r
748 }\r
749 return 0;\r
750 \r
751 yyabortlab:\r
752 /* YYABORT comes here. */\r
753 if (yyfree_stacks)\r
754 {\r
755 free (yyss);\r
756 free (yyvs);\r
757 #ifdef YYLSP_NEEDED\r
758 free (yyls);\r
759 #endif\r
760 }\r
761 return 1;\r
762 }\r