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