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