1 /* original parser id follows */
2 /* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
3 /* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
8 #define YYCHECK "yyyymmdd"
11 #define yyclearin (yychar = YYEMPTY)
12 #define yyerrok (yyerrflag = 0)
13 #define YYRECOVERING() (yyerrflag != 0)
18 #define YYDEBUGSTR YYPREFIX "debug"
21 #define yyparse quote_calc4_parse
25 #define yylex quote_calc4_lex
29 #define yyerror quote_calc4_error
33 #define yychar quote_calc4_char
37 #define yyval quote_calc4_val
41 #define yylval quote_calc4_lval
45 #define yydebug quote_calc4_debug
49 #define yynerrs quote_calc4_nerrs
53 #define yyerrflag quote_calc4_errflag
54 #endif /* yyerrflag */
57 #define yylhs quote_calc4_lhs
61 #define yylen quote_calc4_len
65 #define yydefred quote_calc4_defred
69 #define yystos quote_calc4_stos
73 #define yydgoto quote_calc4_dgoto
77 #define yysindex quote_calc4_sindex
81 #define yyrindex quote_calc4_rindex
85 #define yygindex quote_calc4_gindex
89 #define yytable quote_calc4_table
93 #define yycheck quote_calc4_check
97 #define yyname quote_calc4_name
101 #define yyrule quote_calc4_rule
107 #define yycindex quote_calc4_cindex
108 #endif /* yycindex */
111 #define yyctable quote_calc4_ctable
112 #endif /* yyctable */
114 #endif /* YYBTYACC */
116 #define YYPREFIX "quote_calc4_"
120 #line 2 "quote_calc4.y"
128 static void yyerror(const char *s);
130 #line 131 "quote_calc4.tab.c"
132 #if ! defined(YYSTYPE) && ! defined(YYSTYPE_IS_DECLARED)
133 /* Default: YYSTYPE is the semantic value type. */
135 # define YYSTYPE_IS_DECLARED 1
138 /* compatibility with bison */
140 /* compatibility with FreeBSD */
141 # ifdef YYPARSE_PARAM_TYPE
142 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
144 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
147 # define YYPARSE_DECL() yyparse(void)
150 /* Parameters sent to lex. */
152 # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
153 # define YYLEX yylex(YYLEX_PARAM)
155 # define YYLEX_DECL() yylex(void)
156 # define YYLEX yylex()
159 /* Parameters sent to yyerror. */
161 #define YYERROR_DECL() yyerror(const char *s)
164 #define YYERROR_CALL(msg) yyerror(msg)
167 extern int YYPARSE_DECL();
178 #define YYERRCODE 256
180 static const YYINT quote_calc4_lhs[] = { -1,
181 0, 0, 0, 1, 1, 2, 2, 2, 2, 2,
182 2, 2, 2, 2, 2, 2, 3, 3,
184 static const YYINT quote_calc4_len[] = { 2,
185 0, 3, 3, 1, 3, 3, 3, 3, 3, 3,
186 3, 3, 3, 2, 1, 1, 1, 2,
188 static const YYINT quote_calc4_defred[] = { 1,
189 0, 0, 0, 17, 0, 0, 0, 0, 0, 3,
190 15, 0, 0, 0, 2, 0, 0, 0, 0, 0,
191 0, 0, 18, 0, 6, 0, 0, 0, 0, 0,
194 #if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING)
195 static const YYINT quote_calc4_stos[] = { 0,
196 273, 256, 260, 269, 270, 40, 274, 275, 276, 10,
197 270, 275, 61, 275, 10, 258, 260, 262, 264, 266,
198 268, 124, 269, 275, 41, 275, 275, 275, 275, 275,
201 #endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */
202 static const YYINT quote_calc4_dgoto[] = { 1,
205 static const YYINT quote_calc4_sindex[] = { 0,
206 -38, 4, -36, 0, -51, -36, 6, -121, -249, 0,
207 0, -243, -36, -23, 0, -36, -36, -36, -36, -36,
208 -36, -36, 0, -121, 0, -121, -121, -121, -121, -121,
211 static const YYINT quote_calc4_rindex[] = { 0,
212 0, 0, 0, 0, -9, 0, 0, 12, -10, 0,
213 0, -5, 0, 0, 0, 0, 0, 0, 0, 0,
214 0, 0, 0, 14, 0, -3, -2, -1, 1, 2,
218 static const YYINT quote_calc4_cindex[] = { 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, 0, 0, 0, 0, 0, 0, 0, 0,
225 static const YYINT quote_calc4_gindex[] = { 0,
228 #define YYTABLESIZE 259
229 static const YYINT quote_calc4_table[] = { 16,
230 15, 6, 22, 6, 14, 13, 7, 8, 9, 13,
231 10, 11, 12, 10, 16, 15, 17, 25, 18, 23,
232 19, 4, 20, 5, 21, 0, 0, 0, 0, 0,
233 16, 0, 0, 0, 0, 14, 13, 7, 8, 9,
234 0, 10, 11, 12, 12, 0, 0, 14, 0, 0,
235 0, 0, 0, 0, 24, 0, 0, 26, 27, 28,
236 29, 30, 31, 32, 0, 0, 0, 0, 0, 0,
237 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
238 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
239 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
240 22, 0, 0, 0, 0, 0, 0, 0, 0, 0,
241 0, 0, 0, 16, 15, 0, 0, 0, 14, 13,
242 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
243 0, 0, 0, 0, 0, 0, 16, 0, 17, 0,
244 18, 0, 19, 0, 20, 0, 21, 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, 0, 0, 0, 0, 0,
251 0, 0, 0, 0, 0, 0, 0, 2, 0, 0,
252 0, 3, 0, 3, 0, 0, 0, 0, 0, 0,
253 4, 5, 4, 11, 16, 0, 17, 0, 18, 0,
254 19, 0, 20, 0, 21, 0, 0, 16, 15, 16,
255 15, 16, 15, 16, 15, 16, 15, 16, 15,
257 static const YYINT quote_calc4_check[] = { 10,
258 10, 40, 124, 40, 10, 10, 10, 10, 10, 61,
259 10, 10, 10, 10, 258, 10, 260, 41, 262, 269,
260 264, 10, 266, 10, 268, -1, -1, -1, -1, -1,
261 41, -1, -1, -1, -1, 41, 41, 41, 41, 41,
262 -1, 41, 41, 41, 3, -1, -1, 6, -1, -1,
263 -1, -1, -1, -1, 13, -1, -1, 16, 17, 18,
264 19, 20, 21, 22, -1, -1, -1, -1, -1, -1,
265 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
266 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
267 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
268 124, -1, -1, -1, -1, -1, -1, -1, -1, -1,
269 -1, -1, -1, 124, 124, -1, -1, -1, 124, 124,
270 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
271 -1, -1, -1, -1, -1, -1, 258, -1, 260, -1,
272 262, -1, 264, -1, 266, -1, 268, -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, -1, -1, -1, -1, -1,
278 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
279 -1, -1, -1, -1, -1, -1, -1, 256, -1, -1,
280 -1, 260, -1, 260, -1, -1, -1, -1, -1, -1,
281 269, 270, 269, 270, 258, -1, 260, -1, 262, -1,
282 264, -1, 266, -1, 268, -1, -1, 258, 258, 260,
283 260, 262, 262, 264, 264, 266, 266, 268, 268,
286 static const YYINT quote_calc4_ctable[] = { -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, -1,
303 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
304 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
305 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
306 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
307 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
308 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
309 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
310 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
311 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
312 -1, -1, -1, -1, -1, -1, -1, -1,
319 #define YYMAXTOKEN 271
320 #define YYUNDFTOKEN 277
321 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
323 static const char *const quote_calc4_name[] = {
325 "$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,
326 0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,
327 0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
328 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,0,0,0,
329 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
330 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
331 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
332 0,0,"error","OP_ADD","\"ADD-operator\"","OP_SUB","\"SUB-operator\"","OP_MUL",
333 "\"MUL-operator\"","OP_DIV","\"DIV-operator\"","OP_MOD","\"MOD-operator\"",
334 "OP_AND","\"AND-operator\"","DIGIT","LETTER","UMINUS","$accept","list","stat",
335 "expr","number","illegal-symbol",
337 static const char *const quote_calc4_rule[] = {
340 "list : list stat '\\n'",
341 "list : list error '\\n'",
343 "stat : LETTER '=' expr",
344 "expr : '(' expr ')'",
345 "expr : expr \"ADD-operator\" expr",
346 "expr : expr \"SUB-operator\" expr",
347 "expr : expr \"MUL-operator\" expr",
348 "expr : expr \"DIV-operator\" expr",
349 "expr : expr \"MOD-operator\" expr",
350 "expr : expr \"AND-operator\" expr",
351 "expr : expr '|' expr",
352 "expr : \"SUB-operator\" expr",
356 "number : number DIGIT",
368 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
369 YYLTYPE yyloc; /* position returned by actions */
370 YYLTYPE yylloc; /* position from the lexer */
373 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
374 #ifndef YYLLOC_DEFAULT
375 #define YYLLOC_DEFAULT(loc, rhs, n) \
380 (loc).first_line = ((rhs)[-1]).last_line; \
381 (loc).first_column = ((rhs)[-1]).last_column; \
382 (loc).last_line = ((rhs)[-1]).last_line; \
383 (loc).last_column = ((rhs)[-1]).last_column; \
387 (loc).first_line = ((rhs)[ 0 ]).first_line; \
388 (loc).first_column = ((rhs)[ 0 ]).first_column; \
389 (loc).last_line = ((rhs)[n-1]).last_line; \
390 (loc).last_column = ((rhs)[n-1]).last_column; \
393 #endif /* YYLLOC_DEFAULT */
394 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
397 #ifndef YYLVQUEUEGROWTH
398 #define YYLVQUEUEGROWTH 32
400 #endif /* YYBTYACC */
402 /* define the initial stack-sizes */
405 #define YYMAXDEPTH YYSTACKSIZE
408 #define YYSTACKSIZE YYMAXDEPTH
410 #define YYSTACKSIZE 10000
411 #define YYMAXDEPTH 10000
415 #ifndef YYINITSTACKSIZE
416 #define YYINITSTACKSIZE 200
426 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
433 struct YYParseState_s
435 struct YYParseState_s *save; /* Previously saved parser state */
436 YYSTACKDATA yystack; /* saved parser stack */
437 int state; /* saved parser state */
438 int errflag; /* saved error recovery status */
439 int lexeme; /* saved index of the conflict lexeme in the lexical queue */
440 YYINT ctry; /* saved index in yyctable[] for this conflict */
442 typedef struct YYParseState_s YYParseState;
443 #endif /* YYBTYACC */
444 /* variables for the parser stack */
445 static YYSTACKDATA yystack;
448 /* Current parser state */
449 static YYParseState *yyps = 0;
451 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
452 static YYParseState *yypath = 0;
454 /* Base of the lexical value queue */
455 static YYSTYPE *yylvals = 0;
457 /* Current position at lexical value queue */
458 static YYSTYPE *yylvp = 0;
460 /* End position of lexical value queue */
461 static YYSTYPE *yylve = 0;
463 /* The last allocated position at the lexical value queue */
464 static YYSTYPE *yylvlim = 0;
466 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
467 /* Base of the lexical position queue */
468 static YYLTYPE *yylpsns = 0;
470 /* Current position at lexical position queue */
471 static YYLTYPE *yylpp = 0;
473 /* End position of lexical position queue */
474 static YYLTYPE *yylpe = 0;
476 /* The last allocated position at the lexical position queue */
477 static YYLTYPE *yylplim = 0;
480 /* Current position at lexical token queue */
481 static YYINT *yylexp = 0;
483 static YYINT *yylexemes = 0;
484 #endif /* YYBTYACC */
485 #line 73 "quote_calc4.y"
486 /* start of programs */
491 while(!feof(stdin)) {
498 yyerror(const char *s)
500 fprintf(stderr, "%s\n", s);
505 /* lexical analysis routine */
506 /* returns LETTER for a lower case letter, yylval = 0 through 25 */
507 /* return DIGIT for a digit, yylval = 0 through 9 */
508 /* all other characters are returned immediately */
512 while( (c=getchar()) == ' ' ) { /* skip blanks */ }
514 /* c is now nonblank */
526 #line 527 "quote_calc4.tab.c"
528 /* For use in generated program */
529 #define yydepth (int)(yystack.s_mark - yystack.s_base)
531 #define yytrial (yyps->save)
532 #endif /* YYBTYACC */
535 #include <stdio.h> /* needed for printf */
538 #include <stdlib.h> /* needed for malloc, etc */
539 #include <string.h> /* needed for memset */
541 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
542 static int yygrowstack(YYSTACKDATA *data)
548 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
552 if ((newsize = data->stacksize) == 0)
553 newsize = YYINITSTACKSIZE;
554 else if (newsize >= YYMAXDEPTH)
556 else if ((newsize *= 2) > YYMAXDEPTH)
557 newsize = YYMAXDEPTH;
559 i = (int) (data->s_mark - data->s_base);
560 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
564 data->s_base = newss;
565 data->s_mark = newss + i;
567 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
571 data->l_base = newvs;
572 data->l_mark = newvs + i;
574 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
575 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
579 data->p_base = newps;
580 data->p_mark = newps + i;
583 data->stacksize = newsize;
584 data->s_last = data->s_base + newsize - 1;
588 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
593 #if YYPURE || defined(YY_NO_LEAKS)
594 static void yyfreestack(YYSTACKDATA *data)
598 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
601 memset(data, 0, sizeof(*data));
604 #define yyfreestack(data) /* nothing */
605 #endif /* YYPURE || defined(YY_NO_LEAKS) */
608 static YYParseState *
609 yyNewState(unsigned size)
611 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
612 if (p == NULL) return NULL;
614 p->yystack.stacksize = size;
617 p->yystack.s_base = NULL;
618 p->yystack.l_base = NULL;
619 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
620 p->yystack.p_base = NULL;
624 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT));
625 if (p->yystack.s_base == NULL) return NULL;
626 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
627 if (p->yystack.l_base == NULL) return NULL;
628 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
629 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
630 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
631 if (p->yystack.p_base == NULL) return NULL;
632 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
639 yyFreeState(YYParseState *p)
641 yyfreestack(&p->yystack);
644 #endif /* YYBTYACC */
646 #define YYABORT goto yyabort
647 #define YYREJECT goto yyabort
648 #define YYACCEPT goto yyaccept
649 #define YYERROR goto yyerrlab
651 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
652 #define YYVALID_NESTED do { if (yyps->save && \
653 yyps->save->save == 0) goto yyvalid; } while(0)
654 #endif /* YYBTYACC */
659 int yym, yyn, yystate, yyresult;
662 YYParseState *yyerrctx = NULL;
663 #endif /* YYBTYACC */
664 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
665 YYLTYPE yyerror_loc_range[2]; /* position of error start & end */
670 if ((yys = getenv("YYDEBUG")) != 0)
673 if (yyn >= '0' && yyn <= '9')
677 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
681 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
683 #endif /* YYBTYACC */
692 memset(&yystack, 0, sizeof(yystack));
695 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
696 yystack.s_mark = yystack.s_base;
697 yystack.l_mark = yystack.l_base;
698 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
699 yystack.p_mark = yystack.p_base;
705 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
712 /* we're currently re-reading tokens */
714 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
722 /* in trial mode; save scanner results for future parse attempts */
723 if (yylvp == yylvlim)
724 { /* Enlarge lexical value queue */
725 size_t p = (size_t) (yylvp - yylvals);
726 size_t s = (size_t) (yylvlim - yylvals);
728 s += YYLVQUEUEGROWTH;
729 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
730 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
731 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
732 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
734 yylvp = yylve = yylvals + p;
735 yylvlim = yylvals + s;
736 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
737 yylpp = yylpe = yylpsns + p;
738 yylplim = yylpsns + s;
740 yylexp = yylexemes + p;
742 *yylexp = (YYINT) YYLEX;
745 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
752 /* normal operation, no conflict encountered */
753 #endif /* YYBTYACC */
757 #endif /* YYBTYACC */
758 if (yychar < 0) yychar = YYEOF;
762 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
763 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
764 YYDEBUGSTR, yydepth, yystate, yychar, yys);
765 #ifdef YYSTYPE_TOSTRING
768 #endif /* YYBTYACC */
769 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
777 /* Do we have a conflict? */
778 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
779 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
788 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
789 YYDEBUGSTR, yydepth, yystate);
791 /* Switch to the next conflict context */
796 if (save->state != yystate) YYABORT;
803 /* Unresolved conflict - start/continue trial parse */
808 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
810 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
812 fputs("Starting trial parse.\n", stderr);
815 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
816 if (save == NULL) goto yyenomem;
817 save->save = yyps->save;
818 save->state = yystate;
819 save->errflag = yyerrflag;
820 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
821 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
822 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
823 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
824 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
825 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
826 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
829 if (yyctable[ctry] == -1)
832 if (yydebug && yychar >= YYEOF)
833 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
838 if (yyps->save == NULL)
840 /* If this is a first conflict in the stack, start saving lexemes */
843 yylexemes = malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
844 if (yylexemes == NULL) goto yyenomem;
845 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
846 if (yylvals == NULL) goto yyenomem;
847 yylvlim = yylvals + YYLVQUEUEGROWTH;
848 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
849 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
850 if (yylpsns == NULL) goto yyenomem;
851 yylplim = yylpsns + YYLVQUEUEGROWTH;
856 yylvp = yylve = yylvals;
857 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
858 yylpp = yylpe = yylpsns;
864 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
867 *yylexp = (YYINT) yychar;
875 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
881 save->lexeme = (int) (yylvp - yylvals);
884 if (yytable[yyn] == ctry)
888 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
889 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
894 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
899 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
901 yystate = yyctable[ctry];
902 *++yystack.s_mark = (YYINT) yystate;
903 *++yystack.l_mark = yylval;
904 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
905 *++yystack.p_mark = yylloc;
908 if (yyerrflag > 0) --yyerrflag;
913 yyn = yyctable[ctry];
916 } /* End of code dealing with conflicts */
917 #endif /* YYBTYACC */
918 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
919 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
923 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
924 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
926 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
927 yystate = yytable[yyn];
928 *++yystack.s_mark = yytable[yyn];
929 *++yystack.l_mark = yylval;
930 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
931 *++yystack.p_mark = yylloc;
934 if (yyerrflag > 0) --yyerrflag;
937 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
938 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
943 if (yyerrflag != 0) goto yyinrecovery;
948 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
951 /* explicit YYERROR from an action -- pop the rhs of the rule reduced
952 * before looking for error recovery */
953 yystack.s_mark -= yym;
954 yystate = *yystack.s_mark;
955 yystack.l_mark -= yym;
956 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
957 yystack.p_mark -= yym;
965 YYParseState *save = yyps->save;
968 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
969 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
970 (int)(yylvp - yylvals - yyps->save->lexeme));
972 /* Memorize most forward-looking error state in case it's really an error. */
973 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
975 /* Free old saved error context state */
976 if (yyerrctx) yyFreeState(yyerrctx);
977 /* Create and fill out new saved error context state */
978 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
979 if (yyerrctx == NULL) goto yyenomem;
980 yyerrctx->save = yyps->save;
981 yyerrctx->state = yystate;
982 yyerrctx->errflag = yyerrflag;
983 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
984 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
985 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
986 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
987 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
988 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
989 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
991 yyerrctx->lexeme = (int) (yylvp - yylvals);
993 yylvp = yylvals + save->lexeme;
994 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
995 yylpp = yylpsns + save->lexeme;
997 yylexp = yylexemes + save->lexeme;
999 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
1000 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1001 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
1002 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1003 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1004 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
1005 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1007 ctry = ++save->ctry;
1008 yystate = save->state;
1009 /* We tried shift, try reduce now */
1010 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
1011 yyps->save = save->save;
1015 /* Nothing left on the stack -- error */
1020 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1023 /* Restore state as it was in the most forward-advanced error */
1024 yylvp = yylvals + yyerrctx->lexeme;
1025 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1026 yylpp = yylpsns + yyerrctx->lexeme;
1028 yylexp = yylexemes + yyerrctx->lexeme;
1029 yychar = yylexp[-1];
1031 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1034 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1035 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1036 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1037 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1038 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1039 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1040 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1042 yystate = yyerrctx->state;
1043 yyFreeState(yyerrctx);
1048 if (yynewerrflag == 0) goto yyinrecovery;
1049 #endif /* YYBTYACC */
1051 YYERROR_CALL("syntax error");
1052 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1053 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
1057 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1068 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1069 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1073 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1074 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1076 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1077 yystate = yytable[yyn];
1078 *++yystack.s_mark = yytable[yyn];
1079 *++yystack.l_mark = yylval;
1080 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1081 /* lookahead position is error end position */
1082 yyerror_loc_range[1] = yylloc;
1083 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1084 *++yystack.p_mark = yyloc;
1092 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1093 YYDEBUGSTR, yydepth, *yystack.s_mark);
1095 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1096 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1097 /* the current TOS position is the error start position */
1098 yyerror_loc_range[0] = *yystack.p_mark;
1100 #if defined(YYDESTRUCT_CALL)
1103 #endif /* YYBTYACC */
1104 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1105 YYDESTRUCT_CALL("error: discarding state",
1106 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1108 YYDESTRUCT_CALL("error: discarding state",
1109 yystos[*yystack.s_mark], yystack.l_mark);
1110 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1111 #endif /* defined(YYDESTRUCT_CALL) */
1114 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1122 if (yychar == YYEOF) goto yyabort;
1126 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1127 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1128 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1131 #if defined(YYDESTRUCT_CALL)
1134 #endif /* YYBTYACC */
1135 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1136 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1138 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1139 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1140 #endif /* defined(YYDESTRUCT_CALL) */
1150 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1151 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1152 #ifdef YYSTYPE_TOSTRING
1155 #endif /* YYBTYACC */
1160 for (i = yym; i > 0; i--)
1162 if (i != yym) fputs(", ", stderr);
1163 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1164 yystack.l_mark[1-i]), stderr);
1169 fputc('\n', stderr);
1173 yyval = yystack.l_mark[1-yym];
1175 memset(&yyval, 0, sizeof yyval);
1176 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1178 /* Perform position reduction */
1179 memset(&yyloc, 0, sizeof(yyloc));
1182 #endif /* YYBTYACC */
1184 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
1185 /* just in case YYERROR is invoked within the action, save
1186 the start of the rhs as the error start position */
1187 yyerror_loc_range[0] = yystack.p_mark[1-yym];
1194 #line 35 "quote_calc4.y"
1198 #line 39 "quote_calc4.y"
1199 { printf("%d\n",yystack.l_mark[0]);}
1202 #line 41 "quote_calc4.y"
1203 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
1206 #line 45 "quote_calc4.y"
1207 { yyval = yystack.l_mark[-1]; }
1210 #line 47 "quote_calc4.y"
1211 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
1214 #line 49 "quote_calc4.y"
1215 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
1218 #line 51 "quote_calc4.y"
1219 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
1222 #line 53 "quote_calc4.y"
1223 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
1226 #line 55 "quote_calc4.y"
1227 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
1230 #line 57 "quote_calc4.y"
1231 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
1234 #line 59 "quote_calc4.y"
1235 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
1238 #line 61 "quote_calc4.y"
1239 { yyval = - yystack.l_mark[0]; }
1242 #line 63 "quote_calc4.y"
1243 { yyval = regs[yystack.l_mark[0]]; }
1246 #line 68 "quote_calc4.y"
1247 { yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
1250 #line 70 "quote_calc4.y"
1251 { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
1253 #line 1254 "quote_calc4.tab.c"
1257 yystack.s_mark -= yym;
1258 yystate = *yystack.s_mark;
1259 yystack.l_mark -= yym;
1260 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1261 yystack.p_mark -= yym;
1264 if (yystate == 0 && yym == 0)
1269 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1270 #ifdef YYSTYPE_TOSTRING
1273 #endif /* YYBTYACC */
1274 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1276 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1280 *++yystack.s_mark = YYFINAL;
1281 *++yystack.l_mark = yyval;
1282 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1283 *++yystack.p_mark = yyloc;
1291 /* we're currently re-reading tokens */
1293 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1301 /* in trial mode; save scanner results for future parse attempts */
1302 if (yylvp == yylvlim)
1303 { /* Enlarge lexical value queue */
1304 size_t p = (size_t) (yylvp - yylvals);
1305 size_t s = (size_t) (yylvlim - yylvals);
1307 s += YYLVQUEUEGROWTH;
1308 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL)
1310 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1312 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1313 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1316 yylvp = yylve = yylvals + p;
1317 yylvlim = yylvals + s;
1318 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1319 yylpp = yylpe = yylpsns + p;
1320 yylplim = yylpsns + s;
1322 yylexp = yylexemes + p;
1324 *yylexp = (YYINT) YYLEX;
1327 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1334 /* normal operation, no conflict encountered */
1335 #endif /* YYBTYACC */
1339 #endif /* YYBTYACC */
1340 if (yychar < 0) yychar = YYEOF;
1344 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1345 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
1346 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1350 if (yychar == YYEOF) goto yyaccept;
1353 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1354 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1355 yystate = yytable[yyn];
1357 yystate = yydgoto[yym];
1361 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1362 #ifdef YYSTYPE_TOSTRING
1365 #endif /* YYBTYACC */
1366 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1368 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1371 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1372 *++yystack.s_mark = (YYINT) yystate;
1373 *++yystack.l_mark = yyval;
1374 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1375 *++yystack.p_mark = yyloc;
1380 /* Reduction declares that this path is valid. Set yypath and do a full parse */
1382 if (yypath) YYABORT;
1385 YYParseState *save = yyps->save;
1386 yyps->save = save->save;
1387 save->save = yypath;
1392 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1393 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1397 yyFreeState(yyerrctx);
1400 yylvp = yylvals + yypath->lexeme;
1401 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1402 yylpp = yylpsns + yypath->lexeme;
1404 yylexp = yylexemes + yypath->lexeme;
1406 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1407 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1408 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1409 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1410 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1411 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1412 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1414 yystate = yypath->state;
1416 #endif /* YYBTYACC */
1419 YYERROR_CALL("yacc stack overflow");
1423 YYERROR_CALL("memory exhausted");
1425 #endif /* YYBTYACC */
1435 if (yyps->save) goto yyvalid;
1436 #endif /* YYBTYACC */
1440 #if defined(YYDESTRUCT_CALL)
1441 if (yychar != YYEOF && yychar != YYEMPTY)
1442 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1443 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1445 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1446 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1450 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1453 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1454 YYDESTRUCT_CALL("cleanup: discarding state",
1455 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1457 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1458 YYDESTRUCT_CALL("cleanup: discarding state",
1459 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1460 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1462 #endif /* defined(YYDESTRUCT_CALL) */
1467 yyFreeState(yyerrctx);
1472 YYParseState *save = yyps;
1479 YYParseState *save = yypath;
1480 yypath = save->save;
1484 #endif /* YYBTYACC */
1485 yyfreestack(&yystack);