contrib/byacc/test/yacc/expr.oxout.tab.c

   1 /* original parser id follows */
   2 /* yysccsid[] = "@(#)yaccpar    1.9 (Berkeley) 02/21/93" */
   3 /* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
   4
   5 #define YYBYACC 1
   6 #define YYMAJOR 1
   7 #define YYMINOR 9
   8 #define YYCHECK "yyyymmdd"
   9
  10 #define YYEMPTY        (-1)
  11 #define yyclearin      (yychar = YYEMPTY)
  12 #define yyerrok        (yyerrflag = 0)
  13 #define YYRECOVERING() (yyerrflag != 0)
  14 #define YYENOMEM       (-2)
  15 #define YYEOF          0
  16
  17 #ifndef yyparse
  18 #define yyparse    expr.oxout_parse
  19 #endif /* yyparse */
  20
  21 #ifndef yylex
  22 #define yylex      expr.oxout_lex
  23 #endif /* yylex */
  24
  25 #ifndef yyerror
  26 #define yyerror    expr.oxout_error
  27 #endif /* yyerror */
  28
  29 #ifndef yychar
  30 #define yychar     expr.oxout_char
  31 #endif /* yychar */
  32
  33 #ifndef yyval
  34 #define yyval      expr.oxout_val
  35 #endif /* yyval */
  36
  37 #ifndef yylval
  38 #define yylval     expr.oxout_lval
  39 #endif /* yylval */
  40
  41 #ifndef yydebug
  42 #define yydebug    expr.oxout_debug
  43 #endif /* yydebug */
  44
  45 #ifndef yynerrs
  46 #define yynerrs    expr.oxout_nerrs
  47 #endif /* yynerrs */
  48
  49 #ifndef yyerrflag
  50 #define yyerrflag  expr.oxout_errflag
  51 #endif /* yyerrflag */
  52
  53 #ifndef yylhs
  54 #define yylhs      expr.oxout_lhs
  55 #endif /* yylhs */
  56
  57 #ifndef yylen
  58 #define yylen      expr.oxout_len
  59 #endif /* yylen */
  60
  61 #ifndef yydefred
  62 #define yydefred   expr.oxout_defred
  63 #endif /* yydefred */
  64
  65 #ifndef yydgoto
  66 #define yydgoto    expr.oxout_dgoto
  67 #endif /* yydgoto */
  68
  69 #ifndef yysindex
  70 #define yysindex   expr.oxout_sindex
  71 #endif /* yysindex */
  72
  73 #ifndef yyrindex
  74 #define yyrindex   expr.oxout_rindex
  75 #endif /* yyrindex */
  76
  77 #ifndef yygindex
  78 #define yygindex   expr.oxout_gindex
  79 #endif /* yygindex */
  80
  81 #ifndef yytable
  82 #define yytable    expr.oxout_table
  83 #endif /* yytable */
  84
  85 #ifndef yycheck
  86 #define yycheck    expr.oxout_check
  87 #endif /* yycheck */
  88
  89 #ifndef yyname
  90 #define yyname     expr.oxout_name
  91 #endif /* yyname */
  92
  93 #ifndef yyrule
  94 #define yyrule     expr.oxout_rule
  95 #endif /* yyrule */
  96 #define YYPREFIX "expr.oxout_"
  97
  98 #define YYPURE 0
  99
 100 #line 5 "expr.oxout.y"
 101 #include <stdlib.h>
 102 #include <string.h>
 103 #line 8 "expr.Y"
 104
 105 #include "expr.oxout.h"
 106 #include <stdio.h>
 107
 108 extern int yylex(void);
 109 extern void yyerror(const char *);
 110 #line 27 "expr.oxout.y"
 111 #include <limits.h>
 112 #define yyyR USHRT_MAX
 113 #ifdef YYSTYPE
 114 #undef  YYSTYPE_IS_DECLARED
 115 #define YYSTYPE_IS_DECLARED 1
 116 #endif
 117 #ifndef YYSTYPE_IS_DECLARED
 118 #define YYSTYPE_IS_DECLARED 1
 119 #line 31 "expr.oxout.y"
 120 typedef union {
 121 struct yyyOxAttrbs {
 122 struct yyyStackItem *yyyOxStackItem;
 123 } yyyOxAttrbs;
 124 } YYSTYPE;
 125 #endif /* !YYSTYPE_IS_DECLARED */
 126 #line 38 "expr.oxout.y"
 127 #include <stdio.h>
 128 #include <stdarg.h>
 129
 130 static int yyyYok = 1;
 131
 132 extern yyyFT yyyRCIL[];
 133
 134 void yyyExecuteRRsection(yyyGNT *rootNode);
 135 void yyyYoxInit(void);
 136 void yyyDecorate(void);
 137 struct yyyOxAttrbs; /* hack required to compensate for 'msta' behavior */
 138 void yyyGenIntNode(long yyyProdNum, int yyyRHSlength, int yyyNattrbs, struct yyyOxAttrbs *yyval_OxAttrbs, ...);
 139 void yyyAdjustINRC(long yyyProdNum, int yyyRHSlength, long startP, long stopP, struct yyyOxAttrbs *yyval_OxAttrbs, ...);
 140 void yyyCheckUnsolvedInstTrav(yyyGNT *rootNode,long *nNZrc,long *cycleSum);
 141 void yyyUnsolvedInstSearchTrav(yyyGNT *pNode);
 142 void yyyUnsolvedInstSearchTravAux(yyyGNT *pNode);
 143 void yyyabort(void);
 144
 145 #line 146 "expr.oxout.tab.c"
 146
 147 /* compatibility with bison */
 148 #ifdef YYPARSE_PARAM
 149 /* compatibility with FreeBSD */
 150 # ifdef YYPARSE_PARAM_TYPE
 151 #  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
 152 # else
 153 #  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
 154 # endif
 155 #else
 156 # define YYPARSE_DECL() yyparse(void)
 157 #endif
 158
 159 /* Parameters sent to lex. */
 160 #ifdef YYLEX_PARAM
 161 # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
 162 # define YYLEX yylex(YYLEX_PARAM)
 163 #else
 164 # define YYLEX_DECL() yylex(void)
 165 # define YYLEX yylex()
 166 #endif
 167
 168 /* Parameters sent to yyerror. */
 169 #ifndef YYERROR_DECL
 170 #define YYERROR_DECL() yyerror(const char *s)
 171 #endif
 172 #ifndef YYERROR_CALL
 173 #define YYERROR_CALL(msg) yyerror(msg)
 174 #endif
 175
 176 extern int YYPARSE_DECL();
 177
 178 #define ID 257
 179 #define CONST 258
 180 #define YYERRCODE 256
 181 typedef int YYINT;
 182 static const YYINT expr.oxout_lhs[] = {                  -1,
 183     2,    0,    1,    3,    3,    3,    3,    3,    3,    3,
 184 };
 185 static const YYINT expr.oxout_len[] = {                   2,
 186     0,    2,    1,    3,    3,    3,    3,    3,    1,    1,
 187 };
 188 static const YYINT expr.oxout_defred[] = {                1,
 189     0,    0,    9,   10,    0,    2,    0,    0,    0,    0,
 190     0,    0,    8,    0,    0,    4,    0,
 191 };
 192 static const YYINT expr.oxout_dgoto[] = {                 1,
 193     6,    2,    7,
 194 };
 195 static const YYINT expr.oxout_sindex[] = {                0,
 196     0,  -40,    0,    0,  -40,    0,  -18,  -24,  -40,  -40,
 197   -40,  -40,    0,  -37,  -37,    0,  -39,
 198 };
 199 static const YYINT expr.oxout_rindex[] = {                0,
 200     0,    0,    0,    0,    0,    0,    6,    0,    0,    0,
 201     0,    0,    0,    2,    8,    0,    1,
 202 };
 203 static const YYINT expr.oxout_gindex[] = {                0,
 204     0,    0,    4,
 205 };
 206 #define YYTABLESIZE 218
 207 static const YYINT expr.oxout_table[] = {                 5,
 208     6,    5,   11,    0,   11,    3,    0,    7,    8,   12,
 209     0,    0,   14,   15,   16,   17,   13,   11,    9,    0,
 210    10,    0,   12,   11,    9,    0,   10,    0,   12,    0,
 211     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 212     0,    6,    5,    6,    5,    6,    5,    6,    7,    0,
 213     7,    0,    7,    0,    0,    0,    0,    0,    0,    0,
 214     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 215     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 216     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 217     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 218     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 219     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 220     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 221     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 222     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 223     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 224     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 225     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 226     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 227     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 228     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 229     0,    0,    0,    0,    0,    0,    3,    4,
 230 };
 231 static const YYINT expr.oxout_check[] = {                40,
 232     0,    0,   42,   -1,   42,    0,   -1,    0,    5,   47,
 233    -1,   -1,    9,   10,   11,   12,   41,   42,   43,   -1,
 234    45,   -1,   47,   42,   43,   -1,   45,   -1,   47,   -1,
 235    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 236    -1,   41,   41,   43,   43,   45,   45,   47,   41,   -1,
 237    43,   -1,   45,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 238    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 239    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 240    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 241    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 242    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 243    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 244    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 245    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 246    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 247    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 248    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 249    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 250    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 251    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 252    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 253    -1,   -1,   -1,   -1,   -1,   -1,  257,  258,
 254 };
 255 #define YYFINAL 1
 256 #ifndef YYDEBUG
 257 #define YYDEBUG 0
 258 #endif
 259 #define YYMAXTOKEN 258
 260 #define YYUNDFTOKEN 264
 261 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
 262 #if YYDEBUG
 263 static const char *const expr.oxout_name[] = {
 264
 265 "end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 266 0,0,0,0,0,0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 267 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 268 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 269 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 270 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 271 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"ID",
 272 "CONST",0,0,0,0,0,"illegal-symbol",
 273 };
 274 static const char *const expr.oxout_rule[] = {
 275 "$accept : yyyAugNonterm",
 276 "$$1 :",
 277 "yyyAugNonterm : $$1 s",
 278 "s : expr",
 279 "expr : expr '*' expr",
 280 "expr : expr '+' expr",
 281 "expr : expr '/' expr",
 282 "expr : expr '-' expr",
 283 "expr : '(' expr ')'",
 284 "expr : ID",
 285 "expr : CONST",
 286
 287 };
 288 #endif
 289
 290 int      yydebug;
 291 int      yynerrs;
 292
 293 int      yyerrflag;
 294 int      yychar;
 295 YYSTYPE  yyval;
 296 YYSTYPE  yylval;
 297
 298 /* define the initial stack-sizes */
 299 #ifdef YYSTACKSIZE
 300 #undef YYMAXDEPTH
 301 #define YYMAXDEPTH  YYSTACKSIZE
 302 #else
 303 #ifdef YYMAXDEPTH
 304 #define YYSTACKSIZE YYMAXDEPTH
 305 #else
 306 #define YYSTACKSIZE 10000
 307 #define YYMAXDEPTH  10000
 308 #endif
 309 #endif
 310
 311 #define YYINITSTACKSIZE 200
 312
 313 typedef struct {
 314     unsigned stacksize;
 315     YYINT    *s_base;
 316     YYINT    *s_mark;
 317     YYINT    *s_last;
 318     YYSTYPE  *l_base;
 319     YYSTYPE  *l_mark;
 320 } YYSTACKDATA;
 321 /* variables for the parser stack */
 322 static YYSTACKDATA yystack;
 323 #line 53 "expr.Y"
 324
 325
 326 int yyparse(void);
 327
 328 int main()
 329   {yyparse();
 330   }
 331
 332
 333
 334 #line 138 "expr.oxout.y"
 335 long yyySSALspaceSize =    20000;
 336 long yyyRSmaxSize =        1000;
 337 long yyyTravStackMaxSize = 2000;
 338
 339 struct yyySolvedSAlistCell {yyyWAT attrbNum;
 340                             long next;
 341                            };
 342
 343 #define yyyLambdaSSAL 0
 344 long yyySSALCfreeList = yyyLambdaSSAL;
 345 long yyyNewSSALC = 1;
 346
 347 struct yyySolvedSAlistCell *yyySSALspace;
 348
 349 long yyyNbytesStackStg;
 350
 351
 352
 353 yyyFT yyyRCIL[1];
 354
 355 short yyyIIIEL[] = {0,
 356 0,2,6,10,14,18,22,24,
 357 };
 358
 359 long yyyIIEL[] = {
 360 0,0,0,0,0,0,0,0,0,0,0,0,
 361 0,0,0,0,0,0,0,0,0,0,0,0,
 362 1,1,
 363 };
 364
 365 long yyyIEL[] = {
 366 0,0,0,
 367 };
 368
 369 yyyFT yyyEntL[1];
 370
 371 void yyyfatal(char *msg)
 372 {fputs(msg,stderr);exit(-1);}
 373
 374
 375
 376 #define yyySSALof 'S'
 377 #define yyyRSof   'q'
 378 #define yyyTSof   't'
 379
 380
 381
 382 void yyyHandleOverflow(char which)
 383   {char *msg1,*msg2;
 384    long  oldSize,newSize;
 385    switch(which)
 386      {
 387       case yyySSALof :
 388            msg1 = "SSAL overflow: ";
 389            oldSize = yyySSALspaceSize;
 390            break;
 391       case yyyRSof   :
 392            msg1 = "ready set overflow: ";
 393            oldSize = yyyRSmaxSize;
 394            break;
 395       case yyyTSof   :
 396            msg1 = "traversal stack overflow: ";
 397            oldSize = yyyTravStackMaxSize;
 398            break;
 399       default        :;
 400      }
 401    newSize = (3*oldSize)/2;
 402    if (newSize < 100) newSize = 100;
 403    fputs(msg1,stderr);
 404    fprintf(stderr,"size was %ld.\n",oldSize);
 405    msg2 = "     Have to modify evaluator:  -Y%c%ld.\n";
 406    fprintf(stderr,msg2,which,newSize);
 407    exit(-1);
 408   }
 409
 410
 411
 412 void yyySignalEnts(yyyGNT *node,long startP,long stopP)
 413   {yyyGNT *dumNode;
 414
 415    while (startP < stopP)
 416      {
 417       if (!yyyEntL[startP]) dumNode = node;
 418          else dumNode = (node->cL)[yyyEntL[startP]-1];
 419       if (!(--((dumNode->refCountList)[yyyEntL[startP+1]]
 420               )
 421            )
 422          )
 423          {
 424           if (++yyyRSTop == yyyAfterRS)
 425              {yyyHandleOverflow(yyyRSof);
 426               break;
 427              }
 428           yyyRSTop->node = dumNode;
 429           yyyRSTop->whichSym = yyyEntL[startP];
 430           yyyRSTop->wa = yyyEntL[startP+1];
 431          }
 432       startP += 2;
 433      }
 434   }
 435
 436
 437
 438
 439
 440
 441 void yyySolveAndSignal() {
 442 long yyyiDum,*yyypL;
 443 int yyyws,yyywa;
 444 yyyGNT *yyyRSTopN,*yyyRefN;
 445 yyyParent yyyRSTopNp;
 446
 447
 448 yyyRSTopNp = (yyyRSTopN = yyyRSTop->node)->parent;
 449 yyyRefN= (yyyws = (yyyRSTop->whichSym))?yyyRSTopNp.noderef:yyyRSTopN;
 450 yyywa = yyyRSTop->wa;
 451 yyyRSTop--;
 452 switch(yyyRefN->prodNum) {
 453 case 1:  /***yacc rule 1***/
 454   switch (yyyws) {
 455   }
 456 break;
 457 case 2:  /***yacc rule 2***/
 458   switch (yyyws) {
 459   }
 460 break;
 461 case 3:  /***yacc rule 3***/
 462   switch (yyyws) {
 463   }
 464 break;
 465 case 4:  /***yacc rule 4***/
 466   switch (yyyws) {
 467   }
 468 break;
 469 case 5:  /***yacc rule 5***/
 470   switch (yyyws) {
 471   }
 472 break;
 473 case 6:  /***yacc rule 6***/
 474   switch (yyyws) {
 475   }
 476 break;
 477 case 7:  /***yacc rule 7***/
 478   switch (yyyws) {
 479   case 1:  /**/
 480     switch (yyywa) {
 481     }
 482   break;
 483   }
 484 break;
 485 case 8:  /***yacc rule 8***/
 486   switch (yyyws) {
 487   case 1:  /**/
 488     switch (yyywa) {
 489     }
 490   break;
 491   }
 492 break;
 493 } /* switch */
 494
 495 if (yyyws)  /* the just-solved instance was inherited. */
 496    {if (yyyRSTopN->prodNum)
 497        {yyyiDum = yyyIIEL[yyyIIIEL[yyyRSTopN->prodNum]] + yyywa;
 498         yyySignalEnts(yyyRSTopN,yyyIEL[yyyiDum],
 499                                 yyyIEL[yyyiDum+1]
 500                      );
 501        }
 502    }
 503    else     /* the just-solved instance was synthesized. */
 504    {if (!(yyyRSTopN->parentIsStack)) /* node has a parent. */
 505        {yyyiDum = yyyIIEL[yyyIIIEL[yyyRSTopNp.noderef->prodNum] +
 506                           yyyRSTopN->whichSym
 507                          ] +
 508                   yyywa;
 509         yyySignalEnts(yyyRSTopNp.noderef,
 510                       yyyIEL[yyyiDum],
 511                       yyyIEL[yyyiDum+1]
 512                      );
 513        }
 514        else   /* node is still on the stack--it has no parent yet. */
 515        {yyypL = &(yyyRSTopNp.stackref->solvedSAlist);
 516         if (yyySSALCfreeList == yyyLambdaSSAL)
 517            {yyySSALspace[yyyNewSSALC].next = *yyypL;
 518             if ((*yyypL = yyyNewSSALC++) == yyySSALspaceSize)
 519                yyyHandleOverflow(yyySSALof);
 520            }
 521            else
 522            {yyyiDum = yyySSALCfreeList;
 523             yyySSALCfreeList = yyySSALspace[yyySSALCfreeList].next;
 524             yyySSALspace[yyyiDum].next = *yyypL;
 525             *yyypL = yyyiDum;
 526            }
 527         yyySSALspace[*yyypL].attrbNum = yyywa;
 528        }
 529    }
 530
 531 } /* yyySolveAndSignal */
 532
 533
 534
 535
 536
 537
 538 #define condStg unsigned int conds;
 539 #define yyyClearConds {yyyTST->conds = 0;}
 540 #define yyySetCond(n) {yyyTST->conds += (1<<(n));}
 541 #define yyyCond(n) ((yyyTST->conds & (1<<(n)))?1:0)
 542
 543
 544
 545 struct yyyTravStackItem {yyyGNT *node;
 546                          char isReady;
 547                          condStg
 548                         };
 549
 550
 551
 552 void yyyDoTraversals(yyyGNT *rootNode)
 553 {struct yyyTravStackItem *yyyTravStack,*yyyTST,*yyyAfterTravStack;
 554  yyyGNT *yyyTSTn,**yyyCLptr2;
 555  int yyyi,yyyRL,yyyPass;
 556  int i;
 557
 558  if (!yyyYok) return;
 559  if ((yyyTravStack =
 560                  ((struct yyyTravStackItem *)
 561                   calloc((size_t)yyyTravStackMaxSize,
 562                          (size_t)sizeof(struct yyyTravStackItem)
 563                         )
 564                  )
 565      )
 566      ==
 567      (struct yyyTravStackItem *)NULL
 568     )
 569     {fputs("malloc error in traversal stack allocation\n",stderr);
 570      exit(-1);
 571     }
 572
 573 yyyAfterTravStack = yyyTravStack + yyyTravStackMaxSize;
 574 yyyTravStack++;
 575
 576
 577 for (yyyi=0; yyyi<2; yyyi++) {
 578 yyyTST = yyyTravStack;
 579 yyyTST->node = rootNode;
 580 yyyTST->isReady = 0;
 581 yyyClearConds
 582
 583 while(yyyTST >= yyyTravStack)
 584   {yyyTSTn = yyyTST->node;
 585    if (yyyTST->isReady)
 586       {yyyPass = 1;
 587        goto yyyTravSwitch;
 588 yyyTpop:
 589        yyyTST--;
 590       }
 591       else
 592       {yyyPass = 0;
 593        goto yyyTravSwitch;
 594 yyyTpush:
 595        yyyTST->isReady = 1;
 596        if (yyyTSTn->prodNum)
 597           {if (yyyRL)
 598              {yyyCLptr2 = yyyTSTn->cL;
 599               i = yyyTSTn->cLlen;
 600               while (i--)
 601                 {if (++yyyTST == yyyAfterTravStack)
 602                     yyyHandleOverflow(yyyTSof);
 603                     else
 604                     {yyyTST->node = *yyyCLptr2;
 605                      yyyTST->isReady = 0;
 606                      yyyClearConds
 607                     }
 608                  yyyCLptr2++;
 609                 }
 610              } /* right to left */
 611              else  /* left to right */
 612              {i = yyyTSTn->cLlen;
 613               yyyCLptr2 = yyyTSTn->cL + i;
 614               while (i--)
 615                 {yyyCLptr2--;
 616                  if (++yyyTST == yyyAfterTravStack)
 617                     yyyHandleOverflow(yyyTSof);
 618                     else
 619                     {yyyTST->node = *yyyCLptr2;
 620                      yyyTST->isReady = 0;
 621                      yyyClearConds
 622                     }
 623                 }
 624              } /* left to right */
 625           }
 626       } /* else */
 627    continue;
 628 yyyTravSwitch:
 629                                 switch(yyyTSTn->prodNum)        {
 630 case 1:
 631         switch(yyyi)    {
 632                 case 0:
 633                         switch(yyyPass) {
 634                                 case 0:
 635 yyyRL = 0;yyySetCond(0)
 636
 637 if (!
 638 #line 24 "expr.Y"
 639   (1)
 640 #line 444 "expr.oxout.y"
 641 ) yyySetCond(1)
 642 yyySetCond(2)
 643
 644                                 case 1:
 645
 646 if (yyyCond(0) != yyyPass) {
 647 #line 24 "expr.Y"
 648
 649 #line 453 "expr.oxout.y"
 650 }
 651 if (yyyCond(1) != yyyPass) {
 652 #line 24 "expr.Y"
 653  printf("\n");
 654
 655 #line 459 "expr.oxout.y"
 656 }
 657 if (yyyCond(2) != yyyPass) {
 658 #line 25 "expr.Y"
 659   printf("prefix:   ");
 660
 661 #line 465 "expr.oxout.y"
 662 }
 663                                 break;
 664                                         }
 665                 break;
 666                 case 1:
 667                         switch(yyyPass) {
 668                                 case 0:
 669 yyyRL = 0;
 670 if (
 671 #line 23 "expr.Y"
 672   (1)
 673 #line 477 "expr.oxout.y"
 674 ) yyySetCond(2)
 675
 676                                 case 1:
 677
 678 if (yyyCond(0) != yyyPass) {
 679 #line 22 "expr.Y"
 680  printf("\n");
 681
 682 #line 486 "expr.oxout.y"
 683 }
 684 if (yyyCond(1) != yyyPass) {
 685 #line 23 "expr.Y"
 686
 687 #line 491 "expr.oxout.y"
 688 }
 689 if (yyyCond(2) != yyyPass) {
 690 #line 23 "expr.Y"
 691  printf("postfix:  ")/* missing ; */
 692
 693 #line 497 "expr.oxout.y"
 694 }
 695                                 break;
 696                                         }
 697                 break;
 698                         }
 699
 700 break;
 701 case 2:
 702         switch(yyyi)    {
 703                 case 0:
 704                         switch(yyyPass) {
 705                                 case 0:
 706 yyyRL = 0;yyySetCond(0)
 707
 708                                 case 1:
 709
 710 if (yyyCond(0) != yyyPass) {
 711 #line 29 "expr.Y"
 712   printf(" * ");
 713
 714 #line 518 "expr.oxout.y"
 715 }
 716                                 break;
 717                                         }
 718                 break;
 719                 case 1:
 720                         switch(yyyPass) {
 721                                 case 0:
 722 yyyRL = 0;
 723                                 case 1:
 724
 725 if (yyyCond(0) != yyyPass) {
 726 #line 28 "expr.Y"
 727  printf(" * ");
 728
 729 #line 533 "expr.oxout.y"
 730 }
 731                                 break;
 732                                         }
 733                 break;
 734                         }
 735
 736 break;
 737 case 3:
 738         switch(yyyi)    {
 739                 case 0:
 740                         switch(yyyPass) {
 741                                 case 0:
 742 yyyRL = 0;yyySetCond(0)
 743
 744                                 case 1:
 745
 746 if (yyyCond(0) != yyyPass) {
 747 #line 32 "expr.Y"
 748   printf(" + ");
 749
 750 #line 554 "expr.oxout.y"
 751 }
 752                                 break;
 753                                         }
 754                 break;
 755                 case 1:
 756                         switch(yyyPass) {
 757                                 case 0:
 758 yyyRL = 0;
 759                                 case 1:
 760
 761 if (yyyCond(0) != yyyPass) {
 762 #line 33 "expr.Y"
 763  printf(" + ");
 764
 765 #line 569 "expr.oxout.y"
 766 }
 767                                 break;
 768                                         }
 769                 break;
 770                         }
 771
 772 break;
 773 case 4:
 774         switch(yyyi)    {
 775                 case 0:
 776                         switch(yyyPass) {
 777                                 case 0:
 778 yyyRL = 0;yyySetCond(0)
 779
 780                                 case 1:
 781
 782 if (yyyCond(0) != yyyPass) {
 783 #line 37 "expr.Y"
 784   printf(" / ");
 785
 786 #line 590 "expr.oxout.y"
 787 }
 788                                 break;
 789                                         }
 790                 break;
 791                 case 1:
 792                         switch(yyyPass) {
 793                                 case 0:
 794 yyyRL = 0;
 795                                 case 1:
 796
 797 if (yyyCond(0) != yyyPass) {
 798 #line 36 "expr.Y"
 799  printf(" / ");
 800
 801 #line 605 "expr.oxout.y"
 802 }
 803                                 break;
 804                                         }
 805                 break;
 806                         }
 807
 808 break;
 809 case 5:
 810         switch(yyyi)    {
 811                 case 0:
 812                         switch(yyyPass) {
 813                                 case 0:
 814 yyyRL = 0;yyySetCond(0)
 815
 816                                 case 1:
 817
 818 if (yyyCond(0) != yyyPass) {
 819 #line 41 "expr.Y"
 820   printf(" - ");
 821
 822 #line 626 "expr.oxout.y"
 823 }
 824                                 break;
 825                                         }
 826                 break;
 827                 case 1:
 828                         switch(yyyPass) {
 829                                 case 0:
 830 yyyRL = 0;
 831                                 case 1:
 832
 833 if (yyyCond(0) != yyyPass) {
 834 #line 40 "expr.Y"
 835  printf(" - ");
 836
 837 #line 641 "expr.oxout.y"
 838 }
 839                                 break;
 840                                         }
 841                 break;
 842                         }
 843
 844 break;
 845 case 6:
 846         switch(yyyi)    {
 847                 case 0:
 848                         switch(yyyPass) {
 849                                 case 0:
 850 yyyRL = 0;
 851                                 case 1:
 852
 853                                 break;
 854                                         }
 855                 break;
 856                 case 1:
 857                         switch(yyyPass) {
 858                                 case 0:
 859 yyyRL = 0;
 860                                 case 1:
 861
 862                                 break;
 863                                         }
 864                 break;
 865                         }
 866
 867 break;
 868 case 7:
 869         switch(yyyi)    {
 870                 case 0:
 871                         switch(yyyPass) {
 872                                 case 0:
 873 yyyRL = 0;yyySetCond(0)
 874
 875                                 case 1:
 876
 877 if (yyyCond(0) != yyyPass) {
 878 #line 46 "expr.Y"
 879   printf(" %s ",yyyTSTn->cL[0]->yyyAttrbs.yyyAttrb1.lexeme);
 880
 881 #line 685 "expr.oxout.y"
 882 }
 883                                 break;
 884                                         }
 885                 break;
 886                 case 1:
 887                         switch(yyyPass) {
 888                                 case 0:
 889 yyyRL = 0;
 890                                 case 1:
 891
 892 if (yyyCond(0) != yyyPass) {
 893 #line 45 "expr.Y"
 894  printf(" %s ",yyyTSTn->cL[0]->yyyAttrbs.yyyAttrb1.lexeme);
 895
 896 #line 700 "expr.oxout.y"
 897 }
 898                                 break;
 899                                         }
 900                 break;
 901                         }
 902
 903 break;
 904 case 8:
 905         switch(yyyi)    {
 906                 case 0:
 907                         switch(yyyPass) {
 908                                 case 0:
 909 yyyRL = 0;yyySetCond(0)
 910
 911                                 case 1:
 912
 913 if (yyyCond(0) != yyyPass) {
 914 #line 50 "expr.Y"
 915   printf(" %s ",yyyTSTn->cL[0]->yyyAttrbs.yyyAttrb1.lexeme);
 916
 917 #line 721 "expr.oxout.y"
 918 }
 919                                 break;
 920                                         }
 921                 break;
 922                 case 1:
 923                         switch(yyyPass) {
 924                                 case 0:
 925 yyyRL = 0;
 926                                 case 1:
 927
 928 if (yyyCond(0) != yyyPass) {
 929 #line 49 "expr.Y"
 930  printf(" %s ",yyyTSTn->cL[0]->yyyAttrbs.yyyAttrb1.lexeme);
 931
 932 #line 736 "expr.oxout.y"
 933 }
 934                                 break;
 935                                         }
 936                 break;
 937                         }
 938
 939 break;
 940                                                                 } /* switch */
 941    if (yyyPass) goto yyyTpop; else goto yyyTpush;
 942   } /* while */
 943  } /* for */
 944 } /* yyyDoTraversals */
 945
 946 void yyyExecuteRRsection(yyyGNT *rootNode)  {
 947    int yyyi;
 948    long cycleSum = 0;
 949    long nNZrc = 0;
 950
 951    if (!yyyYok) return;
 952    yyyCheckUnsolvedInstTrav(rootNode,&nNZrc,&cycleSum);
 953    if (nNZrc)
 954       {
 955        fputs("\n\n\n**********\n",stderr);
 956        fputs("cycle detected in completed parse tree",stderr);
 957        fputs(" after decoration.\n",stderr);
 958 #if CYCLE_VERBOSE
 959        fprintf(stderr,
 960                "number of unsolved attribute instances == %ld.\n",
 961                nNZrc
 962               );
 963        fprintf(stderr,
 964                "total number of remaining dependencies == %ld.\n",
 965                cycleSum
 966               );
 967        fputs("average number of remaining dependencies\n",stderr);
 968        fprintf(stderr,"  per unsolved instance == %f.\n",
 969                ((float)(cycleSum)/(float)(nNZrc))
 970               );
 971 #endif
 972        fprintf(stderr,
 973          "searching parse tree for %ld unsolved instances:\n",
 974                nNZrc
 975               );
 976        yyyUnsolvedInstSearchTravAux(rootNode);
 977       }
 978    yyyDoTraversals(rootNode);
 979 } /* yyyExecuteRRsection */
 980
 981
 982
 983 yyyWAT yyyLRCIL[2] = {0,0,
 984 };
 985
 986
 987
 988 void yyyYoxInit(void)
 989   {
 990    static int yyyInitDone = 0;
 991    if (yyyInitDone) return;
 992
 993    if ((yyyRS = (struct yyyRSitem *)
 994          calloc((size_t)(yyyRSmaxSize+1), (size_t)sizeof(struct yyyRSitem))
 995        )
 996        ==
 997        ((struct yyyRSitem *) NULL)
 998       )
 999       yyyfatal("malloc error in ox ready set space allocation\n");
1000    yyyRS++;
1001    yyyAfterRS = yyyRS + yyyRSmaxSize;
1002
1003
1004    if ((yyySSALspace = (struct yyySolvedSAlistCell *)
1005           calloc((size_t)(yyySSALspaceSize+1), (size_t)sizeof(struct yyySolvedSAlistCell))
1006        )
1007        ==
1008        ((struct yyySolvedSAlistCell *) NULL)
1009       )
1010       yyyfatal("malloc error in stack solved list space allocation\n");
1011    yyyInitDone = 1;
1012
1013    yyyRSTop = yyyRS - 1;
1014   } /* yyyYoxInit */
1015
1016
1017
1018 void yyyDecorate(void)
1019   {
1020    while (yyyRSTop >= yyyRS)
1021       yyySolveAndSignal();
1022   }
1023
1024
1025
1026 void yyyGenIntNode(long yyyProdNum, int yyyRHSlength, int yyyNattrbs, struct yyyOxAttrbs *yyval_OxAttrbs, ...)
1027   {yyyWST i;
1028    yyySIT **yyyOxStackItem = &yyval_OxAttrbs->yyyOxStackItem;
1029    yyyGNT *gnpDum;
1030    va_list ap;
1031
1032    *yyyOxStackItem = (yyySIT *) malloc((size_t)sizeof(yyySIT));
1033    if (*yyyOxStackItem == (yyySIT *) NULL)
1034       yyyfatal("malloc error in ox yacc semantic stack space allocation\n");
1035    (*yyyOxStackItem)->node =
1036                                 (yyyGNT *) malloc((size_t)sizeof(yyyGNT));
1037    if ((*yyyOxStackItem)->node == (yyyGNT *) NULL)
1038       yyyfatal("malloc error in ox node space allocation\n");
1039    (*yyyOxStackItem)->solvedSAlist = yyyLambdaSSAL;
1040    (*yyyOxStackItem)->node->parent.stackref = *yyyOxStackItem;
1041    (*yyyOxStackItem)->node->parentIsStack = 1;
1042    (*yyyOxStackItem)->node->cLlen  = yyyRHSlength;
1043    (*yyyOxStackItem)->node->cL =
1044             (yyyGNT **) calloc((size_t)yyyRHSlength, (size_t)sizeof(yyyGNT *));
1045    if ((*yyyOxStackItem)->node->cL == (yyyGNT **) NULL)
1046       yyyfatal("malloc error in ox child list space allocation\n");
1047    (*yyyOxStackItem)->node->refCountListLen = yyyNattrbs;
1048    (*yyyOxStackItem)->node->refCountList =
1049             (yyyRCT *) calloc((size_t)yyyNattrbs, (size_t)sizeof(yyyRCT));
1050    if ((*yyyOxStackItem)->node->refCountList == (yyyRCT *) NULL)
1051       yyyfatal("malloc error in ox reference count list space allocation\n");
1052    (*yyyOxStackItem)->node->prodNum = yyyProdNum;
1053    va_start(ap, yyval_OxAttrbs);
1054    for (i=1;i<=yyyRHSlength;i++)
1055      {yyySIT *yaccStDum = va_arg(ap,struct yyyOxAttrbs *)->yyyOxStackItem;
1056       gnpDum = (*yyyOxStackItem)->node->cL[i-1] = yaccStDum->node;
1057       gnpDum->whichSym = i;
1058       gnpDum->parent.noderef = (*yyyOxStackItem)->node;
1059       gnpDum->parentIsStack = 0;
1060      }
1061    va_end(ap);
1062   }
1063
1064
1065
1066 #define yyyDECORfREQ 50
1067
1068
1069
1070 void yyyAdjustINRC(long yyyProdNum, int yyyRHSlength, long startP, long stopP, struct yyyOxAttrbs *yyval_OxAttrbs, ...)
1071   {yyyWST i;
1072    yyySIT *yyyOxStackItem = yyval_OxAttrbs->yyyOxStackItem;
1073    long SSALptr,SSALptrHead,*cPtrPtr;
1074    long *pL;
1075    yyyGNT *gnpDum;
1076    long iTemp;
1077    long nextP;
1078    static unsigned short intNodeCount = yyyDECORfREQ;
1079    va_list ap;
1080
1081    nextP = startP;
1082    while (nextP < stopP)
1083      {if (yyyRCIL[nextP] == yyyR)
1084          {(yyyOxStackItem->node->refCountList)[yyyRCIL[nextP+1]] = yyyRCIL[nextP+2];
1085          }
1086          else
1087          {(((yyyOxStackItem->node->cL)[yyyRCIL[nextP]])->refCountList)[yyyRCIL[nextP+1]] = yyyRCIL[nextP+2];
1088          }
1089       nextP += 3;
1090      }
1091    pL = yyyIIEL + yyyIIIEL[yyyProdNum];
1092    va_start(ap, yyval_OxAttrbs);
1093    for (i=1;i<=yyyRHSlength;i++)
1094      {yyySIT *yaccStDum = va_arg(ap,struct yyyOxAttrbs *)->yyyOxStackItem;
1095       pL++;
1096       SSALptrHead = SSALptr = *(cPtrPtr = &(yaccStDum->solvedSAlist));
1097       if (SSALptr != yyyLambdaSSAL)
1098          {*cPtrPtr = yyyLambdaSSAL;
1099           do
1100             {
1101              iTemp = (*pL+yyySSALspace[SSALptr].attrbNum);
1102              yyySignalEnts(yyyOxStackItem->node,
1103                            yyyIEL[iTemp],
1104                            yyyIEL[iTemp+1]
1105                           );
1106              SSALptr = *(cPtrPtr = &(yyySSALspace[SSALptr].next));
1107             }
1108             while (SSALptr != yyyLambdaSSAL);
1109           *cPtrPtr = yyySSALCfreeList;
1110           yyySSALCfreeList = SSALptrHead;
1111          }
1112      }
1113    va_end(ap);
1114    nextP = startP + 2;
1115    while (nextP < stopP)
1116      {if (!yyyRCIL[nextP])
1117          {if (yyyRCIL[nextP-2] == yyyR)
1118              {pL = &(yyyOxStackItem->solvedSAlist);
1119               if (yyySSALCfreeList == yyyLambdaSSAL)
1120                  {yyySSALspace[yyyNewSSALC].next = *pL;
1121                   if ((*pL = yyyNewSSALC++) == yyySSALspaceSize)
1122                      yyyHandleOverflow(yyySSALof);
1123                  }
1124                  else
1125                  {iTemp = yyySSALCfreeList;
1126                   yyySSALCfreeList = yyySSALspace[yyySSALCfreeList].next;
1127                   yyySSALspace[iTemp].next = *pL;
1128                   *pL = iTemp;
1129                  }
1130               yyySSALspace[*pL].attrbNum = yyyRCIL[nextP-1];
1131              }
1132              else
1133              {if ((gnpDum = (yyyOxStackItem->node->cL)[yyyRCIL[nextP-2]])->prodNum != 0)
1134                  {
1135                   iTemp = yyyIIEL[yyyIIIEL[gnpDum->prodNum]] + yyyRCIL[nextP-1];
1136                   yyySignalEnts(gnpDum,
1137                                 yyyIEL[iTemp],
1138                                 yyyIEL[iTemp+1]
1139                                );
1140                  }
1141              }
1142          }
1143       nextP += 3;
1144      }
1145    if (!--intNodeCount)
1146       {intNodeCount = yyyDECORfREQ;
1147        yyyDecorate();
1148       }
1149   }
1150
1151
1152
1153 void yyyGenLeaf(int nAttrbs,int typeNum,long startP,long stopP,YYSTYPE *yylval)
1154   {yyyRCT *rcPdum;
1155    yyySIT **yyyOxStackItem = &yylval->yyyOxAttrbs.yyyOxStackItem;
1156    (*yyyOxStackItem) = (yyySIT *) malloc((size_t)sizeof(yyySIT));
1157    if ((*yyyOxStackItem) == (yyySIT *) NULL)
1158       yyyfatal("malloc error in ox yacc semantic stack space allocation\n");
1159    (*yyyOxStackItem)->node =
1160                           (yyyGNT *) malloc((size_t)sizeof(yyyGNT))
1161                          ;
1162    if ((*yyyOxStackItem)->node == (yyyGNT *) NULL)
1163       yyyfatal("malloc error in ox node space allocation\n");
1164    (*yyyOxStackItem)->solvedSAlist = yyyLambdaSSAL;
1165    (*yyyOxStackItem)->node->parent.stackref = *yyyOxStackItem;
1166    (*yyyOxStackItem)->node->parentIsStack = 1;
1167    (*yyyOxStackItem)->node->cLlen = 0;
1168    (*yyyOxStackItem)->node->cL = (yyyGNT **)NULL;
1169    (*yyyOxStackItem)->node->refCountListLen = nAttrbs;
1170    rcPdum = (*yyyOxStackItem)->node->refCountList =
1171             (yyyRCT *) calloc((size_t)nAttrbs, (size_t)sizeof(yyyRCT));
1172    if (rcPdum == (yyyRCT *) NULL)
1173       yyyfatal("malloc error in ox reference count list space allocation\n");
1174    while (startP < stopP) rcPdum[yyyLRCIL[startP++]] = 0;
1175    (*yyyOxStackItem)->node->prodNum = 0;
1176    (*yyyOxStackItem)->node->whichSym = 0;
1177   }
1178
1179
1180
1181 void yyyabort(void)
1182   {yyyYok = 0;
1183   }
1184
1185
1186
1187
1188
1189 #define yyyLastProdNum 8
1190
1191
1192 #define yyyNsorts 1
1193
1194
1195 int yyyProdsInd[] = {
1196    0,
1197    0,   2,   6,  10,  14,  18,  22,  24,
1198   26,
1199 };
1200
1201
1202 int yyyProds[][2] = {
1203 { 116,   0},{ 462,   0},{ 462,   0},{ 462,   0},{ 412,   0},
1204 { 462,   0},{ 462,   0},{ 462,   0},{ 420,   0},{ 462,   0},
1205 { 462,   0},{ 462,   0},{ 452,   0},{ 462,   0},{ 462,   0},
1206 { 462,   0},{ 436,   0},{ 462,   0},{ 462,   0},{ 396,   0},
1207 { 462,   0},{ 404,   0},{ 462,   0},{ 619,   1},{ 462,   0},
1208 { 567,   1},
1209 };
1210
1211
1212 int yyySortsInd[] = {
1213   0,
1214   0,
1215   1,
1216 };
1217
1218
1219 int yyySorts[] = {
1220   413,
1221 };
1222
1223
1224
1225 char *yyyStringTab[] = {
1226 0,0,0,0,0,
1227 0,0,0,0,0,
1228 0,0,0,0,0,
1229 0,0,0,0,0,
1230 0,0,0,0,0,
1231 0,0,0,0,0,
1232 0,0,0,0,0,
1233 0,0,0,0,0,
1234 0,0,0,0,0,
1235 0,0,0,0,0,
1236 0,0,0,0,0,
1237 0,0,0,0,0,
1238 0,0,0,0,0,
1239 0,0,0,0,0,
1240 0,0,0,0,0,
1241 0,0,0,0,0,
1242 0,0,0,0,0,
1243 0,0,0,0,0,
1244 0,0,0,0,0,
1245 0,0,0,0,0,
1246 0,0,0,0,0,
1247 0,0,0,0,0,
1248 0,0,0,0,0,
1249 0,"s",0,0,0,
1250 0,0,"y",0,0,
1251 0,0,0,0,0,
1252 0,0,0,0,0,
1253 0,0,0,0,0,
1254 0,0,0,0,0,
1255 0,0,0,0,0,
1256 0,0,0,0,0,
1257 0,0,0,0,0,
1258 0,0,0,0,0,
1259 0,0,0,0,0,
1260 0,0,0,0,0,
1261 0,0,0,0,0,
1262 0,0,0,0,0,
1263 0,0,0,0,0,
1264 0,0,0,0,0,
1265 0,0,0,0,0,
1266 0,0,0,0,0,
1267 0,0,0,0,0,
1268 0,0,0,0,0,
1269 0,0,0,0,0,
1270 0,0,0,0,0,
1271 0,0,0,0,0,
1272 0,0,0,0,0,
1273 0,0,0,0,0,
1274 0,0,0,0,0,
1275 0,0,0,0,0,
1276 0,0,0,0,0,
1277 0,0,0,0,0,
1278 0,0,0,0,0,
1279 0,0,0,0,0,
1280 0,0,0,0,0,
1281 0,0,0,0,0,
1282 0,0,0,0,0,
1283 0,0,0,0,0,
1284 0,0,0,0,0,
1285 0,0,0,0,0,
1286 0,0,0,0,0,
1287 0,0,0,0,0,
1288 0,0,0,0,0,
1289 0,0,0,0,0,
1290 0,0,0,0,0,
1291 0,"LRpre",0,0,0,
1292 0,0,0,0,0,
1293 0,0,0,0,0,
1294 0,0,0,0,0,
1295 0,0,0,0,0,
1296 0,0,0,0,0,
1297 0,0,0,0,0,
1298 0,0,0,0,0,
1299 0,0,0,0,0,
1300 0,0,0,0,0,
1301 0,0,0,0,0,
1302 0,0,0,0,0,
1303 0,0,0,0,0,
1304 0,0,0,0,0,
1305 0,"'('",0,0,0,
1306 0,0,0,0,"')'",
1307 0,0,0,0,0,
1308 0,0,"'*'","lexeme",0,
1309 0,0,0,0,0,
1310 "'+'",0,0,0,0,
1311 0,0,0,0,0,
1312 0,0,0,0,0,
1313 0,"'-'",0,0,0,
1314 0,0,0,0,0,
1315 0,0,0,0,0,
1316 0,0,"'/'",0,0,
1317 0,0,0,0,0,
1318 0,0,"expr",0,0,
1319 0,0,0,0,0,
1320 0,0,0,0,0,
1321 0,"printf",0,0,0,
1322 0,0,0,0,0,
1323 0,0,0,0,0,
1324 0,0,0,0,0,
1325 0,0,0,0,0,
1326 0,0,0,0,0,
1327 0,0,0,0,0,
1328 0,0,0,0,0,
1329 0,0,0,0,0,
1330 0,0,0,0,0,
1331 0,0,0,0,0,
1332 0,0,0,0,0,
1333 0,0,0,0,0,
1334 0,0,0,0,0,
1335 0,0,0,0,0,
1336 0,0,0,0,0,
1337 0,0,0,0,0,
1338 0,0,0,0,0,
1339 0,0,"CONST","LRpost",0,
1340 0,0,0,0,0,
1341 0,0,0,0,0,
1342 0,0,0,0,0,
1343 0,0,0,0,0,
1344 0,0,0,0,0,
1345 0,0,0,0,0,
1346 0,0,0,0,0,
1347 0,0,0,0,0,
1348 0,0,0,0,0,
1349 0,0,0,0,"ID",
1350 0,0,0,0,0,
1351 0,0,0,0,0,
1352 0,0,0,0,0,
1353 0,0,0,0,0,
1354 0,0,0,0,0,
1355 0,0,0,0,0,
1356 0,0,0,0,0,
1357 0,0,0,0,0,
1358 0,0,0,0,0,
1359 0,0,0,0,0,
1360 0,0,0,0,0,
1361 0,0,0,0,0,
1362 0,0,0,0,0,
1363 0,0,0,0,0,
1364 0,0,0,0,0,
1365 0,0,0,0,0,
1366 0,0,0,0,0,
1367 0,0,0,0,0,
1368 0,0,0,0,0,
1369 0,0,0,0,0,
1370 0,0,0,0,0,
1371 0,0,0,0,0,
1372 0,0,0,0,0,
1373 0,0,0,0,0,
1374 0,0,0,0,0,
1375 0,0,0,0,0,
1376 0,0,0,0,0,
1377 0,0,0,0,0,
1378 0,0,0,0,0,
1379 0,0,0,0,0,
1380 0,0,0,0,0,
1381 0,0,0,0,0,
1382 0,0,0,0,0,
1383 0,0,0,0,0,
1384 0,0,0,0,0,
1385 0,0,0,0,0,
1386 0,0,0,0,0,
1387 0,0,0,0,0,
1388 0,0,0,0,0,
1389 0,0,0,0,0,
1390 0,0,0,0,0,
1391 0,0,0,0,0,
1392 0,0,0,0,0,
1393 0,0,0,0,0,
1394 0,0,0,0,0,
1395 0,0,0,0,0,
1396 0,0,0,0,0,
1397 0,0,0,0,0,
1398 0,0,0,0,0,
1399 0,0,0,0,0,
1400 0,0,0,0,0,
1401 0,0,0,0,0,
1402 0,0,0,0,0,
1403 0,0,0,0,0,
1404 0,0,0,0,0,
1405 0,0,0,0,0,
1406 0,0,0,0,0,
1407 0,0,0,0,0,
1408 0,0,0,0,0,
1409 0,0,0,0,0,
1410 0,0,0,0,0,
1411 0,0,0,0,0,
1412 0,0,0,0,0,
1413 0,0,0,0,0,
1414 0,0,0,0,0,
1415 0,0,0,0,0,
1416 0,0,0,0,0,
1417 0,0,0,0,0,
1418 0,0,0,0,0,
1419 0,0,0,0,0,
1420 0,0,0,0,0,
1421 0,0,0,0,0,
1422 0,0,0,0,0,
1423 0,0,0,0,0,
1424 0,0,0,0,0,
1425 0,0,0,0,0,
1426 0,0,0,0,0,
1427 0,0,0,0,0,
1428 0,0,0,0,0,
1429 0,0,0,0,0,
1430 0,0,0,0,0,
1431 0,0,0,0,0,
1432 0,0,0,0,0,
1433 0,0,0,0,0,
1434 0,0,0,0,0,
1435 0,0,0,0,0,
1436 0,0,0,0,0,
1437 0,0,0,0,0,
1438 0,0,0,0,0,
1439 0,0,0,0,0,
1440 0,0,0,0,0,
1441 0,0,0,0,0,
1442 0,0,0,0,0,
1443 0,0,0,0,0,
1444 0,0,0,0,0,
1445 0,0,0,0,0,
1446 0,0,0,0,0,
1447 0,0,0,0,0,
1448 0,0,0,0,0,
1449 0,0,0,0,0,
1450 0,0,0,0,0,
1451 0,0,0,0,0,
1452 0,0,0,0,0,
1453 0,0,0,0,0,
1454 0,0,0,0,0,
1455 0,0,0,0,0,
1456 0,0,0,0,0,
1457 0,0,0,0,0,
1458 0,0,0,0,0,
1459 0,0,0,0,0,
1460 0,0,0,0,0,
1461 0,0,0,0,0,
1462 0,0,0,0,0,
1463 0,0,0,0,0,
1464 0,0,0,0,0,
1465 0,0,0,0,0,
1466 0,0,0,0,0,
1467 0,0,0,0,0,
1468 0,0,0,0,0,
1469 0,0,0,0,0,
1470 0,0,0,0,0,
1471 0,0,0,0,0,
1472 0,
1473 };
1474
1475
1476
1477 #define yyySizeofProd(num) (yyyProdsInd[(num)+1] - yyyProdsInd[(num)])
1478
1479 #define yyyGSoccurStr(prodNum,symPos) \
1480    (yyyStringTab[yyyProds[yyyProdsInd[(prodNum)] + (symPos)][0]])
1481
1482 #define yyySizeofSort(num) (yyySortsInd[(num)+1] - yyySortsInd[(num)])
1483
1484 #define yyySortOf(prodNum,symPos) \
1485   (yyyProds[yyyProdsInd[(prodNum)] + (symPos)][1])
1486
1487 #define yyyAttrbStr(prodNum,symPos,attrbNum)                      \
1488   (yyyStringTab[yyySorts[yyySortsInd[yyySortOf(prodNum,symPos)] + \
1489                          (attrbNum)                               \
1490                         ]                                         \
1491                ]                                                  \
1492   )
1493
1494
1495
1496 void yyyShowProd(int i)
1497   {int j,nSyms;
1498
1499    nSyms = yyySizeofProd(i);
1500    for (j=0; j<nSyms; j++)
1501      {
1502       fprintf(stderr,"%s",yyyGSoccurStr(i,j));
1503       if (j == 0) fputs(" : ",stderr); else putc(' ',stderr);
1504      }
1505    fputs(";\n",stderr);
1506   }
1507
1508
1509
1510 void yyyShowProds()
1511   {int i; for (i=1; i<=yyyLastProdNum; i++) yyyShowProd(i);}
1512
1513
1514
1515 void yyyShowSymsAndSorts()
1516   {int i;
1517
1518    for (i=1; i<=yyyLastProdNum; i++)
1519      {int j, nSyms;
1520
1521       fprintf(stderr,
1522               "\n\n\n---------------------------------- %3.1d\n",i);
1523       /* yyyShowProd(i); */
1524       nSyms = yyySizeofProd(i);
1525       for (j=0; j<nSyms; j++)
1526         {int k, sortSize;
1527
1528          fprintf(stderr,"%s\n",yyyGSoccurStr(i,j));
1529          sortSize = yyySizeofSort(yyySortOf(i,j));
1530          for (k=0; k<sortSize; k++)
1531             fprintf(stderr,"  %s\n",yyyAttrbStr(i,j,k));
1532          if (j == 0) fputs("->\n",stderr);
1533               else
1534               putc('\n',stderr);
1535         }
1536      }
1537   }
1538
1539
1540
1541 void yyyCheckNodeInstancesSolved(yyyGNT *np)
1542   {int mysort,sortSize,i,prodNum,symPos,inTerminalNode;
1543    int nUnsolvedInsts = 0;
1544
1545    if (np->prodNum != 0)
1546      {inTerminalNode = 0;
1547       prodNum = np->prodNum;
1548       symPos = 0;
1549      }
1550    else
1551      {inTerminalNode = 1;
1552       prodNum = np->parent.noderef->prodNum;
1553       symPos = np->whichSym;
1554      }
1555    mysort = yyySortOf(prodNum,symPos);
1556    sortSize = yyySizeofSort(mysort);
1557    for (i=0; i<sortSize; i++)
1558      if ((np->refCountList)[i] != 0) nUnsolvedInsts += 1;
1559    if (nUnsolvedInsts)
1560      {fprintf(stderr,
1561       "\nFound node that has %d unsolved attribute instance(s).\n",
1562               nUnsolvedInsts
1563              );
1564       fprintf(stderr,"Node is labeled \"%s\".\n",
1565              yyyGSoccurStr(prodNum,symPos));
1566       if (inTerminalNode)
1567         {fputs("Node is terminal.  Its parent production is:\n  ",stderr);
1568          yyyShowProd(prodNum);
1569         }
1570       else
1571         {fputs("Node is nonterminal.  ",stderr);
1572          if (!(np->parentIsStack))
1573            {fprintf(stderr,
1574                     "Node is %dth child in its parent production:\n  ",
1575                    np->whichSym
1576                   );
1577             yyyShowProd(np->parent.noderef->prodNum);
1578            }
1579          fputs("Node is on left hand side of this production:\n  ",stderr);
1580          yyyShowProd(np->prodNum);
1581         }
1582       fputs("The following instances are unsolved:\n",stderr);
1583       for (i=0; i<sortSize; i++)
1584         if ((np->refCountList)[i] != 0)
1585           fprintf(stderr,"     %-16s still has %1d dependencies.\n",
1586                   yyyAttrbStr(prodNum,symPos,i),(np->refCountList)[i]);
1587      }
1588   }
1589
1590
1591
1592 void yyyCheckUnsolvedInstTrav(yyyGNT *pNode,long *nNZrc,long *cycleSum)
1593   {yyyGNT **yyyCLpdum;
1594    yyyRCT *rcp;
1595    int i;
1596
1597    /* visit the refCountList of each node in the tree, and sum the non-zero refCounts */
1598    rcp = pNode->refCountList;
1599    i = pNode->refCountListLen;
1600    while (i--)
1601       if (*rcp++) {*cycleSum += *(rcp - 1); (*nNZrc)++;}
1602    yyyCLpdum = pNode->cL;
1603    i = pNode->cLlen;
1604    while (i--)
1605      {
1606       yyyCheckUnsolvedInstTrav(*yyyCLpdum,nNZrc,cycleSum);
1607       yyyCLpdum++;
1608      }
1609   }
1610
1611
1612
1613 void yyyUnsolvedInstSearchTravAux(yyyGNT *pNode)
1614   {yyyGNT **yyyCLpdum;
1615    int i;
1616
1617    yyyCheckNodeInstancesSolved(pNode);
1618    yyyCLpdum = pNode->cL;
1619    i = pNode->cLlen;
1620    while (i--)
1621      {
1622       yyyUnsolvedInstSearchTravAux(*yyyCLpdum);
1623       yyyCLpdum++;
1624      }
1625   }
1626
1627
1628
1629 void yyyUnsolvedInstSearchTrav(yyyGNT *pNode)
1630   {yyyGNT **yyyCLpdum;
1631    int i;
1632
1633    yyyCLpdum = pNode->cL;
1634    i = pNode->cLlen;
1635    while (i--)
1636      {
1637       yyyUnsolvedInstSearchTravAux(*yyyCLpdum);
1638       yyyCLpdum++;
1639      }
1640   }
1641
1642
1643
1644 #line 1645 "expr.oxout.tab.c"
1645
1646 #if YYDEBUG
1647 #include <stdio.h>      /* needed for printf */
1648 #endif
1649
1650 #include <stdlib.h>     /* needed for malloc, etc */
1651 #include <string.h>     /* needed for memset */
1652
1653 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
1654 static int yygrowstack(YYSTACKDATA *data)
1655 {
1656     int i;
1657     unsigned newsize;
1658     YYINT *newss;
1659     YYSTYPE *newvs;
1660
1661     if ((newsize = data->stacksize) == 0)
1662         newsize = YYINITSTACKSIZE;
1663     else if (newsize >= YYMAXDEPTH)
1664         return YYENOMEM;
1665     else if ((newsize *= 2) > YYMAXDEPTH)
1666         newsize = YYMAXDEPTH;
1667
1668     i = (int) (data->s_mark - data->s_base);
1669     newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
1670     if (newss == 0)
1671         return YYENOMEM;
1672
1673     data->s_base = newss;
1674     data->s_mark = newss + i;
1675
1676     newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
1677     if (newvs == 0)
1678         return YYENOMEM;
1679
1680     data->l_base = newvs;
1681     data->l_mark = newvs + i;
1682
1683     data->stacksize = newsize;
1684     data->s_last = data->s_base + newsize - 1;
1685     return 0;
1686 }
1687
1688 #if YYPURE || defined(YY_NO_LEAKS)
1689 static void yyfreestack(YYSTACKDATA *data)
1690 {
1691     free(data->s_base);
1692     free(data->l_base);
1693     memset(data, 0, sizeof(*data));
1694 }
1695 #else
1696 #define yyfreestack(data) /* nothing */
1697 #endif
1698
1699 #define YYABORT  goto yyabort
1700 #define YYREJECT goto yyabort
1701 #define YYACCEPT goto yyaccept
1702 #define YYERROR  goto yyerrlab
1703
1704 int
1705 YYPARSE_DECL()
1706 {
1707     int yym, yyn, yystate;
1708 #if YYDEBUG
1709     const char *yys;
1710
1711     if ((yys = getenv("YYDEBUG")) != 0)
1712     {
1713         yyn = *yys;
1714         if (yyn >= '0' && yyn <= '9')
1715             yydebug = yyn - '0';
1716     }
1717 #endif
1718
1719     yym = 0;
1720     yyn = 0;
1721     yynerrs = 0;
1722     yyerrflag = 0;
1723     yychar = YYEMPTY;
1724     yystate = 0;
1725
1726 #if YYPURE
1727     memset(&yystack, 0, sizeof(yystack));
1728 #endif
1729
1730     if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1731     yystack.s_mark = yystack.s_base;
1732     yystack.l_mark = yystack.l_base;
1733     yystate = 0;
1734     *yystack.s_mark = 0;
1735
1736 yyloop:
1737     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
1738     if (yychar < 0)
1739     {
1740         yychar = YYLEX;
1741         if (yychar < 0) yychar = YYEOF;
1742 #if YYDEBUG
1743         if (yydebug)
1744         {
1745             if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1746             printf("%sdebug: state %d, reading %d (%s)\n",
1747                     YYPREFIX, yystate, yychar, yys);
1748         }
1749 #endif
1750     }
1751     if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1752             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1753     {
1754 #if YYDEBUG
1755         if (yydebug)
1756             printf("%sdebug: state %d, shifting to state %d\n",
1757                     YYPREFIX, yystate, yytable[yyn]);
1758 #endif
1759         if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1760         yystate = yytable[yyn];
1761         *++yystack.s_mark = yytable[yyn];
1762         *++yystack.l_mark = yylval;
1763         yychar = YYEMPTY;
1764         if (yyerrflag > 0)  --yyerrflag;
1765         goto yyloop;
1766     }
1767     if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1768             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1769     {
1770         yyn = yytable[yyn];
1771         goto yyreduce;
1772     }
1773     if (yyerrflag != 0) goto yyinrecovery;
1774
1775     YYERROR_CALL("syntax error");
1776
1777     goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1778 yyerrlab:
1779     ++yynerrs;
1780
1781 yyinrecovery:
1782     if (yyerrflag < 3)
1783     {
1784         yyerrflag = 3;
1785         for (;;)
1786         {
1787             if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1788                     yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1789             {
1790 #if YYDEBUG
1791                 if (yydebug)
1792                     printf("%sdebug: state %d, error recovery shifting\
1793  to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
1794 #endif
1795                 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1796                 yystate = yytable[yyn];
1797                 *++yystack.s_mark = yytable[yyn];
1798                 *++yystack.l_mark = yylval;
1799                 goto yyloop;
1800             }
1801             else
1802             {
1803 #if YYDEBUG
1804                 if (yydebug)
1805                     printf("%sdebug: error recovery discarding state %d\n",
1806                             YYPREFIX, *yystack.s_mark);
1807 #endif
1808                 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1809                 --yystack.s_mark;
1810                 --yystack.l_mark;
1811             }
1812         }
1813     }
1814     else
1815     {
1816         if (yychar == YYEOF) goto yyabort;
1817 #if YYDEBUG
1818         if (yydebug)
1819         {
1820             if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1821             printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
1822                     YYPREFIX, yystate, yychar, yys);
1823         }
1824 #endif
1825         yychar = YYEMPTY;
1826         goto yyloop;
1827     }
1828
1829 yyreduce:
1830 #if YYDEBUG
1831     if (yydebug)
1832         printf("%sdebug: state %d, reducing by rule %d (%s)\n",
1833                 YYPREFIX, yystate, yyn, yyrule[yyn]);
1834 #endif
1835     yym = yylen[yyn];
1836     if (yym > 0)
1837         yyval = yystack.l_mark[1-yym];
1838     else
1839         memset(&yyval, 0, sizeof yyval);
1840
1841     switch (yyn)
1842     {
1843 case 1:
1844 #line 64 "expr.oxout.y"
1845         {yyyYoxInit();}
1846 break;
1847 case 2:
1848 #line 66 "expr.oxout.y"
1849         {
1850                  yyyDecorate(); yyyExecuteRRsection(yystack.l_mark[0].yyyOxAttrbs.yyyOxStackItem->node);
1851                 }
1852 break;
1853 case 3:
1854 #line 73 "expr.oxout.y"
1855         {if(yyyYok){
1856 yyyGenIntNode(1,1,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
1857 yyyAdjustINRC(1,1,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
1858 break;
1859 case 4:
1860 #line 80 "expr.oxout.y"
1861         {if(yyyYok){
1862 yyyGenIntNode(2,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
1863 yyyAdjustINRC(2,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
1864 break;
1865 case 5:
1866 #line 87 "expr.oxout.y"
1867         {if(yyyYok){
1868 yyyGenIntNode(3,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
1869 yyyAdjustINRC(3,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
1870 break;
1871 case 6:
1872 #line 94 "expr.oxout.y"
1873         {if(yyyYok){
1874 yyyGenIntNode(4,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
1875 yyyAdjustINRC(4,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
1876 break;
1877 case 7:
1878 #line 101 "expr.oxout.y"
1879         {if(yyyYok){
1880 yyyGenIntNode(5,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
1881 yyyAdjustINRC(5,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
1882 break;
1883 case 8:
1884 #line 108 "expr.oxout.y"
1885         {if(yyyYok){
1886 yyyGenIntNode(6,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
1887 yyyAdjustINRC(6,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
1888 break;
1889 case 9:
1890 #line 114 "expr.oxout.y"
1891         {if(yyyYok){
1892 yyyGenIntNode(7,1,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
1893 yyyAdjustINRC(7,1,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
1894 break;
1895 case 10:
1896 #line 121 "expr.oxout.y"
1897         {if(yyyYok){
1898 yyyGenIntNode(8,1,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
1899 yyyAdjustINRC(8,1,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
1900 break;
1901 #line 1902 "expr.oxout.tab.c"
1902     }
1903     yystack.s_mark -= yym;
1904     yystate = *yystack.s_mark;
1905     yystack.l_mark -= yym;
1906     yym = yylhs[yyn];
1907     if (yystate == 0 && yym == 0)
1908     {
1909 #if YYDEBUG
1910         if (yydebug)
1911             printf("%sdebug: after reduction, shifting from state 0 to\
1912  state %d\n", YYPREFIX, YYFINAL);
1913 #endif
1914         yystate = YYFINAL;
1915         *++yystack.s_mark = YYFINAL;
1916         *++yystack.l_mark = yyval;
1917         if (yychar < 0)
1918         {
1919             yychar = YYLEX;
1920             if (yychar < 0) yychar = YYEOF;
1921 #if YYDEBUG
1922             if (yydebug)
1923             {
1924                 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1925                 printf("%sdebug: state %d, reading %d (%s)\n",
1926                         YYPREFIX, YYFINAL, yychar, yys);
1927             }
1928 #endif
1929         }
1930         if (yychar == YYEOF) goto yyaccept;
1931         goto yyloop;
1932     }
1933     if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1934             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1935         yystate = yytable[yyn];
1936     else
1937         yystate = yydgoto[yym];
1938 #if YYDEBUG
1939     if (yydebug)
1940         printf("%sdebug: after reduction, shifting from state %d \
1941 to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
1942 #endif
1943     if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1944     *++yystack.s_mark = (YYINT) yystate;
1945     *++yystack.l_mark = yyval;
1946     goto yyloop;
1947
1948 yyoverflow:
1949     YYERROR_CALL("yacc stack overflow");
1950
1951 yyabort:
1952     yyfreestack(&yystack);
1953     return (1);
1954
1955 yyaccept:
1956     yyfreestack(&yystack);
1957     return (0);
1958 }