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