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