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