1 /* $NetBSD: pure_calc.tab.c,v 1.1.1.1 2015/01/03 22:58:24 christos Exp $ */
2
3 /* original parser id follows */
4 /* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
5 /* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
6
7 #define YYBYACC 1
8 #define YYMAJOR 1
9 #define YYMINOR 9
10 #define YYCHECK "yyyymmdd"
11
12 #define YYEMPTY (-1)
13 #define yyclearin (yychar = YYEMPTY)
14 #define yyerrok (yyerrflag = 0)
15 #define YYRECOVERING() (yyerrflag != 0)
16 #define YYENOMEM (-2)
17 #define YYEOF 0
18
19 #ifndef yyparse
20 #define yyparse calc_parse
21 #endif /* yyparse */
22
23 #ifndef yylex
24 #define yylex calc_lex
25 #endif /* yylex */
26
27 #ifndef yyerror
28 #define yyerror calc_error
29 #endif /* yyerror */
30
31 #ifndef yychar
32 #define yychar calc_char
33 #endif /* yychar */
34
35 #ifndef yyval
36 #define yyval calc_val
37 #endif /* yyval */
38
39 #ifndef yylval
40 #define yylval calc_lval
41 #endif /* yylval */
42
43 #ifndef yydebug
44 #define yydebug calc_debug
45 #endif /* yydebug */
46
47 #ifndef yynerrs
48 #define yynerrs calc_nerrs
49 #endif /* yynerrs */
50
51 #ifndef yyerrflag
52 #define yyerrflag calc_errflag
53 #endif /* yyerrflag */
54
55 #ifndef yylhs
56 #define yylhs calc_lhs
57 #endif /* yylhs */
58
59 #ifndef yylen
60 #define yylen calc_len
61 #endif /* yylen */
62
63 #ifndef yydefred
64 #define yydefred calc_defred
65 #endif /* yydefred */
66
67 #ifndef yydgoto
68 #define yydgoto calc_dgoto
69 #endif /* yydgoto */
70
71 #ifndef yysindex
72 #define yysindex calc_sindex
73 #endif /* yysindex */
74
75 #ifndef yyrindex
76 #define yyrindex calc_rindex
77 #endif /* yyrindex */
78
79 #ifndef yygindex
80 #define yygindex calc_gindex
81 #endif /* yygindex */
82
83 #ifndef yytable
84 #define yytable calc_table
85 #endif /* yytable */
86
87 #ifndef yycheck
88 #define yycheck calc_check
89 #endif /* yycheck */
90
91 #ifndef yyname
92 #define yyname calc_name
93 #endif /* yyname */
94
95 #ifndef yyrule
96 #define yyrule calc_rule
97 #endif /* yyrule */
98 #define YYPREFIX "calc_"
99
100 #define YYPURE 1
101
102 #line 2 "pure_calc.y"
103 # include <stdio.h>
104 # include <ctype.h>
105
106 int regs[26];
107 int base;
108
109 #ifdef YYBISON
110 #define YYSTYPE int
111 #define YYLEX_PARAM &yylval
112 #define YYLEX_DECL() yylex(YYSTYPE *yylval)
113 #define YYERROR_DECL() yyerror(const char *s)
114 int YYLEX_DECL();
115 static void YYERROR_DECL();
116 #endif
117
118 #line 117 "pure_calc.tab.c"
119
120 #if ! defined(YYSTYPE) && ! defined(YYSTYPE_IS_DECLARED)
121 /* Default: YYSTYPE is the semantic value type. */
122 typedef int YYSTYPE;
123 # define YYSTYPE_IS_DECLARED 1
124 #endif
125
126 /* compatibility with bison */
127 #ifdef YYPARSE_PARAM
128 /* compatibility with FreeBSD */
129 # ifdef YYPARSE_PARAM_TYPE
130 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
131 # else
132 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
133 # endif
134 #else
135 # define YYPARSE_DECL() yyparse(void)
136 #endif
137
138 /* Parameters sent to lex. */
139 #ifdef YYLEX_PARAM
140 # ifdef YYLEX_PARAM_TYPE
141 # define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLEX_PARAM_TYPE YYLEX_PARAM)
142 # else
143 # define YYLEX_DECL() yylex(YYSTYPE *yylval, void * YYLEX_PARAM)
144 # endif
145 # define YYLEX yylex(&yylval, YYLEX_PARAM)
146 #else
147 # define YYLEX_DECL() yylex(YYSTYPE *yylval)
148 # define YYLEX yylex(&yylval)
149 #endif
150
151 /* Parameters sent to yyerror. */
152 #ifndef YYERROR_DECL
153 #define YYERROR_DECL() yyerror(const char *s)
154 #endif
155 #ifndef YYERROR_CALL
156 #define YYERROR_CALL(msg) yyerror(msg)
157 #endif
158
159 extern int YYPARSE_DECL();
160
161 #define DIGIT 257
162 #define LETTER 258
163 #define UMINUS 259
164 #define YYERRCODE 256
165 typedef short YYINT;
166 static const YYINT calc_lhs[] = { -1,
167 0, 0, 0, 1, 1, 2, 2, 2, 2, 2,
168 2, 2, 2, 2, 2, 2, 3, 3,
169 };
170 static const YYINT calc_len[] = { 2,
171 0, 3, 3, 1, 3, 3, 3, 3, 3, 3,
172 3, 3, 3, 2, 1, 1, 1, 2,
173 };
174 static const YYINT calc_defred[] = { 1,
175 0, 0, 17, 0, 0, 0, 0, 0, 0, 3,
176 0, 15, 14, 0, 2, 0, 0, 0, 0, 0,
177 0, 0, 18, 0, 6, 0, 0, 0, 0, 9,
178 10, 11,
179 };
180 static const YYINT calc_dgoto[] = { 1,
181 7, 8, 9,
182 };
183 static const YYINT calc_sindex[] = { 0,
184 -40, -7, 0, -55, -38, -38, 1, -29, -247, 0,
185 -38, 0, 0, 22, 0, -38, -38, -38, -38, -38,
186 -38, -38, 0, -29, 0, 51, 60, -20, -20, 0,
187 0, 0,
188 };
189 static const YYINT calc_rindex[] = { 0,
190 0, 0, 0, 2, 0, 0, 0, 9, -9, 0,
191 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
192 0, 0, 0, 10, 0, -6, 14, 5, 13, 0,
193 0, 0,
194 };
195 static const YYINT calc_gindex[] = { 0,
196 0, 65, 0,
197 };
198 #define YYTABLESIZE 220
199 static const YYINT calc_table[] = { 6,
200 16, 6, 10, 13, 5, 11, 5, 22, 17, 23,
201 15, 15, 20, 18, 7, 19, 22, 21, 4, 5,
202 0, 20, 8, 12, 0, 0, 21, 16, 16, 0,
203 0, 16, 16, 16, 13, 16, 0, 16, 15, 15,
204 0, 0, 7, 15, 15, 7, 15, 7, 15, 7,
205 8, 12, 0, 8, 12, 8, 0, 8, 22, 17,
206 0, 0, 25, 20, 18, 0, 19, 0, 21, 13,
207 14, 0, 0, 0, 0, 24, 0, 0, 0, 0,
208 26, 27, 28, 29, 30, 31, 32, 22, 17, 0,
209 0, 0, 20, 18, 16, 19, 22, 21, 0, 0,
210 0, 20, 18, 0, 19, 0, 21, 0, 0, 0,
211 0, 0, 0, 0, 16, 0, 0, 13, 0, 0,
212 0, 0, 0, 0, 0, 15, 0, 0, 7, 0,
213 0, 0, 0, 0, 0, 0, 8, 12, 0, 0,
214 0, 0, 0, 0, 0, 16, 0, 0, 0, 0,
215 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
216 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
217 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
218 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
219 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
220 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
221 0, 0, 0, 0, 0, 2, 3, 4, 3, 12,
222 };
223 static const YYINT calc_check[] = { 40,
224 10, 40, 10, 10, 45, 61, 45, 37, 38, 257,
225 10, 10, 42, 43, 10, 45, 37, 47, 10, 10,
226 -1, 42, 10, 10, -1, -1, 47, 37, 38, -1,
227 -1, 41, 42, 43, 41, 45, -1, 47, 37, 38,
228 -1, -1, 38, 42, 43, 41, 45, 43, 47, 45,
229 38, 38, -1, 41, 41, 43, -1, 45, 37, 38,
230 -1, -1, 41, 42, 43, -1, 45, -1, 47, 5,
231 6, -1, -1, -1, -1, 11, -1, -1, -1, -1,
232 16, 17, 18, 19, 20, 21, 22, 37, 38, -1,
233 -1, -1, 42, 43, 124, 45, 37, 47, -1, -1,
234 -1, 42, 43, -1, 45, -1, 47, -1, -1, -1,
235 -1, -1, -1, -1, 124, -1, -1, 124, -1, -1,
236 -1, -1, -1, -1, -1, 124, -1, -1, 124, -1,
237 -1, -1, -1, -1, -1, -1, 124, 124, -1, -1,
238 -1, -1, -1, -1, -1, 124, -1, -1, -1, -1,
239 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
240 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
241 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
242 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
243 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
244 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
245 -1, -1, -1, -1, -1, 256, 257, 258, 257, 258,
246 };
247 #define YYFINAL 1
248 #ifndef YYDEBUG
249 #define YYDEBUG 0
250 #endif
251 #define YYMAXTOKEN 259
252 #define YYUNDFTOKEN 265
253 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
254 #if YYDEBUG
255 static const char *const calc_name[] = {
256
257 "end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
258 0,0,0,0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,
259 0,0,0,0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
260 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,
261 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
262 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
263 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
264 0,0,0,0,0,0,"DIGIT","LETTER","UMINUS",0,0,0,0,0,"illegal-symbol",
265 };
266 static const char *const calc_rule[] = {
267 "$accept : list",
268 "list :",
269 "list : list stat '\\n'",
270 "list : list error '\\n'",
271 "stat : expr",
272 "stat : LETTER '=' expr",
273 "expr : '(' expr ')'",
274 "expr : expr '+' expr",
275 "expr : expr '-' expr",
276 "expr : expr '*' expr",
277 "expr : expr '/' expr",
278 "expr : expr '%' expr",
279 "expr : expr '&' expr",
280 "expr : expr '|' expr",
281 "expr : '-' expr",
282 "expr : LETTER",
283 "expr : number",
284 "number : DIGIT",
285 "number : number DIGIT",
286
287 };
288 #endif
289
290 int yydebug;
291 int yynerrs;
292
293 /* define the initial stack-sizes */
294 #ifdef YYSTACKSIZE
295 #undef YYMAXDEPTH
296 #define YYMAXDEPTH YYSTACKSIZE
297 #else
298 #ifdef YYMAXDEPTH
299 #define YYSTACKSIZE YYMAXDEPTH
300 #else
301 #define YYSTACKSIZE 10000
302 #define YYMAXDEPTH 10000
303 #endif
304 #endif
305
306 #define YYINITSTACKSIZE 200
307
308 typedef struct {
309 unsigned stacksize;
310 YYINT *s_base;
311 YYINT *s_mark;
312 YYINT *s_last;
313 YYSTYPE *l_base;
314 YYSTYPE *l_mark;
315 } YYSTACKDATA;
316 #line 72 "pure_calc.y"
317 /* start of programs */
318
319 #ifdef YYBYACC
320 static int YYLEX_DECL();
321 #endif
322
323 int
main(void)324 main (void)
325 {
326 while(!feof(stdin)) {
327 yyparse();
328 }
329 return 0;
330 }
331
332 static void
YYERROR_DECL()333 YYERROR_DECL()
334 {
335 fprintf(stderr, "%s\n", s);
336 }
337
338 int
YYLEX_DECL()339 YYLEX_DECL()
340 {
341 /* lexical analysis routine */
342 /* returns LETTER for a lower case letter, yylval = 0 through 25 */
343 /* return DIGIT for a digit, yylval = 0 through 9 */
344 /* all other characters are returned immediately */
345
346 int c;
347
348 while( (c=getchar()) == ' ' ) { /* skip blanks */ }
349
350 /* c is now nonblank */
351
352 if( islower( c )) {
353 *yylval = c - 'a';
354 return ( LETTER );
355 }
356 if( isdigit( c )) {
357 *yylval = c - '0';
358 return ( DIGIT );
359 }
360 return( c );
361 }
362 #line 361 "pure_calc.tab.c"
363
364 #if YYDEBUG
365 #include <stdio.h> /* needed for printf */
366 #endif
367
368 #include <stdlib.h> /* needed for malloc, etc */
369 #include <string.h> /* needed for memset */
370
371 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
yygrowstack(YYSTACKDATA * data)372 static int yygrowstack(YYSTACKDATA *data)
373 {
374 int i;
375 unsigned newsize;
376 YYINT *newss;
377 YYSTYPE *newvs;
378
379 if ((newsize = data->stacksize) == 0)
380 newsize = YYINITSTACKSIZE;
381 else if (newsize >= YYMAXDEPTH)
382 return YYENOMEM;
383 else if ((newsize *= 2) > YYMAXDEPTH)
384 newsize = YYMAXDEPTH;
385
386 i = (int) (data->s_mark - data->s_base);
387 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
388 if (newss == 0)
389 return YYENOMEM;
390
391 data->s_base = newss;
392 data->s_mark = newss + i;
393
394 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
395 if (newvs == 0)
396 return YYENOMEM;
397
398 data->l_base = newvs;
399 data->l_mark = newvs + i;
400
401 data->stacksize = newsize;
402 data->s_last = data->s_base + newsize - 1;
403 return 0;
404 }
405
406 #if YYPURE || defined(YY_NO_LEAKS)
yyfreestack(YYSTACKDATA * data)407 static void yyfreestack(YYSTACKDATA *data)
408 {
409 free(data->s_base);
410 free(data->l_base);
411 memset(data, 0, sizeof(*data));
412 }
413 #else
414 #define yyfreestack(data) /* nothing */
415 #endif
416
417 #define YYABORT goto yyabort
418 #define YYREJECT goto yyabort
419 #define YYACCEPT goto yyaccept
420 #define YYERROR goto yyerrlab
421
422 int
YYPARSE_DECL()423 YYPARSE_DECL()
424 {
425 int yyerrflag;
426 int yychar;
427 YYSTYPE yyval;
428 YYSTYPE yylval;
429
430 /* variables for the parser stack */
431 YYSTACKDATA yystack;
432 int yym, yyn, yystate;
433 #if YYDEBUG
434 const char *yys;
435
436 if ((yys = getenv("YYDEBUG")) != 0)
437 {
438 yyn = *yys;
439 if (yyn >= '0' && yyn <= '9')
440 yydebug = yyn - '0';
441 }
442 #endif
443
444 yynerrs = 0;
445 yyerrflag = 0;
446 yychar = YYEMPTY;
447 yystate = 0;
448
449 #if YYPURE
450 memset(&yystack, 0, sizeof(yystack));
451 #endif
452
453 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
454 yystack.s_mark = yystack.s_base;
455 yystack.l_mark = yystack.l_base;
456 yystate = 0;
457 *yystack.s_mark = 0;
458
459 yyloop:
460 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
461 if (yychar < 0)
462 {
463 if ((yychar = YYLEX) < 0) yychar = YYEOF;
464 #if YYDEBUG
465 if (yydebug)
466 {
467 yys = yyname[YYTRANSLATE(yychar)];
468 printf("%sdebug: state %d, reading %d (%s)\n",
469 YYPREFIX, yystate, yychar, yys);
470 }
471 #endif
472 }
473 if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
474 yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
475 {
476 #if YYDEBUG
477 if (yydebug)
478 printf("%sdebug: state %d, shifting to state %d\n",
479 YYPREFIX, yystate, yytable[yyn]);
480 #endif
481 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
482 {
483 goto yyoverflow;
484 }
485 yystate = yytable[yyn];
486 *++yystack.s_mark = yytable[yyn];
487 *++yystack.l_mark = yylval;
488 yychar = YYEMPTY;
489 if (yyerrflag > 0) --yyerrflag;
490 goto yyloop;
491 }
492 if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
493 yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
494 {
495 yyn = yytable[yyn];
496 goto yyreduce;
497 }
498 if (yyerrflag) goto yyinrecovery;
499
500 YYERROR_CALL("syntax error");
501
502 goto yyerrlab;
503
504 yyerrlab:
505 ++yynerrs;
506
507 yyinrecovery:
508 if (yyerrflag < 3)
509 {
510 yyerrflag = 3;
511 for (;;)
512 {
513 if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
514 yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
515 {
516 #if YYDEBUG
517 if (yydebug)
518 printf("%sdebug: state %d, error recovery shifting\
519 to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
520 #endif
521 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
522 {
523 goto yyoverflow;
524 }
525 yystate = yytable[yyn];
526 *++yystack.s_mark = yytable[yyn];
527 *++yystack.l_mark = yylval;
528 goto yyloop;
529 }
530 else
531 {
532 #if YYDEBUG
533 if (yydebug)
534 printf("%sdebug: error recovery discarding state %d\n",
535 YYPREFIX, *yystack.s_mark);
536 #endif
537 if (yystack.s_mark <= yystack.s_base) goto yyabort;
538 --yystack.s_mark;
539 --yystack.l_mark;
540 }
541 }
542 }
543 else
544 {
545 if (yychar == YYEOF) goto yyabort;
546 #if YYDEBUG
547 if (yydebug)
548 {
549 yys = yyname[YYTRANSLATE(yychar)];
550 printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
551 YYPREFIX, yystate, yychar, yys);
552 }
553 #endif
554 yychar = YYEMPTY;
555 goto yyloop;
556 }
557
558 yyreduce:
559 #if YYDEBUG
560 if (yydebug)
561 printf("%sdebug: state %d, reducing by rule %d (%s)\n",
562 YYPREFIX, yystate, yyn, yyrule[yyn]);
563 #endif
564 yym = yylen[yyn];
565 if (yym)
566 yyval = yystack.l_mark[1-yym];
567 else
568 memset(&yyval, 0, sizeof yyval);
569 switch (yyn)
570 {
571 case 3:
572 #line 34 "pure_calc.y"
573 { yyerrok ; }
574 break;
575 case 4:
576 #line 38 "pure_calc.y"
577 { printf("%d\n",yystack.l_mark[0]);}
578 break;
579 case 5:
580 #line 40 "pure_calc.y"
581 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
582 break;
583 case 6:
584 #line 44 "pure_calc.y"
585 { yyval = yystack.l_mark[-1]; }
586 break;
587 case 7:
588 #line 46 "pure_calc.y"
589 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
590 break;
591 case 8:
592 #line 48 "pure_calc.y"
593 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
594 break;
595 case 9:
596 #line 50 "pure_calc.y"
597 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
598 break;
599 case 10:
600 #line 52 "pure_calc.y"
601 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
602 break;
603 case 11:
604 #line 54 "pure_calc.y"
605 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
606 break;
607 case 12:
608 #line 56 "pure_calc.y"
609 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
610 break;
611 case 13:
612 #line 58 "pure_calc.y"
613 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
614 break;
615 case 14:
616 #line 60 "pure_calc.y"
617 { yyval = - yystack.l_mark[0]; }
618 break;
619 case 15:
620 #line 62 "pure_calc.y"
621 { yyval = regs[yystack.l_mark[0]]; }
622 break;
623 case 17:
624 #line 67 "pure_calc.y"
625 { yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
626 break;
627 case 18:
628 #line 69 "pure_calc.y"
629 { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
630 break;
631 #line 630 "pure_calc.tab.c"
632 }
633 yystack.s_mark -= yym;
634 yystate = *yystack.s_mark;
635 yystack.l_mark -= yym;
636 yym = yylhs[yyn];
637 if (yystate == 0 && yym == 0)
638 {
639 #if YYDEBUG
640 if (yydebug)
641 printf("%sdebug: after reduction, shifting from state 0 to\
642 state %d\n", YYPREFIX, YYFINAL);
643 #endif
644 yystate = YYFINAL;
645 *++yystack.s_mark = YYFINAL;
646 *++yystack.l_mark = yyval;
647 if (yychar < 0)
648 {
649 if ((yychar = YYLEX) < 0) yychar = YYEOF;
650 #if YYDEBUG
651 if (yydebug)
652 {
653 yys = yyname[YYTRANSLATE(yychar)];
654 printf("%sdebug: state %d, reading %d (%s)\n",
655 YYPREFIX, YYFINAL, yychar, yys);
656 }
657 #endif
658 }
659 if (yychar == YYEOF) goto yyaccept;
660 goto yyloop;
661 }
662 if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
663 yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
664 yystate = yytable[yyn];
665 else
666 yystate = yydgoto[yym];
667 #if YYDEBUG
668 if (yydebug)
669 printf("%sdebug: after reduction, shifting from state %d \
670 to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
671 #endif
672 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
673 {
674 goto yyoverflow;
675 }
676 *++yystack.s_mark = (YYINT) yystate;
677 *++yystack.l_mark = yyval;
678 goto yyloop;
679
680 yyoverflow:
681 YYERROR_CALL("yacc stack overflow");
682
683 yyabort:
684 yyfreestack(&yystack);
685 return (1);
686
687 yyaccept:
688 yyfreestack(&yystack);
689 return (0);
690 }
691