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