1 /* $NetBSD: 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 of 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 #undef YYBTYACC
19 #define YYBTYACC 0
20 #define YYDEBUGSTR YYPREFIX "debug"
21
22 #ifndef yyparse
23 #define yyparse calc_parse
24 #endif /* yyparse */
25
26 #ifndef yylex
27 #define yylex calc_lex
28 #endif /* yylex */
29
30 #ifndef yyerror
31 #define yyerror calc_error
32 #endif /* yyerror */
33
34 #ifndef yychar
35 #define yychar calc_char
36 #endif /* yychar */
37
38 #ifndef yyval
39 #define yyval calc_val
40 #endif /* yyval */
41
42 #ifndef yylval
43 #define yylval calc_lval
44 #endif /* yylval */
45
46 #ifndef yydebug
47 #define yydebug calc_debug
48 #endif /* yydebug */
49
50 #ifndef yynerrs
51 #define yynerrs calc_nerrs
52 #endif /* yynerrs */
53
54 #ifndef yyerrflag
55 #define yyerrflag calc_errflag
56 #endif /* yyerrflag */
57
58 #ifndef yylhs
59 #define yylhs calc_lhs
60 #endif /* yylhs */
61
62 #ifndef yylen
63 #define yylen calc_len
64 #endif /* yylen */
65
66 #ifndef yydefred
67 #define yydefred calc_defred
68 #endif /* yydefred */
69
70 #ifndef yystos
71 #define yystos calc_stos
72 #endif /* yystos */
73
74 #ifndef yydgoto
75 #define yydgoto calc_dgoto
76 #endif /* yydgoto */
77
78 #ifndef yysindex
79 #define yysindex calc_sindex
80 #endif /* yysindex */
81
82 #ifndef yyrindex
83 #define yyrindex calc_rindex
84 #endif /* yyrindex */
85
86 #ifndef yygindex
87 #define yygindex calc_gindex
88 #endif /* yygindex */
89
90 #ifndef yytable
91 #define yytable calc_table
92 #endif /* yytable */
93
94 #ifndef yycheck
95 #define yycheck calc_check
96 #endif /* yycheck */
97
98 #ifndef yyname
99 #define yyname calc_name
100 #endif /* yyname */
101
102 #ifndef yyrule
103 #define yyrule calc_rule
104 #endif /* yyrule */
105
106 #if YYBTYACC
107
108 #ifndef yycindex
109 #define yycindex calc_cindex
110 #endif /* yycindex */
111
112 #ifndef yyctable
113 #define yyctable calc_ctable
114 #endif /* yyctable */
115
116 #endif /* YYBTYACC */
117
118 #define YYPREFIX "calc_"
119
120 #define YYPURE 0
121
122 #line 2 "calc.y"
123 # include <stdio.h>
124 # include <ctype.h>
125
126 int regs[26];
127 int base;
128
129 extern int yylex(void);
130 static void yyerror(const char *s);
131
132 #line 131 "calc.tab.c"
133
134 #if ! defined(YYSTYPE) && ! defined(YYSTYPE_IS_DECLARED)
135 /* Default: YYSTYPE is the semantic value type. */
136 typedef int YYSTYPE;
137 # define YYSTYPE_IS_DECLARED 1
138 #endif
139
140 /* compatibility with bison */
141 #ifdef YYPARSE_PARAM
142 /* compatibility with FreeBSD */
143 # ifdef YYPARSE_PARAM_TYPE
144 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
145 # else
146 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
147 # endif
148 #else
149 # define YYPARSE_DECL() yyparse(void)
150 #endif
151
152 /* Parameters sent to lex. */
153 #ifdef YYLEX_PARAM
154 # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
155 # define YYLEX yylex(YYLEX_PARAM)
156 #else
157 # define YYLEX_DECL() yylex(void)
158 # define YYLEX yylex()
159 #endif
160
161 /* Parameters sent to yyerror. */
162 #ifndef YYERROR_DECL
163 #define YYERROR_DECL() yyerror(const char *s)
164 #endif
165 #ifndef YYERROR_CALL
166 #define YYERROR_CALL(msg) yyerror(msg)
167 #endif
168
169 extern int YYPARSE_DECL();
170
171 #define DIGIT 257
172 #define LETTER 258
173 #define UMINUS 259
174 #define YYERRCODE 256
175 typedef short YYINT;
176 static const YYINT calc_lhs[] = { -1,
177 0, 0, 0, 1, 1, 2, 2, 2, 2, 2,
178 2, 2, 2, 2, 2, 2, 3, 3,
179 };
180 static const YYINT calc_len[] = { 2,
181 0, 3, 3, 1, 3, 3, 3, 3, 3, 3,
182 3, 3, 3, 2, 1, 1, 1, 2,
183 };
184 static const YYINT calc_defred[] = { 1,
185 0, 0, 17, 0, 0, 0, 0, 0, 0, 3,
186 0, 15, 14, 0, 2, 0, 0, 0, 0, 0,
187 0, 0, 18, 0, 6, 0, 0, 0, 0, 9,
188 10, 11,
189 };
190 static const YYINT calc_stos[] = { 0,
191 261, 256, 257, 258, 45, 40, 262, 263, 264, 10,
192 61, 258, 263, 263, 10, 124, 38, 43, 45, 42,
193 47, 37, 257, 263, 41, 263, 263, 263, 263, 263,
194 263, 263,
195 };
196 static const YYINT calc_dgoto[] = { 1,
197 7, 8, 9,
198 };
199 static const YYINT calc_sindex[] = { 0,
200 -40, -7, 0, -55, -38, -38, 1, -29, -247, 0,
201 -38, 0, 0, 22, 0, -38, -38, -38, -38, -38,
202 -38, -38, 0, -29, 0, 51, 60, -20, -20, 0,
203 0, 0,
204 };
205 static const YYINT calc_rindex[] = { 0,
206 0, 0, 0, 2, 0, 0, 0, 9, -9, 0,
207 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
208 0, 0, 0, 10, 0, -6, 14, 5, 13, 0,
209 0, 0,
210 };
211 #if YYBTYACC
212 static const YYINT calc_cindex[] = { 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,
217 };
218 #endif
219 static const YYINT calc_gindex[] = { 0,
220 0, 65, 0,
221 };
222 #define YYTABLESIZE 220
223 static const YYINT calc_table[] = { 6,
224 16, 6, 10, 13, 5, 11, 5, 22, 17, 23,
225 15, 15, 20, 18, 7, 19, 22, 21, 4, 5,
226 0, 20, 8, 12, 0, 0, 21, 16, 16, 0,
227 0, 16, 16, 16, 13, 16, 0, 16, 15, 15,
228 0, 0, 7, 15, 15, 7, 15, 7, 15, 7,
229 8, 12, 0, 8, 12, 8, 0, 8, 22, 17,
230 0, 0, 25, 20, 18, 0, 19, 0, 21, 13,
231 14, 0, 0, 0, 0, 24, 0, 0, 0, 0,
232 26, 27, 28, 29, 30, 31, 32, 22, 17, 0,
233 0, 0, 20, 18, 16, 19, 22, 21, 0, 0,
234 0, 20, 18, 0, 19, 0, 21, 0, 0, 0,
235 0, 0, 0, 0, 16, 0, 0, 13, 0, 0,
236 0, 0, 0, 0, 0, 15, 0, 0, 7, 0,
237 0, 0, 0, 0, 0, 0, 8, 12, 0, 0,
238 0, 0, 0, 0, 0, 16, 0, 0, 0, 0,
239 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
240 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
241 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
242 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
243 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
244 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
245 0, 0, 0, 0, 0, 2, 3, 4, 3, 12,
246 };
247 static const YYINT calc_check[] = { 40,
248 10, 40, 10, 10, 45, 61, 45, 37, 38, 257,
249 10, 10, 42, 43, 10, 45, 37, 47, 10, 10,
250 -1, 42, 10, 10, -1, -1, 47, 37, 38, -1,
251 -1, 41, 42, 43, 41, 45, -1, 47, 37, 38,
252 -1, -1, 38, 42, 43, 41, 45, 43, 47, 45,
253 38, 38, -1, 41, 41, 43, -1, 45, 37, 38,
254 -1, -1, 41, 42, 43, -1, 45, -1, 47, 5,
255 6, -1, -1, -1, -1, 11, -1, -1, -1, -1,
256 16, 17, 18, 19, 20, 21, 22, 37, 38, -1,
257 -1, -1, 42, 43, 124, 45, 37, 47, -1, -1,
258 -1, 42, 43, -1, 45, -1, 47, -1, -1, -1,
259 -1, -1, -1, -1, 124, -1, -1, 124, -1, -1,
260 -1, -1, -1, -1, -1, 124, -1, -1, 124, -1,
261 -1, -1, -1, -1, -1, -1, 124, 124, -1, -1,
262 -1, -1, -1, -1, -1, 124, -1, -1, -1, -1,
263 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
264 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
265 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
266 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
267 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
268 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
269 -1, -1, -1, -1, -1, 256, 257, 258, 257, 258,
270 };
271 #if YYBTYACC
272 static const YYINT calc_ctable[] = { -1,
273 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
274 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
275 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
276 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
277 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
278 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
279 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
280 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
281 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
282 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
283 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
284 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
285 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
286 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
287 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
288 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
289 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
290 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
291 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
292 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
293 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
294 -1, -1, -1, -1, -1, -1, -1, -1, -1,
295 };
296 #endif
297 #define YYFINAL 1
298 #ifndef YYDEBUG
299 #define YYDEBUG 0
300 #endif
301 #define YYMAXTOKEN 259
302 #define YYUNDFTOKEN 265
303 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
304 #if YYDEBUG
305 static const char *const calc_name[] = {
306
307 "$end",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,0,0,0,
308 0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,
309 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,
310 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,
311 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,
312 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,
313 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,
314 0,0,"error","DIGIT","LETTER","UMINUS","$accept","list","stat","expr","number",
315 "illegal-symbol",
316 };
317 static const char *const calc_rule[] = {
318 "$accept : list",
319 "list :",
320 "list : list stat '\\n'",
321 "list : list error '\\n'",
322 "stat : expr",
323 "stat : LETTER '=' expr",
324 "expr : '(' expr ')'",
325 "expr : expr '+' expr",
326 "expr : expr '-' expr",
327 "expr : expr '*' expr",
328 "expr : expr '/' expr",
329 "expr : expr '%' expr",
330 "expr : expr '&' expr",
331 "expr : expr '|' expr",
332 "expr : '-' expr",
333 "expr : LETTER",
334 "expr : number",
335 "number : DIGIT",
336 "number : number DIGIT",
337
338 };
339 #endif
340
341 int yydebug;
342 int yynerrs;
343
344 int yyerrflag;
345 int yychar;
346 YYSTYPE yyval;
347 YYSTYPE yylval;
348 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
349 YYLTYPE yyloc; /* position returned by actions */
350 YYLTYPE yylloc; /* position from the lexer */
351 #endif
352
353 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
354 #ifndef YYLLOC_DEFAULT
355 #define YYLLOC_DEFAULT(loc, rhs, n) \
356 do \
357 { \
358 if (n == 0) \
359 { \
360 (loc).first_line = ((rhs)[-1]).last_line; \
361 (loc).first_column = ((rhs)[-1]).last_column; \
362 (loc).last_line = ((rhs)[-1]).last_line; \
363 (loc).last_column = ((rhs)[-1]).last_column; \
364 } \
365 else \
366 { \
367 (loc).first_line = ((rhs)[ 0 ]).first_line; \
368 (loc).first_column = ((rhs)[ 0 ]).first_column; \
369 (loc).last_line = ((rhs)[n-1]).last_line; \
370 (loc).last_column = ((rhs)[n-1]).last_column; \
371 } \
372 } while (0)
373 #endif /* YYLLOC_DEFAULT */
374 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
375 #if YYBTYACC
376
377 #ifndef YYLVQUEUEGROWTH
378 #define YYLVQUEUEGROWTH 32
379 #endif
380 #endif /* YYBTYACC */
381
382 /* define the initial stack-sizes */
383 #ifdef YYSTACKSIZE
384 #undef YYMAXDEPTH
385 #define YYMAXDEPTH YYSTACKSIZE
386 #else
387 #ifdef YYMAXDEPTH
388 #define YYSTACKSIZE YYMAXDEPTH
389 #else
390 #define YYSTACKSIZE 10000
391 #define YYMAXDEPTH 10000
392 #endif
393 #endif
394
395 #ifndef YYINITSTACKSIZE
396 #define YYINITSTACKSIZE 200
397 #endif
398
399 typedef struct {
400 unsigned stacksize;
401 short *s_base;
402 short *s_mark;
403 short *s_last;
404 YYSTYPE *l_base;
405 YYSTYPE *l_mark;
406 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
407 YYLTYPE *p_base;
408 YYLTYPE *p_mark;
409 #endif
410 } YYSTACKDATA;
411 #if YYBTYACC
412
413 struct YYParseState_s
414 {
415 struct YYParseState_s *save; /* Previously saved parser state */
416 YYSTACKDATA yystack; /* saved parser stack */
417 int state; /* saved parser state */
418 int errflag; /* saved error recovery status */
419 int lexeme; /* saved index of the conflict lexeme in the lexical queue */
420 YYINT ctry; /* saved index in yyctable[] for this conflict */
421 };
422 typedef struct YYParseState_s YYParseState;
423 #endif /* YYBTYACC */
424 /* variables for the parser stack */
425 static YYSTACKDATA yystack;
426 #if YYBTYACC
427
428 /* Current parser state */
429 static YYParseState *yyps = 0;
430
431 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
432 static YYParseState *yypath = 0;
433
434 /* Base of the lexical value queue */
435 static YYSTYPE *yylvals = 0;
436
437 /* Current position at lexical value queue */
438 static YYSTYPE *yylvp = 0;
439
440 /* End position of lexical value queue */
441 static YYSTYPE *yylve = 0;
442
443 /* The last allocated position at the lexical value queue */
444 static YYSTYPE *yylvlim = 0;
445
446 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
447 /* Base of the lexical position queue */
448 static YYLTYPE *yylpsns = 0;
449
450 /* Current position at lexical position queue */
451 static YYLTYPE *yylpp = 0;
452
453 /* End position of lexical position queue */
454 static YYLTYPE *yylpe = 0;
455
456 /* The last allocated position at the lexical position queue */
457 static YYLTYPE *yylplim = 0;
458 #endif
459
460 /* Current position at lexical token queue */
461 static short *yylexp = 0;
462
463 static short *yylexemes = 0;
464 #endif /* YYBTYACC */
465 #line 66 "calc.y"
466 /* start of programs */
467
468 int
main(void)469 main (void)
470 {
471 while(!feof(stdin)) {
472 yyparse();
473 }
474 return 0;
475 }
476
477 static void
yyerror(const char * s)478 yyerror(const char *s)
479 {
480 fprintf(stderr, "%s\n", s);
481 }
482
483 int
yylex(void)484 yylex(void)
485 {
486 /* lexical analysis routine */
487 /* returns LETTER for a lower case letter, yylval = 0 through 25 */
488 /* return DIGIT for a digit, yylval = 0 through 9 */
489 /* all other characters are returned immediately */
490
491 int c;
492
493 while( (c=getchar()) == ' ' ) { /* skip blanks */ }
494
495 /* c is now nonblank */
496
497 if( islower( c )) {
498 yylval = c - 'a';
499 return ( LETTER );
500 }
501 if( isdigit( c )) {
502 yylval = c - '0';
503 return ( DIGIT );
504 }
505 return( c );
506 }
507 #line 506 "calc.tab.c"
508
509 /* For use in generated program */
510 #define yydepth (int)(yystack.s_mark - yystack.s_base)
511 #if YYBTYACC
512 #define yytrial (yyps->save)
513 #endif /* YYBTYACC */
514
515 #if YYDEBUG
516 #include <stdio.h> /* needed for printf */
517 #endif
518
519 #include <stdlib.h> /* needed for malloc, etc */
520 #include <string.h> /* needed for memset */
521
522 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
yygrowstack(YYSTACKDATA * data)523 static int yygrowstack(YYSTACKDATA *data)
524 {
525 int i;
526 unsigned newsize;
527 short *newss;
528 YYSTYPE *newvs;
529 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
530 YYLTYPE *newps;
531 #endif
532
533 if ((newsize = data->stacksize) == 0)
534 newsize = YYINITSTACKSIZE;
535 else if (newsize >= YYMAXDEPTH)
536 return YYENOMEM;
537 else if ((newsize *= 2) > YYMAXDEPTH)
538 newsize = YYMAXDEPTH;
539
540 i = (int) (data->s_mark - data->s_base);
541 newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
542 if (newss == 0)
543 return YYENOMEM;
544
545 data->s_base = newss;
546 data->s_mark = newss + i;
547
548 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
549 if (newvs == 0)
550 return YYENOMEM;
551
552 data->l_base = newvs;
553 data->l_mark = newvs + i;
554
555 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
556 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
557 if (newps == 0)
558 return YYENOMEM;
559
560 data->p_base = newps;
561 data->p_mark = newps + i;
562 #endif
563
564 data->stacksize = newsize;
565 data->s_last = data->s_base + newsize - 1;
566
567 #if YYDEBUG
568 if (yydebug)
569 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
570 #endif
571 return 0;
572 }
573
574 #if YYPURE || defined(YY_NO_LEAKS)
yyfreestack(YYSTACKDATA * data)575 static void yyfreestack(YYSTACKDATA *data)
576 {
577 free(data->s_base);
578 free(data->l_base);
579 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
580 free(data->p_base);
581 #endif
582 memset(data, 0, sizeof(*data));
583 }
584 #else
585 #define yyfreestack(data) /* nothing */
586 #endif /* YYPURE || defined(YY_NO_LEAKS) */
587 #if YYBTYACC
588
589 static YYParseState *
yyNewState(unsigned size)590 yyNewState(unsigned size)
591 {
592 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
593 if (p == NULL) return NULL;
594
595 p->yystack.stacksize = size;
596 if (size == 0)
597 {
598 p->yystack.s_base = NULL;
599 p->yystack.l_base = NULL;
600 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
601 p->yystack.p_base = NULL;
602 #endif
603 return p;
604 }
605 p->yystack.s_base = (short *) malloc(size * sizeof(short));
606 if (p->yystack.s_base == NULL) return NULL;
607 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
608 if (p->yystack.l_base == NULL) return NULL;
609 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
610 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
611 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
612 if (p->yystack.p_base == NULL) return NULL;
613 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
614 #endif
615
616 return p;
617 }
618
619 static void
yyFreeState(YYParseState * p)620 yyFreeState(YYParseState *p)
621 {
622 yyfreestack(&p->yystack);
623 free(p);
624 }
625 #endif /* YYBTYACC */
626
627 #define YYABORT goto yyabort
628 #define YYREJECT goto yyabort
629 #define YYACCEPT goto yyaccept
630 #define YYERROR goto yyerrlab
631 #if YYBTYACC
632 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
633 #define YYVALID_NESTED do { if (yyps->save && \
634 yyps->save->save == 0) goto yyvalid; } while(0)
635 #endif /* YYBTYACC */
636
637 int
YYPARSE_DECL()638 YYPARSE_DECL()
639 {
640 int yym, yyn, yystate, yyresult;
641 #if YYBTYACC
642 int yynewerrflag;
643 YYParseState *yyerrctx = NULL;
644 #endif /* YYBTYACC */
645 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
646 YYLTYPE yyerror_loc_range[2]; /* position of error start & end */
647 #endif
648 #if YYDEBUG
649 const char *yys;
650
651 if ((yys = getenv("YYDEBUG")) != 0)
652 {
653 yyn = *yys;
654 if (yyn >= '0' && yyn <= '9')
655 yydebug = yyn - '0';
656 }
657 if (yydebug)
658 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
659 #endif
660
661 #if YYBTYACC
662 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
663 yyps->save = 0;
664 #endif /* YYBTYACC */
665 yynerrs = 0;
666 yyerrflag = 0;
667 yychar = YYEMPTY;
668 yystate = 0;
669
670 #if YYPURE
671 memset(&yystack, 0, sizeof(yystack));
672 #endif
673
674 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
675 yystack.s_mark = yystack.s_base;
676 yystack.l_mark = yystack.l_base;
677 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
678 yystack.p_mark = yystack.p_base;
679 #endif
680 yystate = 0;
681 *yystack.s_mark = 0;
682
683 yyloop:
684 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
685 if (yychar < 0)
686 {
687 #if YYBTYACC
688 do {
689 if (yylvp < yylve)
690 {
691 /* we're currently re-reading tokens */
692 yylval = *yylvp++;
693 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
694 yylloc = *yylpp++;
695 #endif
696 yychar = *yylexp++;
697 break;
698 }
699 if (yyps->save)
700 {
701 /* in trial mode; save scanner results for future parse attempts */
702 if (yylvp == yylvlim)
703 { /* Enlarge lexical value queue */
704 size_t p = (size_t) (yylvp - yylvals);
705 size_t s = (size_t) (yylvlim - yylvals);
706
707 s += YYLVQUEUEGROWTH;
708 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
709 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
710 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
711 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
712 #endif
713 yylvp = yylve = yylvals + p;
714 yylvlim = yylvals + s;
715 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
716 yylpp = yylpe = yylpsns + p;
717 yylplim = yylpsns + s;
718 #endif
719 yylexp = yylexemes + p;
720 }
721 *yylexp = (short) YYLEX;
722 *yylvp++ = yylval;
723 yylve++;
724 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
725 *yylpp++ = yylloc;
726 yylpe++;
727 #endif
728 yychar = *yylexp++;
729 break;
730 }
731 /* normal operation, no conflict encountered */
732 #endif /* YYBTYACC */
733 yychar = YYLEX;
734 #if YYBTYACC
735 } while (0);
736 #endif /* YYBTYACC */
737 if (yychar < 0) yychar = YYEOF;
738 /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */
739 #if YYDEBUG
740 if (yydebug)
741 {
742 yys = yyname[YYTRANSLATE(yychar)];
743 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
744 YYDEBUGSTR, yydepth, yystate, yychar, yys);
745 #ifdef YYSTYPE_TOSTRING
746 #if YYBTYACC
747 if (!yytrial)
748 #endif /* YYBTYACC */
749 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
750 #endif
751 fputc('\n', stderr);
752 }
753 #endif
754 }
755 #if YYBTYACC
756
757 /* Do we have a conflict? */
758 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
759 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
760 {
761 YYINT ctry;
762
763 if (yypath)
764 {
765 YYParseState *save;
766 #if YYDEBUG
767 if (yydebug)
768 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
769 YYDEBUGSTR, yydepth, yystate);
770 #endif
771 /* Switch to the next conflict context */
772 save = yypath;
773 yypath = save->save;
774 save->save = NULL;
775 ctry = save->ctry;
776 if (save->state != yystate) YYABORT;
777 yyFreeState(save);
778
779 }
780 else
781 {
782
783 /* Unresolved conflict - start/continue trial parse */
784 YYParseState *save;
785 #if YYDEBUG
786 if (yydebug)
787 {
788 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
789 if (yyps->save)
790 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
791 else
792 fputs("Starting trial parse.\n", stderr);
793 }
794 #endif
795 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
796 if (save == NULL) goto yyenomem;
797 save->save = yyps->save;
798 save->state = yystate;
799 save->errflag = yyerrflag;
800 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
801 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
802 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
803 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
804 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
805 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
806 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
807 #endif
808 ctry = yytable[yyn];
809 if (yyctable[ctry] == -1)
810 {
811 #if YYDEBUG
812 if (yydebug && yychar >= YYEOF)
813 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
814 #endif
815 ctry++;
816 }
817 save->ctry = ctry;
818 if (yyps->save == NULL)
819 {
820 /* If this is a first conflict in the stack, start saving lexemes */
821 if (!yylexemes)
822 {
823 yylexemes = (short *) malloc((YYLVQUEUEGROWTH) * sizeof(short));
824 if (yylexemes == NULL) goto yyenomem;
825 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
826 if (yylvals == NULL) goto yyenomem;
827 yylvlim = yylvals + YYLVQUEUEGROWTH;
828 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
829 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
830 if (yylpsns == NULL) goto yyenomem;
831 yylplim = yylpsns + YYLVQUEUEGROWTH;
832 #endif
833 }
834 if (yylvp == yylve)
835 {
836 yylvp = yylve = yylvals;
837 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
838 yylpp = yylpe = yylpsns;
839 #endif
840 yylexp = yylexemes;
841 if (yychar >= YYEOF)
842 {
843 *yylve++ = yylval;
844 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
845 *yylpe++ = yylloc;
846 #endif
847 *yylexp = (short) yychar;
848 yychar = YYEMPTY;
849 }
850 }
851 }
852 if (yychar >= YYEOF)
853 {
854 yylvp--;
855 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
856 yylpp--;
857 #endif
858 yylexp--;
859 yychar = YYEMPTY;
860 }
861 save->lexeme = (int) (yylvp - yylvals);
862 yyps->save = save;
863 }
864 if (yytable[yyn] == ctry)
865 {
866 #if YYDEBUG
867 if (yydebug)
868 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
869 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
870 #endif
871 if (yychar < 0)
872 {
873 yylvp++;
874 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
875 yylpp++;
876 #endif
877 yylexp++;
878 }
879 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
880 goto yyoverflow;
881 yystate = yyctable[ctry];
882 *++yystack.s_mark = (short) yystate;
883 *++yystack.l_mark = yylval;
884 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
885 *++yystack.p_mark = yylloc;
886 #endif
887 yychar = YYEMPTY;
888 if (yyerrflag > 0) --yyerrflag;
889 goto yyloop;
890 }
891 else
892 {
893 yyn = yyctable[ctry];
894 goto yyreduce;
895 }
896 } /* End of code dealing with conflicts */
897 #endif /* YYBTYACC */
898 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
899 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
900 {
901 #if YYDEBUG
902 if (yydebug)
903 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
904 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
905 #endif
906 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
907 yystate = yytable[yyn];
908 *++yystack.s_mark = yytable[yyn];
909 *++yystack.l_mark = yylval;
910 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
911 *++yystack.p_mark = yylloc;
912 #endif
913 yychar = YYEMPTY;
914 if (yyerrflag > 0) --yyerrflag;
915 goto yyloop;
916 }
917 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
918 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
919 {
920 yyn = yytable[yyn];
921 goto yyreduce;
922 }
923 if (yyerrflag != 0) goto yyinrecovery;
924 #if YYBTYACC
925
926 yynewerrflag = 1;
927 goto yyerrhandler;
928 goto yyerrlab;
929
930 yyerrlab:
931 yynewerrflag = 0;
932 yyerrhandler:
933 while (yyps->save)
934 {
935 int ctry;
936 YYParseState *save = yyps->save;
937 #if YYDEBUG
938 if (yydebug)
939 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
940 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
941 (int)(yylvp - yylvals - yyps->save->lexeme));
942 #endif
943 /* Memorize most forward-looking error state in case it's really an error. */
944 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
945 {
946 /* Free old saved error context state */
947 if (yyerrctx) yyFreeState(yyerrctx);
948 /* Create and fill out new saved error context state */
949 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
950 if (yyerrctx == NULL) goto yyenomem;
951 yyerrctx->save = yyps->save;
952 yyerrctx->state = yystate;
953 yyerrctx->errflag = yyerrflag;
954 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
955 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
956 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
957 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
958 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
959 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
960 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
961 #endif
962 yyerrctx->lexeme = (int) (yylvp - yylvals);
963 }
964 yylvp = yylvals + save->lexeme;
965 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
966 yylpp = yylpsns + save->lexeme;
967 #endif
968 yylexp = yylexemes + save->lexeme;
969 yychar = YYEMPTY;
970 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
971 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
972 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
973 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
974 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
975 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
976 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
977 #endif
978 ctry = ++save->ctry;
979 yystate = save->state;
980 /* We tried shift, try reduce now */
981 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
982 yyps->save = save->save;
983 save->save = NULL;
984 yyFreeState(save);
985
986 /* Nothing left on the stack -- error */
987 if (!yyps->save)
988 {
989 #if YYDEBUG
990 if (yydebug)
991 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
992 YYPREFIX, yydepth);
993 #endif
994 /* Restore state as it was in the most forward-advanced error */
995 yylvp = yylvals + yyerrctx->lexeme;
996 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
997 yylpp = yylpsns + yyerrctx->lexeme;
998 #endif
999 yylexp = yylexemes + yyerrctx->lexeme;
1000 yychar = yylexp[-1];
1001 yylval = yylvp[-1];
1002 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1003 yylloc = yylpp[-1];
1004 #endif
1005 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1006 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1007 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1008 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1009 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1010 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1011 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1012 #endif
1013 yystate = yyerrctx->state;
1014 yyFreeState(yyerrctx);
1015 yyerrctx = NULL;
1016 }
1017 yynewerrflag = 1;
1018 }
1019 if (yynewerrflag == 0) goto yyinrecovery;
1020 #endif /* YYBTYACC */
1021
1022 YYERROR_CALL("syntax error");
1023 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1024 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
1025 #endif
1026
1027 #if !YYBTYACC
1028 goto yyerrlab;
1029 yyerrlab:
1030 #endif
1031 ++yynerrs;
1032
1033 yyinrecovery:
1034 if (yyerrflag < 3)
1035 {
1036 yyerrflag = 3;
1037 for (;;)
1038 {
1039 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1040 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1041 {
1042 #if YYDEBUG
1043 if (yydebug)
1044 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1045 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1046 #endif
1047 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1048 yystate = yytable[yyn];
1049 *++yystack.s_mark = yytable[yyn];
1050 *++yystack.l_mark = yylval;
1051 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1052 /* lookahead position is error end position */
1053 yyerror_loc_range[1] = yylloc;
1054 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1055 *++yystack.p_mark = yyloc;
1056 #endif
1057 goto yyloop;
1058 }
1059 else
1060 {
1061 #if YYDEBUG
1062 if (yydebug)
1063 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1064 YYDEBUGSTR, yydepth, *yystack.s_mark);
1065 #endif
1066 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1067 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1068 /* the current TOS position is the error start position */
1069 yyerror_loc_range[0] = *yystack.p_mark;
1070 #endif
1071 #if defined(YYDESTRUCT_CALL)
1072 #if YYBTYACC
1073 if (!yytrial)
1074 #endif /* YYBTYACC */
1075 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1076 YYDESTRUCT_CALL("error: discarding state",
1077 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1078 #else
1079 YYDESTRUCT_CALL("error: discarding state",
1080 yystos[*yystack.s_mark], yystack.l_mark);
1081 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1082 #endif /* defined(YYDESTRUCT_CALL) */
1083 --yystack.s_mark;
1084 --yystack.l_mark;
1085 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1086 --yystack.p_mark;
1087 #endif
1088 }
1089 }
1090 }
1091 else
1092 {
1093 if (yychar == YYEOF) goto yyabort;
1094 #if YYDEBUG
1095 if (yydebug)
1096 {
1097 yys = yyname[YYTRANSLATE(yychar)];
1098 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1099 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1100 }
1101 #endif
1102 #if defined(YYDESTRUCT_CALL)
1103 #if YYBTYACC
1104 if (!yytrial)
1105 #endif /* YYBTYACC */
1106 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1107 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1108 #else
1109 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1110 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1111 #endif /* defined(YYDESTRUCT_CALL) */
1112 yychar = YYEMPTY;
1113 goto yyloop;
1114 }
1115
1116 yyreduce:
1117 yym = yylen[yyn];
1118 #if YYDEBUG
1119 if (yydebug)
1120 {
1121 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1122 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1123 #ifdef YYSTYPE_TOSTRING
1124 #if YYBTYACC
1125 if (!yytrial)
1126 #endif /* YYBTYACC */
1127 if (yym > 0)
1128 {
1129 int i;
1130 fputc('<', stderr);
1131 for (i = yym; i > 0; i--)
1132 {
1133 if (i != yym) fputs(", ", stderr);
1134 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1135 yystack.l_mark[1-i]), stderr);
1136 }
1137 fputc('>', stderr);
1138 }
1139 #endif
1140 fputc('\n', stderr);
1141 }
1142 #endif
1143 if (yym > 0)
1144 yyval = yystack.l_mark[1-yym];
1145 else
1146 memset(&yyval, 0, sizeof yyval);
1147 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1148
1149 /* Perform position reduction */
1150 memset(&yyloc, 0, sizeof(yyloc));
1151 #if YYBTYACC
1152 if (!yytrial)
1153 #endif /* YYBTYACC */
1154 {
1155 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
1156 /* just in case YYERROR is invoked within the action, save
1157 the start of the rhs as the error start position */
1158 yyerror_loc_range[0] = yystack.p_mark[1-yym];
1159 }
1160 #endif
1161
1162 switch (yyn)
1163 {
1164 case 3:
1165 #line 28 "calc.y"
1166 { yyerrok ; }
1167 break;
1168 case 4:
1169 #line 32 "calc.y"
1170 { printf("%d\n",yystack.l_mark[0]);}
1171 break;
1172 case 5:
1173 #line 34 "calc.y"
1174 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
1175 break;
1176 case 6:
1177 #line 38 "calc.y"
1178 { yyval = yystack.l_mark[-1]; }
1179 break;
1180 case 7:
1181 #line 40 "calc.y"
1182 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
1183 break;
1184 case 8:
1185 #line 42 "calc.y"
1186 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
1187 break;
1188 case 9:
1189 #line 44 "calc.y"
1190 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
1191 break;
1192 case 10:
1193 #line 46 "calc.y"
1194 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
1195 break;
1196 case 11:
1197 #line 48 "calc.y"
1198 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
1199 break;
1200 case 12:
1201 #line 50 "calc.y"
1202 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
1203 break;
1204 case 13:
1205 #line 52 "calc.y"
1206 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
1207 break;
1208 case 14:
1209 #line 54 "calc.y"
1210 { yyval = - yystack.l_mark[0]; }
1211 break;
1212 case 15:
1213 #line 56 "calc.y"
1214 { yyval = regs[yystack.l_mark[0]]; }
1215 break;
1216 case 17:
1217 #line 61 "calc.y"
1218 { yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
1219 break;
1220 case 18:
1221 #line 63 "calc.y"
1222 { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
1223 break;
1224 #line 1223 "calc.tab.c"
1225 default:
1226 break;
1227 }
1228 yystack.s_mark -= yym;
1229 yystate = *yystack.s_mark;
1230 yystack.l_mark -= yym;
1231 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1232 yystack.p_mark -= yym;
1233 #endif
1234 yym = yylhs[yyn];
1235 if (yystate == 0 && yym == 0)
1236 {
1237 #if YYDEBUG
1238 if (yydebug)
1239 {
1240 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1241 #ifdef YYSTYPE_TOSTRING
1242 #if YYBTYACC
1243 if (!yytrial)
1244 #endif /* YYBTYACC */
1245 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1246 #endif
1247 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1248 }
1249 #endif
1250 yystate = YYFINAL;
1251 *++yystack.s_mark = YYFINAL;
1252 *++yystack.l_mark = yyval;
1253 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1254 *++yystack.p_mark = yyloc;
1255 #endif
1256 if (yychar < 0)
1257 {
1258 #if YYBTYACC
1259 do {
1260 if (yylvp < yylve)
1261 {
1262 /* we're currently re-reading tokens */
1263 yylval = *yylvp++;
1264 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1265 yylloc = *yylpp++;
1266 #endif
1267 yychar = *yylexp++;
1268 break;
1269 }
1270 if (yyps->save)
1271 {
1272 /* in trial mode; save scanner results for future parse attempts */
1273 if (yylvp == yylvlim)
1274 { /* Enlarge lexical value queue */
1275 size_t p = (size_t) (yylvp - yylvals);
1276 size_t s = (size_t) (yylvlim - yylvals);
1277
1278 s += YYLVQUEUEGROWTH;
1279 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
1280 goto yyenomem;
1281 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1282 goto yyenomem;
1283 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1284 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1285 goto yyenomem;
1286 #endif
1287 yylvp = yylve = yylvals + p;
1288 yylvlim = yylvals + s;
1289 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1290 yylpp = yylpe = yylpsns + p;
1291 yylplim = yylpsns + s;
1292 #endif
1293 yylexp = yylexemes + p;
1294 }
1295 *yylexp = (short) YYLEX;
1296 *yylvp++ = yylval;
1297 yylve++;
1298 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1299 *yylpp++ = yylloc;
1300 yylpe++;
1301 #endif
1302 yychar = *yylexp++;
1303 break;
1304 }
1305 /* normal operation, no conflict encountered */
1306 #endif /* YYBTYACC */
1307 yychar = YYLEX;
1308 #if YYBTYACC
1309 } while (0);
1310 #endif /* YYBTYACC */
1311 if (yychar < 0) yychar = YYEOF;
1312 /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */
1313 #if YYDEBUG
1314 if (yydebug)
1315 {
1316 yys = yyname[YYTRANSLATE(yychar)];
1317 fprintf(stderr, "%s[%d]: state %d, reading %d (%s)\n",
1318 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1319 }
1320 #endif
1321 }
1322 if (yychar == YYEOF) goto yyaccept;
1323 goto yyloop;
1324 }
1325 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1326 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1327 yystate = yytable[yyn];
1328 else
1329 yystate = yydgoto[yym];
1330 #if YYDEBUG
1331 if (yydebug)
1332 {
1333 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1334 #ifdef YYSTYPE_TOSTRING
1335 #if YYBTYACC
1336 if (!yytrial)
1337 #endif /* YYBTYACC */
1338 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1339 #endif
1340 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1341 }
1342 #endif
1343 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1344 *++yystack.s_mark = (short) yystate;
1345 *++yystack.l_mark = yyval;
1346 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1347 *++yystack.p_mark = yyloc;
1348 #endif
1349 goto yyloop;
1350 #if YYBTYACC
1351
1352 /* Reduction declares that this path is valid. Set yypath and do a full parse */
1353 yyvalid:
1354 if (yypath) YYABORT;
1355 while (yyps->save)
1356 {
1357 YYParseState *save = yyps->save;
1358 yyps->save = save->save;
1359 save->save = yypath;
1360 yypath = save;
1361 }
1362 #if YYDEBUG
1363 if (yydebug)
1364 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1365 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1366 #endif
1367 if (yyerrctx)
1368 {
1369 yyFreeState(yyerrctx);
1370 yyerrctx = NULL;
1371 }
1372 yylvp = yylvals + yypath->lexeme;
1373 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1374 yylpp = yylpsns + yypath->lexeme;
1375 #endif
1376 yylexp = yylexemes + yypath->lexeme;
1377 yychar = YYEMPTY;
1378 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1379 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1380 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1381 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1382 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1383 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1384 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1385 #endif
1386 yystate = yypath->state;
1387 goto yyloop;
1388 #endif /* YYBTYACC */
1389
1390 yyoverflow:
1391 YYERROR_CALL("yacc stack overflow");
1392 #if YYBTYACC
1393 goto yyabort_nomem;
1394 yyenomem:
1395 YYERROR_CALL("memory exhausted");
1396 yyabort_nomem:
1397 #endif /* YYBTYACC */
1398 yyresult = 2;
1399 goto yyreturn;
1400
1401 yyabort:
1402 yyresult = 1;
1403 goto yyreturn;
1404
1405 yyaccept:
1406 #if YYBTYACC
1407 if (yyps->save) goto yyvalid;
1408 #endif /* YYBTYACC */
1409 yyresult = 0;
1410
1411 yyreturn:
1412 #if defined(YYDESTRUCT_CALL)
1413 if (yychar != YYEOF && yychar != YYEMPTY)
1414 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1415 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1416 #else
1417 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1418 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1419
1420 {
1421 YYSTYPE *pv;
1422 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1423 YYLTYPE *pp;
1424
1425 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1426 YYDESTRUCT_CALL("cleanup: discarding state",
1427 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1428 #else
1429 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1430 YYDESTRUCT_CALL("cleanup: discarding state",
1431 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1432 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1433 }
1434 #endif /* defined(YYDESTRUCT_CALL) */
1435
1436 #if YYBTYACC
1437 if (yyerrctx)
1438 {
1439 yyFreeState(yyerrctx);
1440 yyerrctx = NULL;
1441 }
1442 while (yyps)
1443 {
1444 YYParseState *save = yyps;
1445 yyps = save->save;
1446 save->save = NULL;
1447 yyFreeState(save);
1448 }
1449 while (yypath)
1450 {
1451 YYParseState *save = yypath;
1452 yypath = save->save;
1453 save->save = NULL;
1454 yyFreeState(save);
1455 }
1456 #endif /* YYBTYACC */
1457 yyfreestack(&yystack);
1458 return (yyresult);
1459 }
1460