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 ')'",
358 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
359 YYLTYPE yyloc; /* position returned by actions */
360 YYLTYPE yylloc; /* position from the lexer */
363 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
364 #ifndef YYLLOC_DEFAULT
365 #define YYLLOC_DEFAULT(loc, rhs, n) \
370 (loc).first_line = YYRHSLOC(rhs, 0).last_line; \
371 (loc).first_column = YYRHSLOC(rhs, 0).last_column; \
372 (loc).last_line = YYRHSLOC(rhs, 0).last_line; \
373 (loc).last_column = YYRHSLOC(rhs, 0).last_column; \
377 (loc).first_line = YYRHSLOC(rhs, 1).first_line; \
378 (loc).first_column = YYRHSLOC(rhs, 1).first_column; \
379 (loc).last_line = YYRHSLOC(rhs, n).last_line; \
380 (loc).last_column = YYRHSLOC(rhs, n).last_column; \
383 #endif /* YYLLOC_DEFAULT */
384 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
387 #ifndef YYLVQUEUEGROWTH
388 #define YYLVQUEUEGROWTH 32
390 #endif /* YYBTYACC */
392 /* define the initial stack-sizes */
395 #define YYMAXDEPTH YYSTACKSIZE
398 #define YYSTACKSIZE YYMAXDEPTH
400 #define YYSTACKSIZE 10000
401 #define YYMAXDEPTH 10000
405 #ifndef YYINITSTACKSIZE
406 #define YYINITSTACKSIZE 200
416 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
423 struct YYParseState_s
425 struct YYParseState_s *save; /* Previously saved parser state */
426 YYSTACKDATA yystack; /* saved parser stack */
427 int state; /* saved parser state */
428 int errflag; /* saved error recovery status */
429 int lexeme; /* saved index of the conflict lexeme in the lexical queue */
430 YYINT ctry; /* saved index in yyctable[] for this conflict */
432 typedef struct YYParseState_s YYParseState;
433 #endif /* YYBTYACC */
434 /* variables for the parser stack */
435 static YYSTACKDATA yystack;
438 /* Current parser state */
439 static YYParseState *yyps = 0;
441 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
442 static YYParseState *yypath = 0;
444 /* Base of the lexical value queue */
445 static YYSTYPE *yylvals = 0;
447 /* Current position at lexical value queue */
448 static YYSTYPE *yylvp = 0;
450 /* End position of lexical value queue */
451 static YYSTYPE *yylve = 0;
453 /* The last allocated position at the lexical value queue */
454 static YYSTYPE *yylvlim = 0;
456 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
457 /* Base of the lexical position queue */
458 static YYLTYPE *yylpsns = 0;
460 /* Current position at lexical position queue */
461 static YYLTYPE *yylpp = 0;
463 /* End position of lexical position queue */
464 static YYLTYPE *yylpe = 0;
466 /* The last allocated position at the lexical position queue */
467 static YYLTYPE *yylplim = 0;
470 /* Current position at lexical token queue */
471 static YYINT *yylexp = 0;
473 static YYINT *yylexemes = 0;
474 #endif /* YYBTYACC */
486 #line 138 "expr.oxout.y"
487 long yyySSALspaceSize = 20000;
488 long yyyRSmaxSize = 1000;
489 long yyyTravStackMaxSize = 2000;
491 struct yyySolvedSAlistCell {yyyWAT attrbNum;
495 #define yyyLambdaSSAL 0
496 long yyySSALCfreeList = yyyLambdaSSAL;
497 long yyyNewSSALC = 1;
499 struct yyySolvedSAlistCell *yyySSALspace;
501 long yyyNbytesStackStg;
507 short yyyIIIEL[] = {0,
508 0,2,6,10,14,18,22,24,
512 0,0,0,0,0,0,0,0,0,0,0,0,
513 0,0,0,0,0,0,0,0,0,0,0,0,
523 void yyyfatal(char *msg)
524 {fputs(msg,stderr);exit(-1);}
528 #define yyySSALof 'S'
534 void yyyHandleOverflow(char which)
536 long oldSize,newSize;
540 msg1 = "SSAL overflow: ";
541 oldSize = yyySSALspaceSize;
544 msg1 = "ready set overflow: ";
545 oldSize = yyyRSmaxSize;
548 msg1 = "traversal stack overflow: ";
549 oldSize = yyyTravStackMaxSize;
553 newSize = (3*oldSize)/2;
554 if (newSize < 100) newSize = 100;
556 fprintf(stderr,"size was %ld.\n",oldSize);
557 msg2 = " Have to modify evaluator: -Y%c%ld.\n";
558 fprintf(stderr,msg2,which,newSize);
564 void yyySignalEnts(yyyGNT *node,long startP,long stopP)
567 while (startP < stopP)
569 if (!yyyEntL[startP]) dumNode = node;
570 else dumNode = (node->cL)[yyyEntL[startP]-1];
571 if (!(--((dumNode->refCountList)[yyyEntL[startP+1]]
576 if (++yyyRSTop == yyyAfterRS)
577 {yyyHandleOverflow(yyyRSof);
580 yyyRSTop->node = dumNode;
581 yyyRSTop->whichSym = yyyEntL[startP];
582 yyyRSTop->wa = yyyEntL[startP+1];
593 void yyySolveAndSignal() {
596 yyyGNT *yyyRSTopN,*yyyRefN;
597 yyyParent yyyRSTopNp;
600 yyyRSTopNp = (yyyRSTopN = yyyRSTop->node)->parent;
601 yyyRefN= (yyyws = (yyyRSTop->whichSym))?yyyRSTopNp.noderef:yyyRSTopN;
602 yyywa = yyyRSTop->wa;
604 switch(yyyRefN->prodNum) {
605 case 1: /***yacc rule 1***/
609 case 2: /***yacc rule 2***/
613 case 3: /***yacc rule 3***/
617 case 4: /***yacc rule 4***/
621 case 5: /***yacc rule 5***/
625 case 6: /***yacc rule 6***/
629 case 7: /***yacc rule 7***/
637 case 8: /***yacc rule 8***/
647 if (yyyws) /* the just-solved instance was inherited. */
648 {if (yyyRSTopN->prodNum)
649 {yyyiDum = yyyIIEL[yyyIIIEL[yyyRSTopN->prodNum]] + yyywa;
650 yyySignalEnts(yyyRSTopN,yyyIEL[yyyiDum],
655 else /* the just-solved instance was synthesized. */
656 {if (!(yyyRSTopN->parentIsStack)) /* node has a parent. */
657 {yyyiDum = yyyIIEL[yyyIIIEL[yyyRSTopNp.noderef->prodNum] +
661 yyySignalEnts(yyyRSTopNp.noderef,
666 else /* node is still on the stack--it has no parent yet. */
667 {yyypL = &(yyyRSTopNp.stackref->solvedSAlist);
668 if (yyySSALCfreeList == yyyLambdaSSAL)
669 {yyySSALspace[yyyNewSSALC].next = *yyypL;
670 if ((*yyypL = yyyNewSSALC++) == yyySSALspaceSize)
671 yyyHandleOverflow(yyySSALof);
674 {yyyiDum = yyySSALCfreeList;
675 yyySSALCfreeList = yyySSALspace[yyySSALCfreeList].next;
676 yyySSALspace[yyyiDum].next = *yyypL;
679 yyySSALspace[*yyypL].attrbNum = yyywa;
683 } /* yyySolveAndSignal */
690 #define condStg unsigned int conds;
691 #define yyyClearConds {yyyTST->conds = 0;}
692 #define yyySetCond(n) {yyyTST->conds += (1<<(n));}
693 #define yyyCond(n) ((yyyTST->conds & (1<<(n)))?1:0)
697 struct yyyTravStackItem {yyyGNT *node;
704 void yyyDoTraversals(yyyGNT *rootNode)
705 {struct yyyTravStackItem *yyyTravStack,*yyyTST,*yyyAfterTravStack;
706 yyyGNT *yyyTSTn,**yyyCLptr2;
707 int yyyi,yyyRL,yyyPass;
712 ((struct yyyTravStackItem *)
713 calloc((size_t)yyyTravStackMaxSize,
714 (size_t)sizeof(struct yyyTravStackItem)
719 (struct yyyTravStackItem *)NULL
721 {fputs("malloc error in traversal stack allocation\n",stderr);
725 yyyAfterTravStack = yyyTravStack + yyyTravStackMaxSize;
729 for (yyyi=0; yyyi<2; yyyi++) {
730 yyyTST = yyyTravStack;
731 yyyTST->node = rootNode;
735 while(yyyTST >= yyyTravStack)
736 {yyyTSTn = yyyTST->node;
748 if (yyyTSTn->prodNum)
750 {yyyCLptr2 = yyyTSTn->cL;
753 {if (++yyyTST == yyyAfterTravStack)
754 yyyHandleOverflow(yyyTSof);
756 {yyyTST->node = *yyyCLptr2;
762 } /* right to left */
763 else /* left to right */
765 yyyCLptr2 = yyyTSTn->cL + i;
768 if (++yyyTST == yyyAfterTravStack)
769 yyyHandleOverflow(yyyTSof);
771 {yyyTST->node = *yyyCLptr2;
776 } /* left to right */
781 switch(yyyTSTn->prodNum) {
787 yyyRL = 0;yyySetCond(0)
792 #line 444 "expr.oxout.y"
798 if (yyyCond(0) != yyyPass) {
801 #line 453 "expr.oxout.y"
803 if (yyyCond(1) != yyyPass) {
807 #line 459 "expr.oxout.y"
809 if (yyyCond(2) != yyyPass) {
813 #line 465 "expr.oxout.y"
825 #line 477 "expr.oxout.y"
830 if (yyyCond(0) != yyyPass) {
834 #line 486 "expr.oxout.y"
836 if (yyyCond(1) != yyyPass) {
839 #line 491 "expr.oxout.y"
841 if (yyyCond(2) != yyyPass) {
843 printf("postfix: ")/* missing ; */
845 #line 497 "expr.oxout.y"
858 yyyRL = 0;yyySetCond(0)
862 if (yyyCond(0) != yyyPass) {
866 #line 518 "expr.oxout.y"
877 if (yyyCond(0) != yyyPass) {
881 #line 533 "expr.oxout.y"
894 yyyRL = 0;yyySetCond(0)
898 if (yyyCond(0) != yyyPass) {
902 #line 554 "expr.oxout.y"
913 if (yyyCond(0) != yyyPass) {
917 #line 569 "expr.oxout.y"
930 yyyRL = 0;yyySetCond(0)
934 if (yyyCond(0) != yyyPass) {
938 #line 590 "expr.oxout.y"
949 if (yyyCond(0) != yyyPass) {
953 #line 605 "expr.oxout.y"
966 yyyRL = 0;yyySetCond(0)
970 if (yyyCond(0) != yyyPass) {
974 #line 626 "expr.oxout.y"
985 if (yyyCond(0) != yyyPass) {
989 #line 641 "expr.oxout.y"
1025 yyyRL = 0;yyySetCond(0)
1029 if (yyyCond(0) != yyyPass) {
1031 printf(" %s ",yyyTSTn->cL[0]->yyyAttrbs.yyyAttrb1.lexeme);
1033 #line 685 "expr.oxout.y"
1044 if (yyyCond(0) != yyyPass) {
1046 printf(" %s ",yyyTSTn->cL[0]->yyyAttrbs.yyyAttrb1.lexeme);
1048 #line 700 "expr.oxout.y"
1061 yyyRL = 0;yyySetCond(0)
1065 if (yyyCond(0) != yyyPass) {
1067 printf(" %s ",yyyTSTn->cL[0]->yyyAttrbs.yyyAttrb1.lexeme);
1069 #line 721 "expr.oxout.y"
1080 if (yyyCond(0) != yyyPass) {
1082 printf(" %s ",yyyTSTn->cL[0]->yyyAttrbs.yyyAttrb1.lexeme);
1084 #line 736 "expr.oxout.y"
1093 if (yyyPass) goto yyyTpop; else goto yyyTpush;
1096 } /* yyyDoTraversals */
1098 void yyyExecuteRRsection(yyyGNT *rootNode) {
1103 if (!yyyYok) return;
1104 yyyCheckUnsolvedInstTrav(rootNode,&nNZrc,&cycleSum);
1107 fputs("\n\n\n**********\n",stderr);
1108 fputs("cycle detected in completed parse tree",stderr);
1109 fputs(" after decoration.\n",stderr);
1112 "number of unsolved attribute instances == %ld.\n",
1116 "total number of remaining dependencies == %ld.\n",
1119 fputs("average number of remaining dependencies\n",stderr);
1120 fprintf(stderr," per unsolved instance == %f.\n",
1121 ((float)(cycleSum)/(float)(nNZrc))
1125 "searching parse tree for %ld unsolved instances:\n",
1128 yyyUnsolvedInstSearchTravAux(rootNode);
1130 yyyDoTraversals(rootNode);
1131 } /* yyyExecuteRRsection */
1135 yyyWAT yyyLRCIL[2] = {0,0,
1140 void yyyYoxInit(void)
1142 static int yyyInitDone = 0;
1143 if (yyyInitDone) return;
1145 if ((yyyRS = (struct yyyRSitem *)
1146 calloc((size_t)(yyyRSmaxSize+1), (size_t)sizeof(struct yyyRSitem))
1149 ((struct yyyRSitem *) NULL)
1151 yyyfatal("malloc error in ox ready set space allocation\n");
1153 yyyAfterRS = yyyRS + yyyRSmaxSize;
1156 if ((yyySSALspace = (struct yyySolvedSAlistCell *)
1157 calloc((size_t)(yyySSALspaceSize+1), (size_t)sizeof(struct yyySolvedSAlistCell))
1160 ((struct yyySolvedSAlistCell *) NULL)
1162 yyyfatal("malloc error in stack solved list space allocation\n");
1165 yyyRSTop = yyyRS - 1;
1170 void yyyDecorate(void)
1172 while (yyyRSTop >= yyyRS)
1173 yyySolveAndSignal();
1178 void yyyGenIntNode(long yyyProdNum, int yyyRHSlength, int yyyNattrbs, struct yyyOxAttrbs *yyval_OxAttrbs, ...)
1180 yyySIT **yyyOxStackItem = &yyval_OxAttrbs->yyyOxStackItem;
1184 *yyyOxStackItem = (yyySIT *) malloc((size_t)sizeof(yyySIT));
1185 if (*yyyOxStackItem == (yyySIT *) NULL)
1186 yyyfatal("malloc error in ox yacc semantic stack space allocation\n");
1187 (*yyyOxStackItem)->node =
1188 (yyyGNT *) malloc((size_t)sizeof(yyyGNT));
1189 if ((*yyyOxStackItem)->node == (yyyGNT *) NULL)
1190 yyyfatal("malloc error in ox node space allocation\n");
1191 (*yyyOxStackItem)->solvedSAlist = yyyLambdaSSAL;
1192 (*yyyOxStackItem)->node->parent.stackref = *yyyOxStackItem;
1193 (*yyyOxStackItem)->node->parentIsStack = 1;
1194 (*yyyOxStackItem)->node->cLlen = yyyRHSlength;
1195 (*yyyOxStackItem)->node->cL =
1196 (yyyGNT **) calloc((size_t)yyyRHSlength, (size_t)sizeof(yyyGNT *));
1197 if ((*yyyOxStackItem)->node->cL == (yyyGNT **) NULL)
1198 yyyfatal("malloc error in ox child list space allocation\n");
1199 (*yyyOxStackItem)->node->refCountListLen = yyyNattrbs;
1200 (*yyyOxStackItem)->node->refCountList =
1201 (yyyRCT *) calloc((size_t)yyyNattrbs, (size_t)sizeof(yyyRCT));
1202 if ((*yyyOxStackItem)->node->refCountList == (yyyRCT *) NULL)
1203 yyyfatal("malloc error in ox reference count list space allocation\n");
1204 (*yyyOxStackItem)->node->prodNum = yyyProdNum;
1205 va_start(ap, yyval_OxAttrbs);
1206 for (i=1;i<=yyyRHSlength;i++)
1207 {yyySIT *yaccStDum = va_arg(ap,struct yyyOxAttrbs *)->yyyOxStackItem;
1208 gnpDum = (*yyyOxStackItem)->node->cL[i-1] = yaccStDum->node;
1209 gnpDum->whichSym = i;
1210 gnpDum->parent.noderef = (*yyyOxStackItem)->node;
1211 gnpDum->parentIsStack = 0;
1218 #define yyyDECORfREQ 50
1222 void yyyAdjustINRC(long yyyProdNum, int yyyRHSlength, long startP, long stopP, struct yyyOxAttrbs *yyval_OxAttrbs, ...)
1224 yyySIT *yyyOxStackItem = yyval_OxAttrbs->yyyOxStackItem;
1225 long SSALptr,SSALptrHead,*cPtrPtr;
1230 static unsigned short intNodeCount = yyyDECORfREQ;
1234 while (nextP < stopP)
1235 {if (yyyRCIL[nextP] == yyyR)
1236 {(yyyOxStackItem->node->refCountList)[yyyRCIL[nextP+1]] = yyyRCIL[nextP+2];
1239 {(((yyyOxStackItem->node->cL)[yyyRCIL[nextP]])->refCountList)[yyyRCIL[nextP+1]] = yyyRCIL[nextP+2];
1243 pL = yyyIIEL + yyyIIIEL[yyyProdNum];
1244 va_start(ap, yyval_OxAttrbs);
1245 for (i=1;i<=yyyRHSlength;i++)
1246 {yyySIT *yaccStDum = va_arg(ap,struct yyyOxAttrbs *)->yyyOxStackItem;
1248 SSALptrHead = SSALptr = *(cPtrPtr = &(yaccStDum->solvedSAlist));
1249 if (SSALptr != yyyLambdaSSAL)
1250 {*cPtrPtr = yyyLambdaSSAL;
1253 iTemp = (*pL+yyySSALspace[SSALptr].attrbNum);
1254 yyySignalEnts(yyyOxStackItem->node,
1258 SSALptr = *(cPtrPtr = &(yyySSALspace[SSALptr].next));
1260 while (SSALptr != yyyLambdaSSAL);
1261 *cPtrPtr = yyySSALCfreeList;
1262 yyySSALCfreeList = SSALptrHead;
1267 while (nextP < stopP)
1268 {if (!yyyRCIL[nextP])
1269 {if (yyyRCIL[nextP-2] == yyyR)
1270 {pL = &(yyyOxStackItem->solvedSAlist);
1271 if (yyySSALCfreeList == yyyLambdaSSAL)
1272 {yyySSALspace[yyyNewSSALC].next = *pL;
1273 if ((*pL = yyyNewSSALC++) == yyySSALspaceSize)
1274 yyyHandleOverflow(yyySSALof);
1277 {iTemp = yyySSALCfreeList;
1278 yyySSALCfreeList = yyySSALspace[yyySSALCfreeList].next;
1279 yyySSALspace[iTemp].next = *pL;
1282 yyySSALspace[*pL].attrbNum = yyyRCIL[nextP-1];
1285 {if ((gnpDum = (yyyOxStackItem->node->cL)[yyyRCIL[nextP-2]])->prodNum != 0)
1287 iTemp = yyyIIEL[yyyIIIEL[gnpDum->prodNum]] + yyyRCIL[nextP-1];
1288 yyySignalEnts(gnpDum,
1297 if (!--intNodeCount)
1298 {intNodeCount = yyyDECORfREQ;
1305 void yyyGenLeaf(int nAttrbs,int typeNum,long startP,long stopP,YYSTYPE *yylval)
1307 yyySIT **yyyOxStackItem = &yylval->yyyOxAttrbs.yyyOxStackItem;
1308 (*yyyOxStackItem) = (yyySIT *) malloc((size_t)sizeof(yyySIT));
1309 if ((*yyyOxStackItem) == (yyySIT *) NULL)
1310 yyyfatal("malloc error in ox yacc semantic stack space allocation\n");
1311 (*yyyOxStackItem)->node =
1312 (yyyGNT *) malloc((size_t)sizeof(yyyGNT))
1314 if ((*yyyOxStackItem)->node == (yyyGNT *) NULL)
1315 yyyfatal("malloc error in ox node space allocation\n");
1316 (*yyyOxStackItem)->solvedSAlist = yyyLambdaSSAL;
1317 (*yyyOxStackItem)->node->parent.stackref = *yyyOxStackItem;
1318 (*yyyOxStackItem)->node->parentIsStack = 1;
1319 (*yyyOxStackItem)->node->cLlen = 0;
1320 (*yyyOxStackItem)->node->cL = (yyyGNT **)NULL;
1321 (*yyyOxStackItem)->node->refCountListLen = nAttrbs;
1322 rcPdum = (*yyyOxStackItem)->node->refCountList =
1323 (yyyRCT *) calloc((size_t)nAttrbs, (size_t)sizeof(yyyRCT));
1324 if (rcPdum == (yyyRCT *) NULL)
1325 yyyfatal("malloc error in ox reference count list space allocation\n");
1326 while (startP < stopP) rcPdum[yyyLRCIL[startP++]] = 0;
1327 (*yyyOxStackItem)->node->prodNum = 0;
1328 (*yyyOxStackItem)->node->whichSym = 0;
1341 #define yyyLastProdNum 8
1347 int yyyProdsInd[] = {
1349 0, 2, 6, 10, 14, 18, 22, 24,
1354 int yyyProds[][2] = {
1355 { 116, 0},{ 462, 0},{ 462, 0},{ 462, 0},{ 412, 0},
1356 { 462, 0},{ 462, 0},{ 462, 0},{ 420, 0},{ 462, 0},
1357 { 462, 0},{ 462, 0},{ 452, 0},{ 462, 0},{ 462, 0},
1358 { 462, 0},{ 436, 0},{ 462, 0},{ 462, 0},{ 396, 0},
1359 { 462, 0},{ 404, 0},{ 462, 0},{ 619, 1},{ 462, 0},
1364 int yyySortsInd[] = {
1377 char *yyyStringTab[] = {
1460 0,0,"'*'","lexeme",0,
1491 0,0,"CONST","LRpost",0,
1629 #define yyySizeofProd(num) (yyyProdsInd[(num)+1] - yyyProdsInd[(num)])
1631 #define yyyGSoccurStr(prodNum,symPos) \
1632 (yyyStringTab[yyyProds[yyyProdsInd[(prodNum)] + (symPos)][0]])
1634 #define yyySizeofSort(num) (yyySortsInd[(num)+1] - yyySortsInd[(num)])
1636 #define yyySortOf(prodNum,symPos) \
1637 (yyyProds[yyyProdsInd[(prodNum)] + (symPos)][1])
1639 #define yyyAttrbStr(prodNum,symPos,attrbNum) \
1640 (yyyStringTab[yyySorts[yyySortsInd[yyySortOf(prodNum,symPos)] + \
1648 void yyyShowProd(int i)
1651 nSyms = yyySizeofProd(i);
1652 for (j=0; j<nSyms; j++)
1654 fprintf(stderr,"%s",yyyGSoccurStr(i,j));
1655 if (j == 0) fputs(" : ",stderr); else putc(' ',stderr);
1657 fputs(";\n",stderr);
1663 {int i; for (i=1; i<=yyyLastProdNum; i++) yyyShowProd(i);}
1667 void yyyShowSymsAndSorts()
1670 for (i=1; i<=yyyLastProdNum; i++)
1674 "\n\n\n---------------------------------- %3.1d\n",i);
1675 /* yyyShowProd(i); */
1676 nSyms = yyySizeofProd(i);
1677 for (j=0; j<nSyms; j++)
1680 fprintf(stderr,"%s\n",yyyGSoccurStr(i,j));
1681 sortSize = yyySizeofSort(yyySortOf(i,j));
1682 for (k=0; k<sortSize; k++)
1683 fprintf(stderr," %s\n",yyyAttrbStr(i,j,k));
1684 if (j == 0) fputs("->\n",stderr);
1693 void yyyCheckNodeInstancesSolved(yyyGNT *np)
1694 {int mysort,sortSize,i,prodNum,symPos,inTerminalNode;
1695 int nUnsolvedInsts = 0;
1697 if (np->prodNum != 0)
1698 {inTerminalNode = 0;
1699 prodNum = np->prodNum;
1703 {inTerminalNode = 1;
1704 prodNum = np->parent.noderef->prodNum;
1705 symPos = np->whichSym;
1707 mysort = yyySortOf(prodNum,symPos);
1708 sortSize = yyySizeofSort(mysort);
1709 for (i=0; i<sortSize; i++)
1710 if ((np->refCountList)[i] != 0) nUnsolvedInsts += 1;
1713 "\nFound node that has %d unsolved attribute instance(s).\n",
1716 fprintf(stderr,"Node is labeled \"%s\".\n",
1717 yyyGSoccurStr(prodNum,symPos));
1719 {fputs("Node is terminal. Its parent production is:\n ",stderr);
1720 yyyShowProd(prodNum);
1723 {fputs("Node is nonterminal. ",stderr);
1724 if (!(np->parentIsStack))
1726 "Node is %dth child in its parent production:\n ",
1729 yyyShowProd(np->parent.noderef->prodNum);
1731 fputs("Node is on left hand side of this production:\n ",stderr);
1732 yyyShowProd(np->prodNum);
1734 fputs("The following instances are unsolved:\n",stderr);
1735 for (i=0; i<sortSize; i++)
1736 if ((np->refCountList)[i] != 0)
1737 fprintf(stderr," %-16s still has %1d dependencies.\n",
1738 yyyAttrbStr(prodNum,symPos,i),(np->refCountList)[i]);
1744 void yyyCheckUnsolvedInstTrav(yyyGNT *pNode,long *nNZrc,long *cycleSum)
1745 {yyyGNT **yyyCLpdum;
1749 /* visit the refCountList of each node in the tree, and sum the non-zero refCounts */
1750 rcp = pNode->refCountList;
1751 i = pNode->refCountListLen;
1753 if (*rcp++) {*cycleSum += *(rcp - 1); (*nNZrc)++;}
1754 yyyCLpdum = pNode->cL;
1758 yyyCheckUnsolvedInstTrav(*yyyCLpdum,nNZrc,cycleSum);
1765 void yyyUnsolvedInstSearchTravAux(yyyGNT *pNode)
1766 {yyyGNT **yyyCLpdum;
1769 yyyCheckNodeInstancesSolved(pNode);
1770 yyyCLpdum = pNode->cL;
1774 yyyUnsolvedInstSearchTravAux(*yyyCLpdum);
1781 void yyyUnsolvedInstSearchTrav(yyyGNT *pNode)
1782 {yyyGNT **yyyCLpdum;
1785 yyyCLpdum = pNode->cL;
1789 yyyUnsolvedInstSearchTravAux(*yyyCLpdum);
1796 #line 1797 "expr.oxout.tab.c"
1798 /* For use in generated program */
1799 #define yydepth (int)(yystack.s_mark - yystack.s_base)
1801 #define yytrial (yyps->save)
1802 #endif /* YYBTYACC */
1805 #include <stdio.h> /* needed for printf */
1808 #include <stdlib.h> /* needed for malloc, etc */
1809 #include <string.h> /* needed for memset */
1811 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
1812 static int yygrowstack(YYSTACKDATA *data)
1818 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1822 if ((newsize = data->stacksize) == 0)
1823 newsize = YYINITSTACKSIZE;
1824 else if (newsize >= YYMAXDEPTH)
1826 else if ((newsize *= 2) > YYMAXDEPTH)
1827 newsize = YYMAXDEPTH;
1829 i = (int) (data->s_mark - data->s_base);
1830 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
1834 data->s_base = newss;
1835 data->s_mark = newss + i;
1837 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
1841 data->l_base = newvs;
1842 data->l_mark = newvs + i;
1844 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1845 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
1849 data->p_base = newps;
1850 data->p_mark = newps + i;
1853 data->stacksize = newsize;
1854 data->s_last = data->s_base + newsize - 1;
1858 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
1863 #if YYPURE || defined(YY_NO_LEAKS)
1864 static void yyfreestack(YYSTACKDATA *data)
1868 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1871 memset(data, 0, sizeof(*data));
1874 #define yyfreestack(data) /* nothing */
1875 #endif /* YYPURE || defined(YY_NO_LEAKS) */
1878 static YYParseState *
1879 yyNewState(unsigned size)
1881 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
1882 if (p == NULL) return NULL;
1884 p->yystack.stacksize = size;
1887 p->yystack.s_base = NULL;
1888 p->yystack.l_base = NULL;
1889 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1890 p->yystack.p_base = NULL;
1894 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT));
1895 if (p->yystack.s_base == NULL) return NULL;
1896 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
1897 if (p->yystack.l_base == NULL) return NULL;
1898 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
1899 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1900 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
1901 if (p->yystack.p_base == NULL) return NULL;
1902 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
1909 yyFreeState(YYParseState *p)
1911 yyfreestack(&p->yystack);
1914 #endif /* YYBTYACC */
1916 #define YYABORT goto yyabort
1917 #define YYREJECT goto yyabort
1918 #define YYACCEPT goto yyaccept
1919 #define YYERROR goto yyerrlab
1921 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
1922 #define YYVALID_NESTED do { if (yyps->save && \
1923 yyps->save->save == 0) goto yyvalid; } while(0)
1924 #endif /* YYBTYACC */
1929 int yym, yyn, yystate, yyresult;
1932 YYParseState *yyerrctx = NULL;
1933 #endif /* YYBTYACC */
1934 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1935 YYLTYPE yyerror_loc_range[3]; /* position of error start/end (0 unused) */
1940 if ((yys = getenv("YYDEBUG")) != 0)
1943 if (yyn >= '0' && yyn <= '9')
1944 yydebug = yyn - '0';
1947 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
1949 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1950 memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range));
1954 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
1956 #endif /* YYBTYACC */
1965 memset(&yystack, 0, sizeof(yystack));
1968 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1969 yystack.s_mark = yystack.s_base;
1970 yystack.l_mark = yystack.l_base;
1971 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1972 yystack.p_mark = yystack.p_base;
1975 *yystack.s_mark = 0;
1978 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
1985 /* we're currently re-reading tokens */
1987 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1995 /* in trial mode; save scanner results for future parse attempts */
1996 if (yylvp == yylvlim)
1997 { /* Enlarge lexical value queue */
1998 size_t p = (size_t) (yylvp - yylvals);
1999 size_t s = (size_t) (yylvlim - yylvals);
2001 s += YYLVQUEUEGROWTH;
2002 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
2003 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
2004 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2005 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
2007 yylvp = yylve = yylvals + p;
2008 yylvlim = yylvals + s;
2009 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2010 yylpp = yylpe = yylpsns + p;
2011 yylplim = yylpsns + s;
2013 yylexp = yylexemes + p;
2015 *yylexp = (YYINT) YYLEX;
2018 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2025 /* normal operation, no conflict encountered */
2026 #endif /* YYBTYACC */
2030 #endif /* YYBTYACC */
2031 if (yychar < 0) yychar = YYEOF;
2035 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
2036 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
2037 YYDEBUGSTR, yydepth, yystate, yychar, yys);
2038 #ifdef YYSTYPE_TOSTRING
2041 #endif /* YYBTYACC */
2042 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
2044 fputc('\n', stderr);
2050 /* Do we have a conflict? */
2051 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
2052 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
2061 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
2062 YYDEBUGSTR, yydepth, yystate);
2064 /* Switch to the next conflict context */
2066 yypath = save->save;
2069 if (save->state != yystate) YYABORT;
2076 /* Unresolved conflict - start/continue trial parse */
2081 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
2083 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
2085 fputs("Starting trial parse.\n", stderr);
2088 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
2089 if (save == NULL) goto yyenomem;
2090 save->save = yyps->save;
2091 save->state = yystate;
2092 save->errflag = yyerrflag;
2093 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
2094 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
2095 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
2096 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
2097 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2098 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
2099 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
2101 ctry = yytable[yyn];
2102 if (yyctable[ctry] == -1)
2105 if (yydebug && yychar >= YYEOF)
2106 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
2111 if (yyps->save == NULL)
2113 /* If this is a first conflict in the stack, start saving lexemes */
2116 yylexemes = (YYINT *) malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
2117 if (yylexemes == NULL) goto yyenomem;
2118 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
2119 if (yylvals == NULL) goto yyenomem;
2120 yylvlim = yylvals + YYLVQUEUEGROWTH;
2121 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2122 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
2123 if (yylpsns == NULL) goto yyenomem;
2124 yylplim = yylpsns + YYLVQUEUEGROWTH;
2129 yylvp = yylve = yylvals;
2130 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2131 yylpp = yylpe = yylpsns;
2134 if (yychar >= YYEOF)
2137 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2140 *yylexp = (YYINT) yychar;
2145 if (yychar >= YYEOF)
2148 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2154 save->lexeme = (int) (yylvp - yylvals);
2157 if (yytable[yyn] == ctry)
2161 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
2162 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
2167 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2172 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
2174 yystate = yyctable[ctry];
2175 *++yystack.s_mark = (YYINT) yystate;
2176 *++yystack.l_mark = yylval;
2177 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2178 *++yystack.p_mark = yylloc;
2181 if (yyerrflag > 0) --yyerrflag;
2186 yyn = yyctable[ctry];
2189 } /* End of code dealing with conflicts */
2190 #endif /* YYBTYACC */
2191 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
2192 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
2196 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
2197 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
2199 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
2200 yystate = yytable[yyn];
2201 *++yystack.s_mark = yytable[yyn];
2202 *++yystack.l_mark = yylval;
2203 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2204 *++yystack.p_mark = yylloc;
2207 if (yyerrflag > 0) --yyerrflag;
2210 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
2211 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
2216 if (yyerrflag != 0) goto yyinrecovery;
2221 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
2224 /* explicit YYERROR from an action -- pop the rhs of the rule reduced
2225 * before looking for error recovery */
2226 yystack.s_mark -= yym;
2227 yystate = *yystack.s_mark;
2228 yystack.l_mark -= yym;
2229 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2230 yystack.p_mark -= yym;
2238 YYParseState *save = yyps->save;
2241 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
2242 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
2243 (int)(yylvp - yylvals - yyps->save->lexeme));
2245 /* Memorize most forward-looking error state in case it's really an error. */
2246 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
2248 /* Free old saved error context state */
2249 if (yyerrctx) yyFreeState(yyerrctx);
2250 /* Create and fill out new saved error context state */
2251 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
2252 if (yyerrctx == NULL) goto yyenomem;
2253 yyerrctx->save = yyps->save;
2254 yyerrctx->state = yystate;
2255 yyerrctx->errflag = yyerrflag;
2256 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
2257 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
2258 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
2259 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
2260 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2261 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
2262 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
2264 yyerrctx->lexeme = (int) (yylvp - yylvals);
2266 yylvp = yylvals + save->lexeme;
2267 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2268 yylpp = yylpsns + save->lexeme;
2270 yylexp = yylexemes + save->lexeme;
2272 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
2273 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
2274 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
2275 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
2276 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2277 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
2278 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
2280 ctry = ++save->ctry;
2281 yystate = save->state;
2282 /* We tried shift, try reduce now */
2283 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
2284 yyps->save = save->save;
2288 /* Nothing left on the stack -- error */
2293 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
2296 /* Restore state as it was in the most forward-advanced error */
2297 yylvp = yylvals + yyerrctx->lexeme;
2298 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2299 yylpp = yylpsns + yyerrctx->lexeme;
2301 yylexp = yylexemes + yyerrctx->lexeme;
2302 yychar = yylexp[-1];
2304 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2307 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
2308 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
2309 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
2310 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
2311 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2312 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
2313 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
2315 yystate = yyerrctx->state;
2316 yyFreeState(yyerrctx);
2321 if (yynewerrflag == 0) goto yyinrecovery;
2322 #endif /* YYBTYACC */
2324 YYERROR_CALL("syntax error");
2325 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2326 yyerror_loc_range[1] = yylloc; /* lookahead position is error start position */
2330 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
2341 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
2342 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
2346 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
2347 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
2349 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
2350 yystate = yytable[yyn];
2351 *++yystack.s_mark = yytable[yyn];
2352 *++yystack.l_mark = yylval;
2353 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2354 /* lookahead position is error end position */
2355 yyerror_loc_range[2] = yylloc;
2356 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
2357 *++yystack.p_mark = yyloc;
2365 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
2366 YYDEBUGSTR, yydepth, *yystack.s_mark);
2368 if (yystack.s_mark <= yystack.s_base) goto yyabort;
2369 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2370 /* the current TOS position is the error start position */
2371 yyerror_loc_range[1] = *yystack.p_mark;
2373 #if defined(YYDESTRUCT_CALL)
2376 #endif /* YYBTYACC */
2377 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2378 YYDESTRUCT_CALL("error: discarding state",
2379 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
2381 YYDESTRUCT_CALL("error: discarding state",
2382 yystos[*yystack.s_mark], yystack.l_mark);
2383 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
2384 #endif /* defined(YYDESTRUCT_CALL) */
2387 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2395 if (yychar == YYEOF) goto yyabort;
2399 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
2400 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
2401 YYDEBUGSTR, yydepth, yystate, yychar, yys);
2404 #if defined(YYDESTRUCT_CALL)
2407 #endif /* YYBTYACC */
2408 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2409 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
2411 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
2412 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
2413 #endif /* defined(YYDESTRUCT_CALL) */
2423 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
2424 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
2425 #ifdef YYSTYPE_TOSTRING
2428 #endif /* YYBTYACC */
2433 for (i = yym; i > 0; i--)
2435 if (i != yym) fputs(", ", stderr);
2436 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
2437 yystack.l_mark[1-i]), stderr);
2442 fputc('\n', stderr);
2446 yyval = yystack.l_mark[1-yym];
2448 memset(&yyval, 0, sizeof yyval);
2449 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2451 /* Perform position reduction */
2452 memset(&yyloc, 0, sizeof(yyloc));
2455 #endif /* YYBTYACC */
2457 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[-yym], yym);
2458 /* just in case YYERROR is invoked within the action, save
2459 the start of the rhs as the error start position */
2460 yyerror_loc_range[1] = yystack.p_mark[1-yym];
2467 #line 64 "expr.oxout.y"
2471 #line 66 "expr.oxout.y"
2473 yyyDecorate(); yyyExecuteRRsection(yystack.l_mark[0].yyyOxAttrbs.yyyOxStackItem->node);
2477 #line 73 "expr.oxout.y"
2479 yyyGenIntNode(1,1,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
2480 yyyAdjustINRC(1,1,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
2483 #line 80 "expr.oxout.y"
2485 yyyGenIntNode(2,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
2486 yyyAdjustINRC(2,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
2489 #line 87 "expr.oxout.y"
2491 yyyGenIntNode(3,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
2492 yyyAdjustINRC(3,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
2495 #line 94 "expr.oxout.y"
2497 yyyGenIntNode(4,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
2498 yyyAdjustINRC(4,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
2501 #line 101 "expr.oxout.y"
2503 yyyGenIntNode(5,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
2504 yyyAdjustINRC(5,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
2507 #line 108 "expr.oxout.y"
2509 yyyGenIntNode(6,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
2510 yyyAdjustINRC(6,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
2513 #line 114 "expr.oxout.y"
2515 yyyGenIntNode(7,1,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
2516 yyyAdjustINRC(7,1,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
2519 #line 121 "expr.oxout.y"
2521 yyyGenIntNode(8,1,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
2522 yyyAdjustINRC(8,1,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
2524 #line 2525 "expr.oxout.tab.c"
2528 yystack.s_mark -= yym;
2529 yystate = *yystack.s_mark;
2530 yystack.l_mark -= yym;
2531 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2532 yystack.p_mark -= yym;
2535 if (yystate == 0 && yym == 0)
2540 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
2541 #ifdef YYSTYPE_TOSTRING
2544 #endif /* YYBTYACC */
2545 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
2547 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
2551 *++yystack.s_mark = YYFINAL;
2552 *++yystack.l_mark = yyval;
2553 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2554 *++yystack.p_mark = yyloc;
2562 /* we're currently re-reading tokens */
2564 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2572 /* in trial mode; save scanner results for future parse attempts */
2573 if (yylvp == yylvlim)
2574 { /* Enlarge lexical value queue */
2575 size_t p = (size_t) (yylvp - yylvals);
2576 size_t s = (size_t) (yylvlim - yylvals);
2578 s += YYLVQUEUEGROWTH;
2579 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL)
2581 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
2583 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2584 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
2587 yylvp = yylve = yylvals + p;
2588 yylvlim = yylvals + s;
2589 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2590 yylpp = yylpe = yylpsns + p;
2591 yylplim = yylpsns + s;
2593 yylexp = yylexemes + p;
2595 *yylexp = (YYINT) YYLEX;
2598 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2605 /* normal operation, no conflict encountered */
2606 #endif /* YYBTYACC */
2610 #endif /* YYBTYACC */
2611 if (yychar < 0) yychar = YYEOF;
2615 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
2616 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
2617 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
2621 if (yychar == YYEOF) goto yyaccept;
2624 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
2625 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
2626 yystate = yytable[yyn];
2628 yystate = yydgoto[yym];
2632 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
2633 #ifdef YYSTYPE_TOSTRING
2636 #endif /* YYBTYACC */
2637 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
2639 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
2642 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
2643 *++yystack.s_mark = (YYINT) yystate;
2644 *++yystack.l_mark = yyval;
2645 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2646 *++yystack.p_mark = yyloc;
2651 /* Reduction declares that this path is valid. Set yypath and do a full parse */
2653 if (yypath) YYABORT;
2656 YYParseState *save = yyps->save;
2657 yyps->save = save->save;
2658 save->save = yypath;
2663 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
2664 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
2668 yyFreeState(yyerrctx);
2671 yylvp = yylvals + yypath->lexeme;
2672 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2673 yylpp = yylpsns + yypath->lexeme;
2675 yylexp = yylexemes + yypath->lexeme;
2677 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
2678 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
2679 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
2680 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
2681 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2682 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
2683 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
2685 yystate = yypath->state;
2687 #endif /* YYBTYACC */
2690 YYERROR_CALL("yacc stack overflow");
2694 YYERROR_CALL("memory exhausted");
2696 #endif /* YYBTYACC */
2706 if (yyps->save) goto yyvalid;
2707 #endif /* YYBTYACC */
2711 #if defined(YYDESTRUCT_CALL)
2712 if (yychar != YYEOF && yychar != YYEMPTY)
2713 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2714 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
2716 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
2717 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
2721 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2724 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
2725 YYDESTRUCT_CALL("cleanup: discarding state",
2726 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
2728 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
2729 YYDESTRUCT_CALL("cleanup: discarding state",
2730 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
2731 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
2733 #endif /* defined(YYDESTRUCT_CALL) */
2738 yyFreeState(yyerrctx);
2743 YYParseState *save = yyps;
2750 YYParseState *save = yypath;
2751 yypath = save->save;
2755 #endif /* YYBTYACC */
2756 yyfreestack(&yystack);