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