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 expr.oxout_parse
25 #define yylex expr.oxout_lex
29 #define yyerror expr.oxout_error
33 #define yychar expr.oxout_char
37 #define yyval expr.oxout_val
41 #define yylval expr.oxout_lval
45 #define yydebug expr.oxout_debug
49 #define yynerrs expr.oxout_nerrs
53 #define yyerrflag expr.oxout_errflag
54 #endif /* yyerrflag */
57 #define yylhs expr.oxout_lhs
61 #define yylen expr.oxout_len
65 #define yydefred expr.oxout_defred
69 #define yystos expr.oxout_stos
73 #define yydgoto expr.oxout_dgoto
77 #define yysindex expr.oxout_sindex
81 #define yyrindex expr.oxout_rindex
85 #define yygindex expr.oxout_gindex
89 #define yytable expr.oxout_table
93 #define yycheck expr.oxout_check
97 #define yyname expr.oxout_name
101 #define yyrule expr.oxout_rule
107 #define yycindex expr.oxout_cindex
108 #endif /* yycindex */
111 #define yyctable expr.oxout_ctable
112 #endif /* yyctable */
114 #endif /* YYBTYACC */
116 #define YYPREFIX "expr.oxout_"
120 #line 5 "expr.oxout.y"
125 #include "expr.oxout.h"
128 extern int yylex(void);
129 extern void yyerror(const char *);
130 #line 27 "expr.oxout.y"
132 #define yyyR USHRT_MAX
134 #undef YYSTYPE_IS_DECLARED
135 #define YYSTYPE_IS_DECLARED 1
137 #ifndef YYSTYPE_IS_DECLARED
138 #define YYSTYPE_IS_DECLARED 1
139 #line 31 "expr.oxout.y"
142 struct yyyStackItem *yyyOxStackItem;
145 #endif /* !YYSTYPE_IS_DECLARED */
146 #line 38 "expr.oxout.y"
150 static int yyyYok = 1;
152 extern yyyFT yyyRCIL[];
154 void yyyExecuteRRsection(yyyGNT *rootNode);
155 void yyyYoxInit(void);
156 void yyyDecorate(void);
157 struct yyyOxAttrbs; /* hack required to compensate for 'msta' behavior */
158 void yyyGenIntNode(long yyyProdNum, int yyyRHSlength, int yyyNattrbs, struct yyyOxAttrbs *yyval_OxAttrbs, ...);
159 void yyyAdjustINRC(long yyyProdNum, int yyyRHSlength, long startP, long stopP, struct yyyOxAttrbs *yyval_OxAttrbs, ...);
160 void yyyCheckUnsolvedInstTrav(yyyGNT *rootNode,long *nNZrc,long *cycleSum);
161 void yyyUnsolvedInstSearchTrav(yyyGNT *pNode);
162 void yyyUnsolvedInstSearchTravAux(yyyGNT *pNode);
165 #line 166 "expr.oxout.tab.c"
167 /* compatibility with bison */
169 /* compatibility with FreeBSD */
170 # ifdef YYPARSE_PARAM_TYPE
171 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
173 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
176 # define YYPARSE_DECL() yyparse(void)
179 /* Parameters sent to lex. */
181 # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
182 # define YYLEX yylex(YYLEX_PARAM)
184 # define YYLEX_DECL() yylex(void)
185 # define YYLEX yylex()
188 /* Parameters sent to yyerror. */
190 #define YYERROR_DECL() yyerror(const char *s)
193 #define YYERROR_CALL(msg) yyerror(msg)
196 extern int YYPARSE_DECL();
200 #define YYERRCODE 256
202 static const YYINT expr.oxout_lhs[] = { -1,
203 2, 0, 1, 3, 3, 3, 3, 3, 3, 3,
205 static const YYINT expr.oxout_len[] = { 2,
206 0, 2, 1, 3, 3, 3, 3, 3, 1, 1,
208 static const YYINT expr.oxout_defred[] = { 1,
209 0, 0, 9, 10, 0, 2, 0, 0, 0, 0,
212 #if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING)
213 static const YYINT expr.oxout_stos[] = { 0,
214 260, 262, 257, 258, 40, 261, 263, 263, 43, 45,
215 42, 47, 41, 263, 263, 263, 263,
217 #endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */
218 static const YYINT expr.oxout_dgoto[] = { 1,
221 static const YYINT expr.oxout_sindex[] = { 0,
222 0, -40, 0, 0, -40, 0, -18, -24, -40, -40,
223 -40, -40, 0, -37, -37, 0, -39,
225 static const YYINT expr.oxout_rindex[] = { 0,
226 0, 0, 0, 0, 0, 0, 6, 0, 0, 0,
230 static const YYINT expr.oxout_cindex[] = { 0,
231 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
235 static const YYINT expr.oxout_gindex[] = { 0,
238 #define YYTABLESIZE 218
239 static const YYINT expr.oxout_table[] = { 5,
240 6, 5, 11, 0, 11, 3, 0, 7, 8, 12,
241 0, 0, 14, 15, 16, 17, 13, 11, 9, 0,
242 10, 0, 12, 11, 9, 0, 10, 0, 12, 0,
243 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
244 0, 6, 5, 6, 5, 6, 5, 6, 7, 0,
245 7, 0, 7, 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, 0, 0, 0,
252 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
253 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
254 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
255 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
256 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
257 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
258 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
259 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
260 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
261 0, 0, 0, 0, 0, 0, 3, 4,
263 static const YYINT expr.oxout_check[] = { 40,
264 0, 0, 42, -1, 42, 0, -1, 0, 5, 47,
265 -1, -1, 9, 10, 11, 12, 41, 42, 43, -1,
266 45, -1, 47, 42, 43, -1, 45, -1, 47, -1,
267 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
268 -1, 41, 41, 43, 43, 45, 45, 47, 41, -1,
269 43, -1, 45, -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, -1, -1, -1, -1, -1,
275 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
276 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
277 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
278 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
279 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
280 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
281 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
282 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
283 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
284 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
285 -1, -1, -1, -1, -1, -1, 257, 258,
288 static const YYINT expr.oxout_ctable[] = { -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,
317 #define YYMAXTOKEN 258
318 #define YYUNDFTOKEN 264
319 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
321 static const char *const expr.oxout_name[] = {
323 "$end",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
324 0,0,0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
325 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,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,0,0,0,0,0,0,0,0,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,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,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,"error","ID",
330 "CONST","$accept","yyyAugNonterm","s","$$1","expr","illegal-symbol",
332 static const char *const expr.oxout_rule[] = {
333 "$accept : yyyAugNonterm",
335 "yyyAugNonterm : $$1 s",
337 "expr : expr '*' expr",
338 "expr : expr '+' expr",
339 "expr : expr '/' expr",
340 "expr : expr '-' expr",
341 "expr : '(' expr ')'",
355 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
356 YYLTYPE yyloc; /* position returned by actions */
357 YYLTYPE yylloc; /* position from the lexer */
360 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
361 #ifndef YYLLOC_DEFAULT
362 #define YYLLOC_DEFAULT(loc, rhs, n) \
367 (loc).first_line = ((rhs)[-1]).last_line; \
368 (loc).first_column = ((rhs)[-1]).last_column; \
369 (loc).last_line = ((rhs)[-1]).last_line; \
370 (loc).last_column = ((rhs)[-1]).last_column; \
374 (loc).first_line = ((rhs)[ 0 ]).first_line; \
375 (loc).first_column = ((rhs)[ 0 ]).first_column; \
376 (loc).last_line = ((rhs)[n-1]).last_line; \
377 (loc).last_column = ((rhs)[n-1]).last_column; \
380 #endif /* YYLLOC_DEFAULT */
381 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
384 #ifndef YYLVQUEUEGROWTH
385 #define YYLVQUEUEGROWTH 32
387 #endif /* YYBTYACC */
389 /* define the initial stack-sizes */
392 #define YYMAXDEPTH YYSTACKSIZE
395 #define YYSTACKSIZE YYMAXDEPTH
397 #define YYSTACKSIZE 10000
398 #define YYMAXDEPTH 10000
402 #ifndef YYINITSTACKSIZE
403 #define YYINITSTACKSIZE 200
413 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
420 struct YYParseState_s
422 struct YYParseState_s *save; /* Previously saved parser state */
423 YYSTACKDATA yystack; /* saved parser stack */
424 int state; /* saved parser state */
425 int errflag; /* saved error recovery status */
426 int lexeme; /* saved index of the conflict lexeme in the lexical queue */
427 YYINT ctry; /* saved index in yyctable[] for this conflict */
429 typedef struct YYParseState_s YYParseState;
430 #endif /* YYBTYACC */
431 /* variables for the parser stack */
432 static YYSTACKDATA yystack;
435 /* Current parser state */
436 static YYParseState *yyps = 0;
438 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
439 static YYParseState *yypath = 0;
441 /* Base of the lexical value queue */
442 static YYSTYPE *yylvals = 0;
444 /* Current position at lexical value queue */
445 static YYSTYPE *yylvp = 0;
447 /* End position of lexical value queue */
448 static YYSTYPE *yylve = 0;
450 /* The last allocated position at the lexical value queue */
451 static YYSTYPE *yylvlim = 0;
453 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
454 /* Base of the lexical position queue */
455 static YYLTYPE *yylpsns = 0;
457 /* Current position at lexical position queue */
458 static YYLTYPE *yylpp = 0;
460 /* End position of lexical position queue */
461 static YYLTYPE *yylpe = 0;
463 /* The last allocated position at the lexical position queue */
464 static YYLTYPE *yylplim = 0;
467 /* Current position at lexical token queue */
468 static YYINT *yylexp = 0;
470 static YYINT *yylexemes = 0;
471 #endif /* YYBTYACC */
483 #line 138 "expr.oxout.y"
484 long yyySSALspaceSize = 20000;
485 long yyyRSmaxSize = 1000;
486 long yyyTravStackMaxSize = 2000;
488 struct yyySolvedSAlistCell {yyyWAT attrbNum;
492 #define yyyLambdaSSAL 0
493 long yyySSALCfreeList = yyyLambdaSSAL;
494 long yyyNewSSALC = 1;
496 struct yyySolvedSAlistCell *yyySSALspace;
498 long yyyNbytesStackStg;
504 short yyyIIIEL[] = {0,
505 0,2,6,10,14,18,22,24,
509 0,0,0,0,0,0,0,0,0,0,0,0,
510 0,0,0,0,0,0,0,0,0,0,0,0,
520 void yyyfatal(char *msg)
521 {fputs(msg,stderr);exit(-1);}
525 #define yyySSALof 'S'
531 void yyyHandleOverflow(char which)
533 long oldSize,newSize;
537 msg1 = "SSAL overflow: ";
538 oldSize = yyySSALspaceSize;
541 msg1 = "ready set overflow: ";
542 oldSize = yyyRSmaxSize;
545 msg1 = "traversal stack overflow: ";
546 oldSize = yyyTravStackMaxSize;
550 newSize = (3*oldSize)/2;
551 if (newSize < 100) newSize = 100;
553 fprintf(stderr,"size was %ld.\n",oldSize);
554 msg2 = " Have to modify evaluator: -Y%c%ld.\n";
555 fprintf(stderr,msg2,which,newSize);
561 void yyySignalEnts(yyyGNT *node,long startP,long stopP)
564 while (startP < stopP)
566 if (!yyyEntL[startP]) dumNode = node;
567 else dumNode = (node->cL)[yyyEntL[startP]-1];
568 if (!(--((dumNode->refCountList)[yyyEntL[startP+1]]
573 if (++yyyRSTop == yyyAfterRS)
574 {yyyHandleOverflow(yyyRSof);
577 yyyRSTop->node = dumNode;
578 yyyRSTop->whichSym = yyyEntL[startP];
579 yyyRSTop->wa = yyyEntL[startP+1];
590 void yyySolveAndSignal() {
593 yyyGNT *yyyRSTopN,*yyyRefN;
594 yyyParent yyyRSTopNp;
597 yyyRSTopNp = (yyyRSTopN = yyyRSTop->node)->parent;
598 yyyRefN= (yyyws = (yyyRSTop->whichSym))?yyyRSTopNp.noderef:yyyRSTopN;
599 yyywa = yyyRSTop->wa;
601 switch(yyyRefN->prodNum) {
602 case 1: /***yacc rule 1***/
606 case 2: /***yacc rule 2***/
610 case 3: /***yacc rule 3***/
614 case 4: /***yacc rule 4***/
618 case 5: /***yacc rule 5***/
622 case 6: /***yacc rule 6***/
626 case 7: /***yacc rule 7***/
634 case 8: /***yacc rule 8***/
644 if (yyyws) /* the just-solved instance was inherited. */
645 {if (yyyRSTopN->prodNum)
646 {yyyiDum = yyyIIEL[yyyIIIEL[yyyRSTopN->prodNum]] + yyywa;
647 yyySignalEnts(yyyRSTopN,yyyIEL[yyyiDum],
652 else /* the just-solved instance was synthesized. */
653 {if (!(yyyRSTopN->parentIsStack)) /* node has a parent. */
654 {yyyiDum = yyyIIEL[yyyIIIEL[yyyRSTopNp.noderef->prodNum] +
658 yyySignalEnts(yyyRSTopNp.noderef,
663 else /* node is still on the stack--it has no parent yet. */
664 {yyypL = &(yyyRSTopNp.stackref->solvedSAlist);
665 if (yyySSALCfreeList == yyyLambdaSSAL)
666 {yyySSALspace[yyyNewSSALC].next = *yyypL;
667 if ((*yyypL = yyyNewSSALC++) == yyySSALspaceSize)
668 yyyHandleOverflow(yyySSALof);
671 {yyyiDum = yyySSALCfreeList;
672 yyySSALCfreeList = yyySSALspace[yyySSALCfreeList].next;
673 yyySSALspace[yyyiDum].next = *yyypL;
676 yyySSALspace[*yyypL].attrbNum = yyywa;
680 } /* yyySolveAndSignal */
687 #define condStg unsigned int conds;
688 #define yyyClearConds {yyyTST->conds = 0;}
689 #define yyySetCond(n) {yyyTST->conds += (1<<(n));}
690 #define yyyCond(n) ((yyyTST->conds & (1<<(n)))?1:0)
694 struct yyyTravStackItem {yyyGNT *node;
701 void yyyDoTraversals(yyyGNT *rootNode)
702 {struct yyyTravStackItem *yyyTravStack,*yyyTST,*yyyAfterTravStack;
703 yyyGNT *yyyTSTn,**yyyCLptr2;
704 int yyyi,yyyRL,yyyPass;
709 ((struct yyyTravStackItem *)
710 calloc((size_t)yyyTravStackMaxSize,
711 (size_t)sizeof(struct yyyTravStackItem)
716 (struct yyyTravStackItem *)NULL
718 {fputs("malloc error in traversal stack allocation\n",stderr);
722 yyyAfterTravStack = yyyTravStack + yyyTravStackMaxSize;
726 for (yyyi=0; yyyi<2; yyyi++) {
727 yyyTST = yyyTravStack;
728 yyyTST->node = rootNode;
732 while(yyyTST >= yyyTravStack)
733 {yyyTSTn = yyyTST->node;
745 if (yyyTSTn->prodNum)
747 {yyyCLptr2 = yyyTSTn->cL;
750 {if (++yyyTST == yyyAfterTravStack)
751 yyyHandleOverflow(yyyTSof);
753 {yyyTST->node = *yyyCLptr2;
759 } /* right to left */
760 else /* left to right */
762 yyyCLptr2 = yyyTSTn->cL + i;
765 if (++yyyTST == yyyAfterTravStack)
766 yyyHandleOverflow(yyyTSof);
768 {yyyTST->node = *yyyCLptr2;
773 } /* left to right */
778 switch(yyyTSTn->prodNum) {
784 yyyRL = 0;yyySetCond(0)
789 #line 444 "expr.oxout.y"
795 if (yyyCond(0) != yyyPass) {
798 #line 453 "expr.oxout.y"
800 if (yyyCond(1) != yyyPass) {
804 #line 459 "expr.oxout.y"
806 if (yyyCond(2) != yyyPass) {
810 #line 465 "expr.oxout.y"
822 #line 477 "expr.oxout.y"
827 if (yyyCond(0) != yyyPass) {
831 #line 486 "expr.oxout.y"
833 if (yyyCond(1) != yyyPass) {
836 #line 491 "expr.oxout.y"
838 if (yyyCond(2) != yyyPass) {
840 printf("postfix: ")/* missing ; */
842 #line 497 "expr.oxout.y"
855 yyyRL = 0;yyySetCond(0)
859 if (yyyCond(0) != yyyPass) {
863 #line 518 "expr.oxout.y"
874 if (yyyCond(0) != yyyPass) {
878 #line 533 "expr.oxout.y"
891 yyyRL = 0;yyySetCond(0)
895 if (yyyCond(0) != yyyPass) {
899 #line 554 "expr.oxout.y"
910 if (yyyCond(0) != yyyPass) {
914 #line 569 "expr.oxout.y"
927 yyyRL = 0;yyySetCond(0)
931 if (yyyCond(0) != yyyPass) {
935 #line 590 "expr.oxout.y"
946 if (yyyCond(0) != yyyPass) {
950 #line 605 "expr.oxout.y"
963 yyyRL = 0;yyySetCond(0)
967 if (yyyCond(0) != yyyPass) {
971 #line 626 "expr.oxout.y"
982 if (yyyCond(0) != yyyPass) {
986 #line 641 "expr.oxout.y"
1022 yyyRL = 0;yyySetCond(0)
1026 if (yyyCond(0) != yyyPass) {
1028 printf(" %s ",yyyTSTn->cL[0]->yyyAttrbs.yyyAttrb1.lexeme);
1030 #line 685 "expr.oxout.y"
1041 if (yyyCond(0) != yyyPass) {
1043 printf(" %s ",yyyTSTn->cL[0]->yyyAttrbs.yyyAttrb1.lexeme);
1045 #line 700 "expr.oxout.y"
1058 yyyRL = 0;yyySetCond(0)
1062 if (yyyCond(0) != yyyPass) {
1064 printf(" %s ",yyyTSTn->cL[0]->yyyAttrbs.yyyAttrb1.lexeme);
1066 #line 721 "expr.oxout.y"
1077 if (yyyCond(0) != yyyPass) {
1079 printf(" %s ",yyyTSTn->cL[0]->yyyAttrbs.yyyAttrb1.lexeme);
1081 #line 736 "expr.oxout.y"
1090 if (yyyPass) goto yyyTpop; else goto yyyTpush;
1093 } /* yyyDoTraversals */
1095 void yyyExecuteRRsection(yyyGNT *rootNode) {
1100 if (!yyyYok) return;
1101 yyyCheckUnsolvedInstTrav(rootNode,&nNZrc,&cycleSum);
1104 fputs("\n\n\n**********\n",stderr);
1105 fputs("cycle detected in completed parse tree",stderr);
1106 fputs(" after decoration.\n",stderr);
1109 "number of unsolved attribute instances == %ld.\n",
1113 "total number of remaining dependencies == %ld.\n",
1116 fputs("average number of remaining dependencies\n",stderr);
1117 fprintf(stderr," per unsolved instance == %f.\n",
1118 ((float)(cycleSum)/(float)(nNZrc))
1122 "searching parse tree for %ld unsolved instances:\n",
1125 yyyUnsolvedInstSearchTravAux(rootNode);
1127 yyyDoTraversals(rootNode);
1128 } /* yyyExecuteRRsection */
1132 yyyWAT yyyLRCIL[2] = {0,0,
1137 void yyyYoxInit(void)
1139 static int yyyInitDone = 0;
1140 if (yyyInitDone) return;
1142 if ((yyyRS = (struct yyyRSitem *)
1143 calloc((size_t)(yyyRSmaxSize+1), (size_t)sizeof(struct yyyRSitem))
1146 ((struct yyyRSitem *) NULL)
1148 yyyfatal("malloc error in ox ready set space allocation\n");
1150 yyyAfterRS = yyyRS + yyyRSmaxSize;
1153 if ((yyySSALspace = (struct yyySolvedSAlistCell *)
1154 calloc((size_t)(yyySSALspaceSize+1), (size_t)sizeof(struct yyySolvedSAlistCell))
1157 ((struct yyySolvedSAlistCell *) NULL)
1159 yyyfatal("malloc error in stack solved list space allocation\n");
1162 yyyRSTop = yyyRS - 1;
1167 void yyyDecorate(void)
1169 while (yyyRSTop >= yyyRS)
1170 yyySolveAndSignal();
1175 void yyyGenIntNode(long yyyProdNum, int yyyRHSlength, int yyyNattrbs, struct yyyOxAttrbs *yyval_OxAttrbs, ...)
1177 yyySIT **yyyOxStackItem = &yyval_OxAttrbs->yyyOxStackItem;
1181 *yyyOxStackItem = (yyySIT *) malloc((size_t)sizeof(yyySIT));
1182 if (*yyyOxStackItem == (yyySIT *) NULL)
1183 yyyfatal("malloc error in ox yacc semantic stack space allocation\n");
1184 (*yyyOxStackItem)->node =
1185 (yyyGNT *) malloc((size_t)sizeof(yyyGNT));
1186 if ((*yyyOxStackItem)->node == (yyyGNT *) NULL)
1187 yyyfatal("malloc error in ox node space allocation\n");
1188 (*yyyOxStackItem)->solvedSAlist = yyyLambdaSSAL;
1189 (*yyyOxStackItem)->node->parent.stackref = *yyyOxStackItem;
1190 (*yyyOxStackItem)->node->parentIsStack = 1;
1191 (*yyyOxStackItem)->node->cLlen = yyyRHSlength;
1192 (*yyyOxStackItem)->node->cL =
1193 (yyyGNT **) calloc((size_t)yyyRHSlength, (size_t)sizeof(yyyGNT *));
1194 if ((*yyyOxStackItem)->node->cL == (yyyGNT **) NULL)
1195 yyyfatal("malloc error in ox child list space allocation\n");
1196 (*yyyOxStackItem)->node->refCountListLen = yyyNattrbs;
1197 (*yyyOxStackItem)->node->refCountList =
1198 (yyyRCT *) calloc((size_t)yyyNattrbs, (size_t)sizeof(yyyRCT));
1199 if ((*yyyOxStackItem)->node->refCountList == (yyyRCT *) NULL)
1200 yyyfatal("malloc error in ox reference count list space allocation\n");
1201 (*yyyOxStackItem)->node->prodNum = yyyProdNum;
1202 va_start(ap, yyval_OxAttrbs);
1203 for (i=1;i<=yyyRHSlength;i++)
1204 {yyySIT *yaccStDum = va_arg(ap,struct yyyOxAttrbs *)->yyyOxStackItem;
1205 gnpDum = (*yyyOxStackItem)->node->cL[i-1] = yaccStDum->node;
1206 gnpDum->whichSym = i;
1207 gnpDum->parent.noderef = (*yyyOxStackItem)->node;
1208 gnpDum->parentIsStack = 0;
1215 #define yyyDECORfREQ 50
1219 void yyyAdjustINRC(long yyyProdNum, int yyyRHSlength, long startP, long stopP, struct yyyOxAttrbs *yyval_OxAttrbs, ...)
1221 yyySIT *yyyOxStackItem = yyval_OxAttrbs->yyyOxStackItem;
1222 long SSALptr,SSALptrHead,*cPtrPtr;
1227 static unsigned short intNodeCount = yyyDECORfREQ;
1231 while (nextP < stopP)
1232 {if (yyyRCIL[nextP] == yyyR)
1233 {(yyyOxStackItem->node->refCountList)[yyyRCIL[nextP+1]] = yyyRCIL[nextP+2];
1236 {(((yyyOxStackItem->node->cL)[yyyRCIL[nextP]])->refCountList)[yyyRCIL[nextP+1]] = yyyRCIL[nextP+2];
1240 pL = yyyIIEL + yyyIIIEL[yyyProdNum];
1241 va_start(ap, yyval_OxAttrbs);
1242 for (i=1;i<=yyyRHSlength;i++)
1243 {yyySIT *yaccStDum = va_arg(ap,struct yyyOxAttrbs *)->yyyOxStackItem;
1245 SSALptrHead = SSALptr = *(cPtrPtr = &(yaccStDum->solvedSAlist));
1246 if (SSALptr != yyyLambdaSSAL)
1247 {*cPtrPtr = yyyLambdaSSAL;
1250 iTemp = (*pL+yyySSALspace[SSALptr].attrbNum);
1251 yyySignalEnts(yyyOxStackItem->node,
1255 SSALptr = *(cPtrPtr = &(yyySSALspace[SSALptr].next));
1257 while (SSALptr != yyyLambdaSSAL);
1258 *cPtrPtr = yyySSALCfreeList;
1259 yyySSALCfreeList = SSALptrHead;
1264 while (nextP < stopP)
1265 {if (!yyyRCIL[nextP])
1266 {if (yyyRCIL[nextP-2] == yyyR)
1267 {pL = &(yyyOxStackItem->solvedSAlist);
1268 if (yyySSALCfreeList == yyyLambdaSSAL)
1269 {yyySSALspace[yyyNewSSALC].next = *pL;
1270 if ((*pL = yyyNewSSALC++) == yyySSALspaceSize)
1271 yyyHandleOverflow(yyySSALof);
1274 {iTemp = yyySSALCfreeList;
1275 yyySSALCfreeList = yyySSALspace[yyySSALCfreeList].next;
1276 yyySSALspace[iTemp].next = *pL;
1279 yyySSALspace[*pL].attrbNum = yyyRCIL[nextP-1];
1282 {if ((gnpDum = (yyyOxStackItem->node->cL)[yyyRCIL[nextP-2]])->prodNum != 0)
1284 iTemp = yyyIIEL[yyyIIIEL[gnpDum->prodNum]] + yyyRCIL[nextP-1];
1285 yyySignalEnts(gnpDum,
1294 if (!--intNodeCount)
1295 {intNodeCount = yyyDECORfREQ;
1302 void yyyGenLeaf(int nAttrbs,int typeNum,long startP,long stopP,YYSTYPE *yylval)
1304 yyySIT **yyyOxStackItem = &yylval->yyyOxAttrbs.yyyOxStackItem;
1305 (*yyyOxStackItem) = (yyySIT *) malloc((size_t)sizeof(yyySIT));
1306 if ((*yyyOxStackItem) == (yyySIT *) NULL)
1307 yyyfatal("malloc error in ox yacc semantic stack space allocation\n");
1308 (*yyyOxStackItem)->node =
1309 (yyyGNT *) malloc((size_t)sizeof(yyyGNT))
1311 if ((*yyyOxStackItem)->node == (yyyGNT *) NULL)
1312 yyyfatal("malloc error in ox node space allocation\n");
1313 (*yyyOxStackItem)->solvedSAlist = yyyLambdaSSAL;
1314 (*yyyOxStackItem)->node->parent.stackref = *yyyOxStackItem;
1315 (*yyyOxStackItem)->node->parentIsStack = 1;
1316 (*yyyOxStackItem)->node->cLlen = 0;
1317 (*yyyOxStackItem)->node->cL = (yyyGNT **)NULL;
1318 (*yyyOxStackItem)->node->refCountListLen = nAttrbs;
1319 rcPdum = (*yyyOxStackItem)->node->refCountList =
1320 (yyyRCT *) calloc((size_t)nAttrbs, (size_t)sizeof(yyyRCT));
1321 if (rcPdum == (yyyRCT *) NULL)
1322 yyyfatal("malloc error in ox reference count list space allocation\n");
1323 while (startP < stopP) rcPdum[yyyLRCIL[startP++]] = 0;
1324 (*yyyOxStackItem)->node->prodNum = 0;
1325 (*yyyOxStackItem)->node->whichSym = 0;
1338 #define yyyLastProdNum 8
1344 int yyyProdsInd[] = {
1346 0, 2, 6, 10, 14, 18, 22, 24,
1351 int yyyProds[][2] = {
1352 { 116, 0},{ 462, 0},{ 462, 0},{ 462, 0},{ 412, 0},
1353 { 462, 0},{ 462, 0},{ 462, 0},{ 420, 0},{ 462, 0},
1354 { 462, 0},{ 462, 0},{ 452, 0},{ 462, 0},{ 462, 0},
1355 { 462, 0},{ 436, 0},{ 462, 0},{ 462, 0},{ 396, 0},
1356 { 462, 0},{ 404, 0},{ 462, 0},{ 619, 1},{ 462, 0},
1361 int yyySortsInd[] = {
1374 char *yyyStringTab[] = {
1457 0,0,"'*'","lexeme",0,
1488 0,0,"CONST","LRpost",0,
1626 #define yyySizeofProd(num) (yyyProdsInd[(num)+1] - yyyProdsInd[(num)])
1628 #define yyyGSoccurStr(prodNum,symPos) \
1629 (yyyStringTab[yyyProds[yyyProdsInd[(prodNum)] + (symPos)][0]])
1631 #define yyySizeofSort(num) (yyySortsInd[(num)+1] - yyySortsInd[(num)])
1633 #define yyySortOf(prodNum,symPos) \
1634 (yyyProds[yyyProdsInd[(prodNum)] + (symPos)][1])
1636 #define yyyAttrbStr(prodNum,symPos,attrbNum) \
1637 (yyyStringTab[yyySorts[yyySortsInd[yyySortOf(prodNum,symPos)] + \
1645 void yyyShowProd(int i)
1648 nSyms = yyySizeofProd(i);
1649 for (j=0; j<nSyms; j++)
1651 fprintf(stderr,"%s",yyyGSoccurStr(i,j));
1652 if (j == 0) fputs(" : ",stderr); else putc(' ',stderr);
1654 fputs(";\n",stderr);
1660 {int i; for (i=1; i<=yyyLastProdNum; i++) yyyShowProd(i);}
1664 void yyyShowSymsAndSorts()
1667 for (i=1; i<=yyyLastProdNum; i++)
1671 "\n\n\n---------------------------------- %3.1d\n",i);
1672 /* yyyShowProd(i); */
1673 nSyms = yyySizeofProd(i);
1674 for (j=0; j<nSyms; j++)
1677 fprintf(stderr,"%s\n",yyyGSoccurStr(i,j));
1678 sortSize = yyySizeofSort(yyySortOf(i,j));
1679 for (k=0; k<sortSize; k++)
1680 fprintf(stderr," %s\n",yyyAttrbStr(i,j,k));
1681 if (j == 0) fputs("->\n",stderr);
1690 void yyyCheckNodeInstancesSolved(yyyGNT *np)
1691 {int mysort,sortSize,i,prodNum,symPos,inTerminalNode;
1692 int nUnsolvedInsts = 0;
1694 if (np->prodNum != 0)
1695 {inTerminalNode = 0;
1696 prodNum = np->prodNum;
1700 {inTerminalNode = 1;
1701 prodNum = np->parent.noderef->prodNum;
1702 symPos = np->whichSym;
1704 mysort = yyySortOf(prodNum,symPos);
1705 sortSize = yyySizeofSort(mysort);
1706 for (i=0; i<sortSize; i++)
1707 if ((np->refCountList)[i] != 0) nUnsolvedInsts += 1;
1710 "\nFound node that has %d unsolved attribute instance(s).\n",
1713 fprintf(stderr,"Node is labeled \"%s\".\n",
1714 yyyGSoccurStr(prodNum,symPos));
1716 {fputs("Node is terminal. Its parent production is:\n ",stderr);
1717 yyyShowProd(prodNum);
1720 {fputs("Node is nonterminal. ",stderr);
1721 if (!(np->parentIsStack))
1723 "Node is %dth child in its parent production:\n ",
1726 yyyShowProd(np->parent.noderef->prodNum);
1728 fputs("Node is on left hand side of this production:\n ",stderr);
1729 yyyShowProd(np->prodNum);
1731 fputs("The following instances are unsolved:\n",stderr);
1732 for (i=0; i<sortSize; i++)
1733 if ((np->refCountList)[i] != 0)
1734 fprintf(stderr," %-16s still has %1d dependencies.\n",
1735 yyyAttrbStr(prodNum,symPos,i),(np->refCountList)[i]);
1741 void yyyCheckUnsolvedInstTrav(yyyGNT *pNode,long *nNZrc,long *cycleSum)
1742 {yyyGNT **yyyCLpdum;
1746 /* visit the refCountList of each node in the tree, and sum the non-zero refCounts */
1747 rcp = pNode->refCountList;
1748 i = pNode->refCountListLen;
1750 if (*rcp++) {*cycleSum += *(rcp - 1); (*nNZrc)++;}
1751 yyyCLpdum = pNode->cL;
1755 yyyCheckUnsolvedInstTrav(*yyyCLpdum,nNZrc,cycleSum);
1762 void yyyUnsolvedInstSearchTravAux(yyyGNT *pNode)
1763 {yyyGNT **yyyCLpdum;
1766 yyyCheckNodeInstancesSolved(pNode);
1767 yyyCLpdum = pNode->cL;
1771 yyyUnsolvedInstSearchTravAux(*yyyCLpdum);
1778 void yyyUnsolvedInstSearchTrav(yyyGNT *pNode)
1779 {yyyGNT **yyyCLpdum;
1782 yyyCLpdum = pNode->cL;
1786 yyyUnsolvedInstSearchTravAux(*yyyCLpdum);
1793 #line 1794 "expr.oxout.tab.c"
1795 /* For use in generated program */
1796 #define yydepth (int)(yystack.s_mark - yystack.s_base)
1798 #define yytrial (yyps->save)
1799 #endif /* YYBTYACC */
1802 #include <stdio.h> /* needed for printf */
1805 #include <stdlib.h> /* needed for malloc, etc */
1806 #include <string.h> /* needed for memset */
1808 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
1809 static int yygrowstack(YYSTACKDATA *data)
1815 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1819 if ((newsize = data->stacksize) == 0)
1820 newsize = YYINITSTACKSIZE;
1821 else if (newsize >= YYMAXDEPTH)
1823 else if ((newsize *= 2) > YYMAXDEPTH)
1824 newsize = YYMAXDEPTH;
1826 i = (int) (data->s_mark - data->s_base);
1827 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
1831 data->s_base = newss;
1832 data->s_mark = newss + i;
1834 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
1838 data->l_base = newvs;
1839 data->l_mark = newvs + i;
1841 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1842 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
1846 data->p_base = newps;
1847 data->p_mark = newps + i;
1850 data->stacksize = newsize;
1851 data->s_last = data->s_base + newsize - 1;
1855 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
1860 #if YYPURE || defined(YY_NO_LEAKS)
1861 static void yyfreestack(YYSTACKDATA *data)
1865 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1868 memset(data, 0, sizeof(*data));
1871 #define yyfreestack(data) /* nothing */
1872 #endif /* YYPURE || defined(YY_NO_LEAKS) */
1875 static YYParseState *
1876 yyNewState(unsigned size)
1878 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
1879 if (p == NULL) return NULL;
1881 p->yystack.stacksize = size;
1884 p->yystack.s_base = NULL;
1885 p->yystack.l_base = NULL;
1886 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1887 p->yystack.p_base = NULL;
1891 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT));
1892 if (p->yystack.s_base == NULL) return NULL;
1893 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
1894 if (p->yystack.l_base == NULL) return NULL;
1895 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
1896 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1897 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
1898 if (p->yystack.p_base == NULL) return NULL;
1899 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
1906 yyFreeState(YYParseState *p)
1908 yyfreestack(&p->yystack);
1911 #endif /* YYBTYACC */
1913 #define YYABORT goto yyabort
1914 #define YYREJECT goto yyabort
1915 #define YYACCEPT goto yyaccept
1916 #define YYERROR goto yyerrlab
1918 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
1919 #define YYVALID_NESTED do { if (yyps->save && \
1920 yyps->save->save == 0) goto yyvalid; } while(0)
1921 #endif /* YYBTYACC */
1926 int yym, yyn, yystate, yyresult;
1929 YYParseState *yyerrctx = NULL;
1930 #endif /* YYBTYACC */
1931 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1932 YYLTYPE yyerror_loc_range[2]; /* position of error start & end */
1937 if ((yys = getenv("YYDEBUG")) != 0)
1940 if (yyn >= '0' && yyn <= '9')
1941 yydebug = yyn - '0';
1944 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
1946 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1947 memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range));
1951 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
1953 #endif /* YYBTYACC */
1962 memset(&yystack, 0, sizeof(yystack));
1965 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1966 yystack.s_mark = yystack.s_base;
1967 yystack.l_mark = yystack.l_base;
1968 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1969 yystack.p_mark = yystack.p_base;
1972 *yystack.s_mark = 0;
1975 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
1982 /* we're currently re-reading tokens */
1984 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1992 /* in trial mode; save scanner results for future parse attempts */
1993 if (yylvp == yylvlim)
1994 { /* Enlarge lexical value queue */
1995 size_t p = (size_t) (yylvp - yylvals);
1996 size_t s = (size_t) (yylvlim - yylvals);
1998 s += YYLVQUEUEGROWTH;
1999 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
2000 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
2001 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2002 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
2004 yylvp = yylve = yylvals + p;
2005 yylvlim = yylvals + s;
2006 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2007 yylpp = yylpe = yylpsns + p;
2008 yylplim = yylpsns + s;
2010 yylexp = yylexemes + p;
2012 *yylexp = (YYINT) YYLEX;
2015 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2022 /* normal operation, no conflict encountered */
2023 #endif /* YYBTYACC */
2027 #endif /* YYBTYACC */
2028 if (yychar < 0) yychar = YYEOF;
2032 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
2033 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
2034 YYDEBUGSTR, yydepth, yystate, yychar, yys);
2035 #ifdef YYSTYPE_TOSTRING
2038 #endif /* YYBTYACC */
2039 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
2041 fputc('\n', stderr);
2047 /* Do we have a conflict? */
2048 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
2049 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
2058 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
2059 YYDEBUGSTR, yydepth, yystate);
2061 /* Switch to the next conflict context */
2063 yypath = save->save;
2066 if (save->state != yystate) YYABORT;
2073 /* Unresolved conflict - start/continue trial parse */
2078 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
2080 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
2082 fputs("Starting trial parse.\n", stderr);
2085 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
2086 if (save == NULL) goto yyenomem;
2087 save->save = yyps->save;
2088 save->state = yystate;
2089 save->errflag = yyerrflag;
2090 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
2091 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
2092 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
2093 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
2094 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2095 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
2096 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
2098 ctry = yytable[yyn];
2099 if (yyctable[ctry] == -1)
2102 if (yydebug && yychar >= YYEOF)
2103 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
2108 if (yyps->save == NULL)
2110 /* If this is a first conflict in the stack, start saving lexemes */
2113 yylexemes = malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
2114 if (yylexemes == NULL) goto yyenomem;
2115 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
2116 if (yylvals == NULL) goto yyenomem;
2117 yylvlim = yylvals + YYLVQUEUEGROWTH;
2118 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2119 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
2120 if (yylpsns == NULL) goto yyenomem;
2121 yylplim = yylpsns + YYLVQUEUEGROWTH;
2126 yylvp = yylve = yylvals;
2127 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2128 yylpp = yylpe = yylpsns;
2131 if (yychar >= YYEOF)
2134 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2137 *yylexp = (YYINT) yychar;
2142 if (yychar >= YYEOF)
2145 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2151 save->lexeme = (int) (yylvp - yylvals);
2154 if (yytable[yyn] == ctry)
2158 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
2159 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
2164 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2169 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
2171 yystate = yyctable[ctry];
2172 *++yystack.s_mark = (YYINT) yystate;
2173 *++yystack.l_mark = yylval;
2174 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2175 *++yystack.p_mark = yylloc;
2178 if (yyerrflag > 0) --yyerrflag;
2183 yyn = yyctable[ctry];
2186 } /* End of code dealing with conflicts */
2187 #endif /* YYBTYACC */
2188 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
2189 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
2193 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
2194 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
2196 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
2197 yystate = yytable[yyn];
2198 *++yystack.s_mark = yytable[yyn];
2199 *++yystack.l_mark = yylval;
2200 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2201 *++yystack.p_mark = yylloc;
2204 if (yyerrflag > 0) --yyerrflag;
2207 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
2208 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
2213 if (yyerrflag != 0) goto yyinrecovery;
2218 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
2221 /* explicit YYERROR from an action -- pop the rhs of the rule reduced
2222 * before looking for error recovery */
2223 yystack.s_mark -= yym;
2224 yystate = *yystack.s_mark;
2225 yystack.l_mark -= yym;
2226 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2227 yystack.p_mark -= yym;
2235 YYParseState *save = yyps->save;
2238 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
2239 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
2240 (int)(yylvp - yylvals - yyps->save->lexeme));
2242 /* Memorize most forward-looking error state in case it's really an error. */
2243 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
2245 /* Free old saved error context state */
2246 if (yyerrctx) yyFreeState(yyerrctx);
2247 /* Create and fill out new saved error context state */
2248 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
2249 if (yyerrctx == NULL) goto yyenomem;
2250 yyerrctx->save = yyps->save;
2251 yyerrctx->state = yystate;
2252 yyerrctx->errflag = yyerrflag;
2253 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
2254 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
2255 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
2256 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
2257 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2258 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
2259 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
2261 yyerrctx->lexeme = (int) (yylvp - yylvals);
2263 yylvp = yylvals + save->lexeme;
2264 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2265 yylpp = yylpsns + save->lexeme;
2267 yylexp = yylexemes + save->lexeme;
2269 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
2270 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
2271 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
2272 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
2273 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2274 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
2275 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
2277 ctry = ++save->ctry;
2278 yystate = save->state;
2279 /* We tried shift, try reduce now */
2280 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
2281 yyps->save = save->save;
2285 /* Nothing left on the stack -- error */
2290 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
2293 /* Restore state as it was in the most forward-advanced error */
2294 yylvp = yylvals + yyerrctx->lexeme;
2295 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2296 yylpp = yylpsns + yyerrctx->lexeme;
2298 yylexp = yylexemes + yyerrctx->lexeme;
2299 yychar = yylexp[-1];
2301 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2304 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
2305 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
2306 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
2307 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
2308 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2309 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
2310 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
2312 yystate = yyerrctx->state;
2313 yyFreeState(yyerrctx);
2318 if (yynewerrflag == 0) goto yyinrecovery;
2319 #endif /* YYBTYACC */
2321 YYERROR_CALL("syntax error");
2322 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2323 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
2327 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
2338 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
2339 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
2343 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
2344 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
2346 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
2347 yystate = yytable[yyn];
2348 *++yystack.s_mark = yytable[yyn];
2349 *++yystack.l_mark = yylval;
2350 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2351 /* lookahead position is error end position */
2352 yyerror_loc_range[1] = yylloc;
2353 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
2354 *++yystack.p_mark = yyloc;
2362 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
2363 YYDEBUGSTR, yydepth, *yystack.s_mark);
2365 if (yystack.s_mark <= yystack.s_base) goto yyabort;
2366 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2367 /* the current TOS position is the error start position */
2368 yyerror_loc_range[0] = *yystack.p_mark;
2370 #if defined(YYDESTRUCT_CALL)
2373 #endif /* YYBTYACC */
2374 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2375 YYDESTRUCT_CALL("error: discarding state",
2376 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
2378 YYDESTRUCT_CALL("error: discarding state",
2379 yystos[*yystack.s_mark], yystack.l_mark);
2380 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
2381 #endif /* defined(YYDESTRUCT_CALL) */
2384 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2392 if (yychar == YYEOF) goto yyabort;
2396 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
2397 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
2398 YYDEBUGSTR, yydepth, yystate, yychar, yys);
2401 #if defined(YYDESTRUCT_CALL)
2404 #endif /* YYBTYACC */
2405 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2406 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
2408 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
2409 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
2410 #endif /* defined(YYDESTRUCT_CALL) */
2420 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
2421 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
2422 #ifdef YYSTYPE_TOSTRING
2425 #endif /* YYBTYACC */
2430 for (i = yym; i > 0; i--)
2432 if (i != yym) fputs(", ", stderr);
2433 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
2434 yystack.l_mark[1-i]), stderr);
2439 fputc('\n', stderr);
2443 yyval = yystack.l_mark[1-yym];
2445 memset(&yyval, 0, sizeof yyval);
2446 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2448 /* Perform position reduction */
2449 memset(&yyloc, 0, sizeof(yyloc));
2452 #endif /* YYBTYACC */
2454 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
2455 /* just in case YYERROR is invoked within the action, save
2456 the start of the rhs as the error start position */
2457 yyerror_loc_range[0] = yystack.p_mark[1-yym];
2464 #line 64 "expr.oxout.y"
2468 #line 66 "expr.oxout.y"
2470 yyyDecorate(); yyyExecuteRRsection(yystack.l_mark[0].yyyOxAttrbs.yyyOxStackItem->node);
2474 #line 73 "expr.oxout.y"
2476 yyyGenIntNode(1,1,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
2477 yyyAdjustINRC(1,1,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
2480 #line 80 "expr.oxout.y"
2482 yyyGenIntNode(2,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
2483 yyyAdjustINRC(2,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
2486 #line 87 "expr.oxout.y"
2488 yyyGenIntNode(3,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
2489 yyyAdjustINRC(3,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
2492 #line 94 "expr.oxout.y"
2494 yyyGenIntNode(4,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
2495 yyyAdjustINRC(4,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
2498 #line 101 "expr.oxout.y"
2500 yyyGenIntNode(5,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
2501 yyyAdjustINRC(5,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
2504 #line 108 "expr.oxout.y"
2506 yyyGenIntNode(6,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
2507 yyyAdjustINRC(6,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
2510 #line 114 "expr.oxout.y"
2512 yyyGenIntNode(7,1,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
2513 yyyAdjustINRC(7,1,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
2516 #line 121 "expr.oxout.y"
2518 yyyGenIntNode(8,1,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
2519 yyyAdjustINRC(8,1,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
2521 #line 2522 "expr.oxout.tab.c"
2525 yystack.s_mark -= yym;
2526 yystate = *yystack.s_mark;
2527 yystack.l_mark -= yym;
2528 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2529 yystack.p_mark -= yym;
2532 if (yystate == 0 && yym == 0)
2537 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
2538 #ifdef YYSTYPE_TOSTRING
2541 #endif /* YYBTYACC */
2542 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
2544 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
2548 *++yystack.s_mark = YYFINAL;
2549 *++yystack.l_mark = yyval;
2550 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2551 *++yystack.p_mark = yyloc;
2559 /* we're currently re-reading tokens */
2561 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2569 /* in trial mode; save scanner results for future parse attempts */
2570 if (yylvp == yylvlim)
2571 { /* Enlarge lexical value queue */
2572 size_t p = (size_t) (yylvp - yylvals);
2573 size_t s = (size_t) (yylvlim - yylvals);
2575 s += YYLVQUEUEGROWTH;
2576 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL)
2578 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
2580 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2581 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
2584 yylvp = yylve = yylvals + p;
2585 yylvlim = yylvals + s;
2586 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2587 yylpp = yylpe = yylpsns + p;
2588 yylplim = yylpsns + s;
2590 yylexp = yylexemes + p;
2592 *yylexp = (YYINT) YYLEX;
2595 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2602 /* normal operation, no conflict encountered */
2603 #endif /* YYBTYACC */
2607 #endif /* YYBTYACC */
2608 if (yychar < 0) yychar = YYEOF;
2612 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
2613 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
2614 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
2618 if (yychar == YYEOF) goto yyaccept;
2621 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
2622 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
2623 yystate = yytable[yyn];
2625 yystate = yydgoto[yym];
2629 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
2630 #ifdef YYSTYPE_TOSTRING
2633 #endif /* YYBTYACC */
2634 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
2636 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
2639 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
2640 *++yystack.s_mark = (YYINT) yystate;
2641 *++yystack.l_mark = yyval;
2642 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2643 *++yystack.p_mark = yyloc;
2648 /* Reduction declares that this path is valid. Set yypath and do a full parse */
2650 if (yypath) YYABORT;
2653 YYParseState *save = yyps->save;
2654 yyps->save = save->save;
2655 save->save = yypath;
2660 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
2661 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
2665 yyFreeState(yyerrctx);
2668 yylvp = yylvals + yypath->lexeme;
2669 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2670 yylpp = yylpsns + yypath->lexeme;
2672 yylexp = yylexemes + yypath->lexeme;
2674 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
2675 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
2676 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
2677 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
2678 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2679 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
2680 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
2682 yystate = yypath->state;
2684 #endif /* YYBTYACC */
2687 YYERROR_CALL("yacc stack overflow");
2691 YYERROR_CALL("memory exhausted");
2693 #endif /* YYBTYACC */
2703 if (yyps->save) goto yyvalid;
2704 #endif /* YYBTYACC */
2708 #if defined(YYDESTRUCT_CALL)
2709 if (yychar != YYEOF && yychar != YYEMPTY)
2710 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2711 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
2713 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
2714 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
2718 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2721 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
2722 YYDESTRUCT_CALL("cleanup: discarding state",
2723 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
2725 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
2726 YYDESTRUCT_CALL("cleanup: discarding state",
2727 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
2728 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
2730 #endif /* defined(YYDESTRUCT_CALL) */
2735 yyFreeState(yyerrctx);
2740 YYParseState *save = yyps;
2747 YYParseState *save = yypath;
2748 yypath = save->save;
2752 #endif /* YYBTYACC */
2753 yyfreestack(&yystack);