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