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