Return to cgram.c CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / lib / fpcc

Annotation of cci/usr/src/lib/fpcc/cgram.c, revision 1.1

1.1     ! root        1: # define NAME 2
        !             2: # define STRING 3
        !             3: # define ICON 4
        !             4: # define FCON 5
        !             5: # define PLUS 6
        !             6: # define MINUS 8
        !             7: # define MUL 11
        !             8: # define AND 14
        !             9: # define OR 17
        !            10: # define ER 19
        !            11: # define QUEST 21
        !            12: # define COLON 22
        !            13: # define ANDAND 23
        !            14: # define OROR 24
        !            15: # define ASOP 25
        !            16: # define RELOP 26
        !            17: # define EQUOP 27
        !            18: # define DIVOP 28
        !            19: # define SHIFTOP 29
        !            20: # define INCOP 30
        !            21: # define UNOP 31
        !            22: # define STROP 32
        !            23: # define TYPE 33
        !            24: # define CLASS 34
        !            25: # define STRUCT 35
        !            26: # define RETURN 36
        !            27: # define GOTO 37
        !            28: # define IF 38
        !            29: # define ELSE 39
        !            30: # define SWITCH 40
        !            31: # define BREAK 41
        !            32: # define CONTINUE 42
        !            33: # define WHILE 43
        !            34: # define DO 44
        !            35: # define FOR 45
        !            36: # define DEFAULT 46
        !            37: # define CASE 47
        !            38: # define SIZEOF 48
        !            39: # define ENUM 49
        !            40: # define LP 50
        !            41: # define RP 51
        !            42: # define LC 52
        !            43: # define RC 53
        !            44: # define LB 54
        !            45: # define RB 55
        !            46: # define CM 56
        !            47: # define SM 57
        !            48: # define ASSIGN 58
        !            49: # define ASM 59
        !            50: 
        !            51: # line 109 "../fmip/cgram.y"
        !            52: # include "mfile1"
        !            53: #define yyclearin yychar = -1
        !            54: #define yyerrok yyerrflag = 0
        !            55: extern int yychar;
        !            56: extern short yyerrflag;
        !            57: #ifndef YYMAXDEPTH
        !            58: #define YYMAXDEPTH 150
        !            59: #endif
        !            60: YYSTYPE yylval, yyval;
        !            61: 
        !            62: # line 128 "../fmip/cgram.y"
        !            63:        static int fake = 0;
        !            64: #ifndef FLEXNAMES
        !            65:        static char fakename[NCHNAM+1];
        !            66: #else
        !            67:        static char fakename[24];
        !            68: #endif
        !            69: # define YYERRCODE 256
        !            70: 
        !            71: # line 852 "../fmip/cgram.y"
        !            72: 
        !            73: 
        !            74: NODE *
        !            75: mkty( t, d, s ) unsigned t; {
        !            76:        return( block( TYPE, NIL, NIL, t, d, s ) );
        !            77:        }
        !            78: 
        !            79: NODE *
        !            80: bdty( op, p, v ) NODE *p; {
        !            81:        register NODE *q;
        !            82: 
        !            83:        q = block( op, p, NIL, INT, 0, INT );
        !            84: 
        !            85:        switch( op ){
        !            86: 
        !            87:        case UNARY MUL:
        !            88:        case UNARY CALL:
        !            89:                break;
        !            90: 
        !            91:        case LB:
        !            92:                q->in.right = bcon(v);
        !            93:                break;
        !            94: 
        !            95:        case NAME:
        !            96:                q->tn.rval = v;
        !            97:                break;
        !            98: 
        !            99:        default:
        !           100:                cerror( "bad bdty" );
        !           101:                }
        !           102: 
        !           103:        return( q );
        !           104:        }
        !           105: 
        !           106: dstash( n ){ /* put n into the dimension table */
        !           107:        if( curdim >= DIMTABSZ-1 ){
        !           108:                cerror( "dimension table overflow");
        !           109:                }
        !           110:        dimtab[ curdim++ ] = n;
        !           111:        }
        !           112: 
        !           113: savebc() {
        !           114:        if( psavbc > & asavbc[BCSZ-4 ] ){
        !           115:                cerror( "whiles, fors, etc. too deeply nested");
        !           116:                }
        !           117:        *psavbc++ = brklab;
        !           118:        *psavbc++ = contlab;
        !           119:        *psavbc++ = flostat;
        !           120:        *psavbc++ = swx;
        !           121:        flostat = 0;
        !           122:        }
        !           123: 
        !           124: resetbc(mask){
        !           125: 
        !           126:        swx = *--psavbc;
        !           127:        flostat = *--psavbc | (flostat&mask);
        !           128:        contlab = *--psavbc;
        !           129:        brklab = *--psavbc;
        !           130: 
        !           131:        }
        !           132: 
        !           133: addcase(p) NODE *p; { /* add case to switch */
        !           134: 
        !           135:        p = optim( p );  /* change enum to ints */
        !           136:        if( p->in.op != ICON ){
        !           137:                uerror( "non-constant case expression");
        !           138:                return;
        !           139:                }
        !           140:        if( swp == swtab ){
        !           141:                uerror( "case not in switch");
        !           142:                return;
        !           143:                }
        !           144:        if( swp >= &swtab[SWITSZ] ){
        !           145:                cerror( "switch table overflow");
        !           146:                }
        !           147:        swp->sval = p->tn.lval;
        !           148:        deflab( swp->slab = getlab() );
        !           149:        ++swp;
        !           150:        tfree(p);
        !           151:        }
        !           152: 
        !           153: adddef(){ /* add default case to switch */
        !           154:        if( swtab[swx].slab >= 0 ){
        !           155:                uerror( "duplicate default in switch");
        !           156:                return;
        !           157:                }
        !           158:        if( swp == swtab ){
        !           159:                uerror( "default not inside switch");
        !           160:                return;
        !           161:                }
        !           162:        deflab( swtab[swx].slab = getlab() );
        !           163:        }
        !           164: 
        !           165: swstart(){
        !           166:        /* begin a switch block */
        !           167:        if( swp >= &swtab[SWITSZ] ){
        !           168:                cerror( "switch table overflow");
        !           169:                }
        !           170:        swx = swp - swtab;
        !           171:        swp->slab = -1;
        !           172:        ++swp;
        !           173:        }
        !           174: 
        !           175: swend(){ /* end a switch block */
        !           176: 
        !           177:        register struct sw *swbeg, *p, *q, *r, *r1;
        !           178:        CONSZ temp;
        !           179:        int tempi;
        !           180: 
        !           181:        swbeg = &swtab[swx+1];
        !           182: 
        !           183:        /* sort */
        !           184: 
        !           185:        r1 = swbeg;
        !           186:        r = swp-1;
        !           187: 
        !           188:        while( swbeg < r ){
        !           189:                /* bubble largest to end */
        !           190:                for( q=swbeg; q<r; ++q ){
        !           191:                        if( q->sval > (q+1)->sval ){
        !           192:                                /* swap */
        !           193:                                r1 = q+1;
        !           194:                                temp = q->sval;
        !           195:                                q->sval = r1->sval;
        !           196:                                r1->sval = temp;
        !           197:                                tempi = q->slab;
        !           198:                                q->slab = r1->slab;
        !           199:                                r1->slab = tempi;
        !           200:                                }
        !           201:                        }
        !           202:                r = r1;
        !           203:                r1 = swbeg;
        !           204:                }
        !           205: 
        !           206:        /* it is now sorted */
        !           207: 
        !           208:        for( p = swbeg+1; p<swp; ++p ){
        !           209:                if( p->sval == (p-1)->sval ){
        !           210:                        uerror( "duplicate case in switch, %d", tempi=p->sval );
        !           211:                        return;
        !           212:                        }
        !           213:                }
        !           214: 
        !           215:        genswitch( swbeg-1, swp-swbeg );
        !           216:        swp = swbeg-1;
        !           217:        }
        !           218: extern short  yyexca[];
        !           219: # define YYNPROD 189
        !           220: # define YYLAST 1249
        !           221: extern short  yyact[];
        !           222: extern short  yypact[];
        !           223: extern short  yypgo[];
        !           224: extern short  yyr1[];
        !           225: extern short  yyr2[];
        !           226: extern short  yychk[];
        !           227: extern short  yydef[];
        !           228: #ifndef lint
        !           229: static char yaccpar_sccsid[] = "@(#)yaccpar    4.1     (Berkeley)      2/11/83";
        !           230: #endif not lint
        !           231: 
        !           232: #
        !           233: # define YYFLAG -1000
        !           234: # define YYERROR goto yyerrlab
        !           235: # define YYACCEPT return(0)
        !           236: # define YYABORT return(1)
        !           237: 
        !           238: /*     parser for yacc output  */
        !           239: 
        !           240: #ifdef YYDEBUG
        !           241: int yydebug = 0; /* 1 for debugging */
        !           242: #endif
        !           243: YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
        !           244: int yychar = -1; /* current input token number */
        !           245: int yynerrs = 0;  /* number of errors */
        !           246: short yyerrflag = 0;  /* error recovery flag */
        !           247: 
        !           248: yyparse() {
        !           249: 
        !           250:        short yys[YYMAXDEPTH];
        !           251:        short yyj, yym;
        !           252:        register YYSTYPE *yypvt;
        !           253:        register short yystate, *yyps, yyn;
        !           254:        register YYSTYPE *yypv;
        !           255:        register short *yyxi;
        !           256: 
        !           257:        yystate = 0;
        !           258:        yychar = -1;
        !           259:        yynerrs = 0;
        !           260:        yyerrflag = 0;
        !           261:        yyps= &yys[-1];
        !           262:        yypv= &yyv[-1];
        !           263: 
        !           264:  yystack:    /* put a state and value onto the stack */
        !           265: 
        !           266: #ifdef YYDEBUG
        !           267:        if( yydebug  ) printf( "state %d, char 0%o\n", yystate, yychar );
        !           268: #endif
        !           269:                if( ++yyps> &yys[YYMAXDEPTH] ) { yyerror( "yacc stack overflow" ); return(1); }
        !           270:                *yyps = yystate;
        !           271:                ++yypv;
        !           272:                *yypv = yyval;
        !           273: 
        !           274:  yynewstate:
        !           275: 
        !           276:        yyn = yypact[yystate];
        !           277: 
        !           278:        if( yyn<= YYFLAG ) goto yydefault; /* simple state */
        !           279: 
        !           280:        if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0;
        !           281:        if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault;
        !           282: 
        !           283:        if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
        !           284:                yychar = -1;
        !           285:                yyval = yylval;
        !           286:                yystate = yyn;
        !           287:                if( yyerrflag > 0 ) --yyerrflag;
        !           288:                goto yystack;
        !           289:                }
        !           290: 
        !           291:  yydefault:
        !           292:        /* default state action */
        !           293: 
        !           294:        if( (yyn=yydef[yystate]) == -2 ) {
        !           295:                if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0;
        !           296:                /* look through exception table */
        !           297: 
        !           298:                for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */
        !           299: 
        !           300:                while( *(yyxi+=2) >= 0 ){
        !           301:                        if( *yyxi == yychar ) break;
        !           302:                        }
        !           303:                if( (yyn = yyxi[1]) < 0 ) return(0);   /* accept */
        !           304:                }
        !           305: 
        !           306:        if( yyn == 0 ){ /* error */
        !           307:                /* error ... attempt to resume parsing */
        !           308: 
        !           309:                switch( yyerrflag ){
        !           310: 
        !           311:                case 0:   /* brand new error */
        !           312: 
        !           313:                        yyerror( "syntax error" );
        !           314:                yyerrlab:
        !           315:                        ++yynerrs;
        !           316: 
        !           317:                case 1:
        !           318:                case 2: /* incompletely recovered error ... try again */
        !           319: 
        !           320:                        yyerrflag = 3;
        !           321: 
        !           322:                        /* find a state where "error" is a legal shift action */
        !           323: 
        !           324:                        while ( yyps >= yys ) {
        !           325:                           yyn = yypact[*yyps] + YYERRCODE;
        !           326:                           if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
        !           327:                              yystate = yyact[yyn];  /* simulate a shift of "error" */
        !           328:                              goto yystack;
        !           329:                              }
        !           330:                           yyn = yypact[*yyps];
        !           331: 
        !           332:                           /* the current yyps has no shift onn "error", pop stack */
        !           333: 
        !           334: #ifdef YYDEBUG
        !           335:                           if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
        !           336: #endif
        !           337:                           --yyps;
        !           338:                           --yypv;
        !           339:                           }
        !           340: 
        !           341:                        /* there is no state on the stack with an error shift ... abort */
        !           342: 
        !           343:        yyabort:
        !           344:                        return(1);
        !           345: 
        !           346: 
        !           347:                case 3:  /* no shift yet; clobber input char */
        !           348: 
        !           349: #ifdef YYDEBUG
        !           350:                        if( yydebug ) printf( "error recovery discards char %d\n", yychar );
        !           351: #endif
        !           352: 
        !           353:                        if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
        !           354:                        yychar = -1;
        !           355:                        goto yynewstate;   /* try again in the same state */
        !           356: 
        !           357:                        }
        !           358: 
        !           359:                }
        !           360: 
        !           361:        /* reduction by production yyn */
        !           362: 
        !           363: #ifdef YYDEBUG
        !           364:                if( yydebug ) printf("reduce %d\n",yyn);
        !           365: #endif
        !           366:                yyps -= yyr2[yyn];
        !           367:                yypvt = yypv;
        !           368:                yypv -= yyr2[yyn];
        !           369:                yyval = yypv[1];
        !           370:                yym=yyn;
        !           371:                        /* consult goto table to find next state */
        !           372:                yyn = yyr1[yyn];
        !           373:                yyj = yypgo[yyn] + *yyps + 1;
        !           374:                if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
        !           375:                switch(yym){
        !           376:                        
        !           377: case 2:
        !           378: # line 138 "../fmip/cgram.y"
        !           379: { beg_file();  /* do implementation dep. stuff now */
        !           380:                           ftnend(); } break;
        !           381: case 3:
        !           382: # line 142 "../fmip/cgram.y"
        !           383: { curclass = SNULL;  blevel = 0; } break;
        !           384: case 4:
        !           385: # line 144 "../fmip/cgram.y"
        !           386: {
        !           387:                                asmout();
        !           388:                                curclass = SNULL;
        !           389:                                blevel = 0;
        !           390:                        } break;
        !           391: case 5:
        !           392: # line 150 "../fmip/cgram.y"
        !           393: { curclass = SNULL;  blevel = 0; } break;
        !           394: case 6:
        !           395: # line 154 "../fmip/cgram.y"
        !           396: {  yypvt[-1].nodep->in.op = FREE; } break;
        !           397: case 7:
        !           398: # line 156 "../fmip/cgram.y"
        !           399: {  yypvt[-2].nodep->in.op = FREE; } break;
        !           400: case 8:
        !           401: # line 157 "../fmip/cgram.y"
        !           402: {
        !           403:                                defid( tymerge(yypvt[-1].nodep,yypvt[-0].nodep), curclass==STATIC?STATIC:EXTDEF );
        !           404: #ifndef LINT
        !           405:                                pfstab(stab[yypvt[-0].nodep->tn.rval].sname);
        !           406: #endif
        !           407:                                } break;
        !           408: case 9:
        !           409: # line 163 "../fmip/cgram.y"
        !           410: {  
        !           411:                            if( blevel ) cerror( "function level error" );
        !           412:                            if( reached ) retstat |= NRETVAL; 
        !           413:                            yypvt[-3].nodep->in.op = FREE;
        !           414:                            ftnend();
        !           415:                            } break;
        !           416: case 12:
        !           417: # line 174 "../fmip/cgram.y"
        !           418: {  blevel = 1; } break;
        !           419: case 14:
        !           420: # line 179 "../fmip/cgram.y"
        !           421: {  bccode();
        !           422:                            locctr(PROG);
        !           423:                            } break;
        !           424: case 15:
        !           425: # line 185 "../fmip/cgram.y"
        !           426: {  yypvt[-1].nodep->in.op = FREE; 
        !           427: #ifndef LINT
        !           428:                            plcstab(blevel);
        !           429: #endif
        !           430:                            } break;
        !           431: case 16:
        !           432: # line 191 "../fmip/cgram.y"
        !           433: {  yypvt[-2].nodep->in.op = FREE; 
        !           434: #ifndef LINT
        !           435:                            plcstab(blevel);
        !           436: #endif
        !           437:                            } break;
        !           438: case 17:
        !           439: # line 199 "../fmip/cgram.y"
        !           440: {  yypvt[-1].nodep->in.op = FREE; } break;
        !           441: case 18:
        !           442: # line 201 "../fmip/cgram.y"
        !           443: {  yypvt[-2].nodep->in.op = FREE; } break;
        !           444: case 20:
        !           445: # line 205 "../fmip/cgram.y"
        !           446: { curclass = SNULL;  yypvt[-2].nodep->in.op = FREE; } break;
        !           447: case 21:
        !           448: # line 207 "../fmip/cgram.y"
        !           449: { curclass = SNULL;  yypvt[-1].nodep->in.op = FREE; } break;
        !           450: case 22:
        !           451: # line 209 "../fmip/cgram.y"
        !           452: {  curclass = SNULL; } break;
        !           453: case 24:
        !           454: # line 213 "../fmip/cgram.y"
        !           455: {  yyval.nodep = mkty(INT,0,INT);  curclass = SNULL; } break;
        !           456: case 25:
        !           457: # line 216 "../fmip/cgram.y"
        !           458: {  yyval.nodep = yypvt[-0].nodep; } break;
        !           459: case 27:
        !           460: # line 219 "../fmip/cgram.y"
        !           461: {  yyval.nodep = mkty(INT,0,INT); } break;
        !           462: case 28:
        !           463: # line 221 "../fmip/cgram.y"
        !           464: { curclass = SNULL ; } break;
        !           465: case 29:
        !           466: # line 223 "../fmip/cgram.y"
        !           467: {  yypvt[-2].nodep->in.type = types( yypvt[-2].nodep->in.type, yypvt[-0].nodep->in.type, UNDEF );
        !           468:                            yypvt[-0].nodep->in.op = FREE;
        !           469:                            } break;
        !           470: case 30:
        !           471: # line 230 "../fmip/cgram.y"
        !           472: {  curclass = yypvt[-0].intval; } break;
        !           473: case 32:
        !           474: # line 235 "../fmip/cgram.y"
        !           475: {  yypvt[-1].nodep->in.type = types( yypvt[-1].nodep->in.type, yypvt[-0].nodep->in.type, UNDEF );
        !           476:                            yypvt[-0].nodep->in.op = FREE;
        !           477:                            } break;
        !           478: case 33:
        !           479: # line 239 "../fmip/cgram.y"
        !           480: {  yypvt[-2].nodep->in.type = types( yypvt[-2].nodep->in.type, yypvt[-1].nodep->in.type, yypvt[-0].nodep->in.type );
        !           481:                            yypvt[-1].nodep->in.op = yypvt[-0].nodep->in.op = FREE;
        !           482:                            } break;
        !           483: case 36:
        !           484: # line 247 "../fmip/cgram.y"
        !           485: { yyval.nodep = dclstruct(yypvt[-4].intval); } break;
        !           486: case 37:
        !           487: # line 249 "../fmip/cgram.y"
        !           488: {  yyval.nodep = rstruct(yypvt[-0].intval,0);  stwart = instruct; } break;
        !           489: case 38:
        !           490: # line 253 "../fmip/cgram.y"
        !           491: {  yyval.intval = bstruct(-1,0); stwart = SEENAME; } break;
        !           492: case 39:
        !           493: # line 255 "../fmip/cgram.y"
        !           494: {  yyval.intval = bstruct(yypvt[-0].intval,0); stwart = SEENAME; } break;
        !           495: case 42:
        !           496: # line 263 "../fmip/cgram.y"
        !           497: {  moedef( yypvt[-0].intval ); } break;
        !           498: case 43:
        !           499: # line 265 "../fmip/cgram.y"
        !           500: {  strucoff = yypvt[-0].intval;  moedef( yypvt[-2].intval ); } break;
        !           501: case 44:
        !           502: # line 269 "../fmip/cgram.y"
        !           503: { yyval.nodep = dclstruct(yypvt[-4].intval);  } break;
        !           504: case 45:
        !           505: # line 271 "../fmip/cgram.y"
        !           506: {  yyval.nodep = rstruct(yypvt[-0].intval,yypvt[-1].intval); } break;
        !           507: case 46:
        !           508: # line 275 "../fmip/cgram.y"
        !           509: {  yyval.intval = bstruct(-1,yypvt[-0].intval);  stwart=0; } break;
        !           510: case 47:
        !           511: # line 277 "../fmip/cgram.y"
        !           512: {  yyval.intval = bstruct(yypvt[-0].intval,yypvt[-1].intval);  stwart=0;  } break;
        !           513: case 50:
        !           514: # line 285 "../fmip/cgram.y"
        !           515: { curclass = SNULL;  stwart=0; yypvt[-1].nodep->in.op = FREE; } break;
        !           516: case 51:
        !           517: # line 287 "../fmip/cgram.y"
        !           518: {  if( curclass != MOU ){
        !           519:                                curclass = SNULL;
        !           520:                                }
        !           521:                            else {
        !           522:                                sprintf( fakename, "$%dFAKE", fake++ );
        !           523: #ifdef FLEXSTRINGS
        !           524:                                /* No need to hash this, we won't look it up */
        !           525:                                defid( tymerge(yypvt[-0].nodep, bdty(NAME,NIL,lookup( savestr(fakename), SMOS ))), curclass );
        !           526: #else
        !           527:                                defid( tymerge(yypvt[-0].nodep, bdty(NAME,NIL,lookup( fakename, SMOS ))), curclass );
        !           528: #endif
        !           529:                                werror("structure typed union member must be named");
        !           530:                                }
        !           531:                            stwart = 0;
        !           532:                            yypvt[-0].nodep->in.op = FREE;
        !           533:                            } break;
        !           534: case 52:
        !           535: # line 307 "../fmip/cgram.y"
        !           536: { defid( tymerge(yypvt[-1].nodep,yypvt[-0].nodep), curclass);  stwart = instruct; } break;
        !           537: case 53:
        !           538: # line 308 "../fmip/cgram.y"
        !           539: {yyval.nodep=yypvt[-2].nodep;} break;
        !           540: case 54:
        !           541: # line 309 "../fmip/cgram.y"
        !           542: { defid( tymerge(yypvt[-4].nodep,yypvt[-0].nodep), curclass);  stwart = instruct; } break;
        !           543: case 57:
        !           544: # line 315 "../fmip/cgram.y"
        !           545: {  if( !(instruct&INSTRUCT) ) uerror( "field outside of structure" );
        !           546:                            if( yypvt[-0].intval<0 || yypvt[-0].intval >= FIELD ){
        !           547:                                uerror( "illegal field size" );
        !           548:                                yypvt[-0].intval = 1;
        !           549:                                }
        !           550:                            defid( tymerge(yypvt[-3].nodep,yypvt[-2].nodep), FIELD|yypvt[-0].intval );
        !           551:                            yyval.nodep = NIL;
        !           552:                            } break;
        !           553: case 58:
        !           554: # line 325 "../fmip/cgram.y"
        !           555: {  if( !(instruct&INSTRUCT) ) uerror( "field outside of structure" );
        !           556:                            falloc( stab, yypvt[-0].intval, -1, yypvt[-2].nodep );  /* alignment or hole */
        !           557:                            yyval.nodep = NIL;
        !           558:                            } break;
        !           559: case 59:
        !           560: # line 330 "../fmip/cgram.y"
        !           561: {  yyval.nodep = NIL; } break;
        !           562: case 60:
        !           563: # line 335 "../fmip/cgram.y"
        !           564: {  umul:
        !           565:                                yyval.nodep = bdty( UNARY MUL, yypvt[-0].nodep, 0 ); } break;
        !           566: case 61:
        !           567: # line 338 "../fmip/cgram.y"
        !           568: {  uftn:
        !           569:                                yyval.nodep = bdty( UNARY CALL, yypvt[-2].nodep, 0 );  } break;
        !           570: case 62:
        !           571: # line 341 "../fmip/cgram.y"
        !           572: {  uary:
        !           573:                                yyval.nodep = bdty( LB, yypvt[-2].nodep, 0 );  } break;
        !           574: case 63:
        !           575: # line 344 "../fmip/cgram.y"
        !           576: {  bary:
        !           577:                                if( (int)yypvt[-1].intval <= 0 ) werror( "zero or negative subscript" );
        !           578:                                yyval.nodep = bdty( LB, yypvt[-3].nodep, yypvt[-1].intval );  } break;
        !           579: case 64:
        !           580: # line 348 "../fmip/cgram.y"
        !           581: {  yyval.nodep = bdty( NAME, NIL, yypvt[-0].intval );  } break;
        !           582: case 65:
        !           583: # line 350 "../fmip/cgram.y"
        !           584: { yyval.nodep=yypvt[-1].nodep; } break;
        !           585: case 66:
        !           586: # line 353 "../fmip/cgram.y"
        !           587: {  goto umul; } break;
        !           588: case 67:
        !           589: # line 355 "../fmip/cgram.y"
        !           590: {  goto uftn; } break;
        !           591: case 68:
        !           592: # line 357 "../fmip/cgram.y"
        !           593: {  goto uary; } break;
        !           594: case 69:
        !           595: # line 359 "../fmip/cgram.y"
        !           596: {  goto bary; } break;
        !           597: case 70:
        !           598: # line 361 "../fmip/cgram.y"
        !           599: { yyval.nodep = yypvt[-1].nodep; } break;
        !           600: case 71:
        !           601: # line 363 "../fmip/cgram.y"
        !           602: {
        !           603:                                if( blevel!=0 ) uerror("function declaration in bad context");
        !           604:                                yyval.nodep = bdty( UNARY CALL, bdty(NAME,NIL,yypvt[-2].intval), 0 );
        !           605:                                stwart = 0;
        !           606:                                } break;
        !           607: case 72:
        !           608: # line 369 "../fmip/cgram.y"
        !           609: {
        !           610:                                yyval.nodep = bdty( UNARY CALL, bdty(NAME,NIL,yypvt[-1].intval), 0 );
        !           611:                                stwart = 0;
        !           612:                                } break;
        !           613: case 73:
        !           614: # line 376 "../fmip/cgram.y"
        !           615: {
        !           616:                                /* turn off typedefs for argument names */
        !           617:                                stwart = SEENAME;
        !           618:                                if( stab[yypvt[-1].intval].sclass == SNULL )
        !           619:                                    stab[yypvt[-1].intval].stype = FTN;
        !           620:                                } break;
        !           621: case 74:
        !           622: # line 385 "../fmip/cgram.y"
        !           623: { ftnarg( yypvt[-0].intval );  stwart = SEENAME; } break;
        !           624: case 75:
        !           625: # line 387 "../fmip/cgram.y"
        !           626: { ftnarg( yypvt[-0].intval );  stwart = SEENAME; } break;
        !           627: case 78:
        !           628: # line 393 "../fmip/cgram.y"
        !           629: {yyval.nodep=yypvt[-2].nodep;} break;
        !           630: case 80:
        !           631: # line 397 "../fmip/cgram.y"
        !           632: {  defid( yypvt[-0].nodep = tymerge(yypvt[-1].nodep,yypvt[-0].nodep), curclass);
        !           633:                            beginit(yypvt[-0].nodep->tn.rval);
        !           634:                            } break;
        !           635: case 82:
        !           636: # line 404 "../fmip/cgram.y"
        !           637: {  nidcl( tymerge(yypvt[-1].nodep,yypvt[-0].nodep) ); } break;
        !           638: case 83:
        !           639: # line 406 "../fmip/cgram.y"
        !           640: {  defid( tymerge(yypvt[-1].nodep,yypvt[-0].nodep), uclass(curclass) );
        !           641:                        } break;
        !           642: case 84:
        !           643: # line 410 "../fmip/cgram.y"
        !           644: {  doinit( yypvt[-0].nodep );
        !           645:                            endinit(); } break;
        !           646: case 85:
        !           647: # line 413 "../fmip/cgram.y"
        !           648: {  endinit(); } break;
        !           649: case 89:
        !           650: # line 423 "../fmip/cgram.y"
        !           651: {  doinit( yypvt[-0].nodep ); } break;
        !           652: case 90:
        !           653: # line 425 "../fmip/cgram.y"
        !           654: {  irbrace(); } break;
        !           655: case 95:
        !           656: # line 437 "../fmip/cgram.y"
        !           657: {  werror( "old-fashioned initialization: use =" ); } break;
        !           658: case 97:
        !           659: # line 442 "../fmip/cgram.y"
        !           660: {  ilbrace(); } break;
        !           661: case 100:
        !           662: # line 452 "../fmip/cgram.y"
        !           663: {  
        !           664: #ifndef LINT
        !           665:                            prcstab(blevel);
        !           666: #endif
        !           667:                            --blevel;
        !           668:                            if( blevel == 1 ) blevel = 0;
        !           669:                            clearst( blevel );
        !           670:                            checkst( blevel );
        !           671:                            autooff = *--psavbc;
        !           672:                            regvar = *--psavbc;
        !           673:                            } break;
        !           674: case 101:
        !           675: # line 466 "../fmip/cgram.y"
        !           676: {  --blevel;
        !           677:                            if( blevel == 1 ) blevel = 0;
        !           678:                            clearst( blevel );
        !           679:                            checkst( blevel );
        !           680:                            autooff = *--psavbc;
        !           681:                            regvar = *--psavbc;
        !           682:                            } break;
        !           683: case 102:
        !           684: # line 476 "../fmip/cgram.y"
        !           685: {  if( blevel == 1 ) dclargs();
        !           686:                            ++blevel;
        !           687:                            if( psavbc > &asavbc[BCSZ-2] ) cerror( "nesting too deep" );
        !           688:                            *psavbc++ = regvar;
        !           689:                            *psavbc++ = autooff;
        !           690:                            } break;
        !           691: case 103:
        !           692: # line 485 "../fmip/cgram.y"
        !           693: { ecomp( yypvt[-1].nodep ); } break;
        !           694: case 104:
        !           695: # line 487 "../fmip/cgram.y"
        !           696: {
        !           697:                                asmout();
        !           698:                        } break;
        !           699: case 106:
        !           700: # line 492 "../fmip/cgram.y"
        !           701: { deflab(yypvt[-1].intval);
        !           702:                           reached = 1;
        !           703:                           } break;
        !           704: case 107:
        !           705: # line 496 "../fmip/cgram.y"
        !           706: {  if( yypvt[-1].intval != NOLAB ){
        !           707:                                deflab( yypvt[-1].intval );
        !           708:                                reached = 1;
        !           709:                                }
        !           710:                            } break;
        !           711: case 108:
        !           712: # line 502 "../fmip/cgram.y"
        !           713: {  branch(  contlab );
        !           714:                            deflab( brklab );
        !           715:                            if( (flostat&FBRK) || !(flostat&FLOOP)) reached = 1;
        !           716:                            else reached = 0;
        !           717:                            resetbc(0);
        !           718:                            } break;
        !           719: case 109:
        !           720: # line 509 "../fmip/cgram.y"
        !           721: {  deflab( contlab );
        !           722:                            if( flostat & FCONT ) reached = 1;
        !           723:                            ecomp( buildtree( CBRANCH, buildtree( NOT, yypvt[-2].nodep, NIL ), bcon( yypvt[-6].intval ) ) );
        !           724:                            deflab( brklab );
        !           725:                            reached = 1;
        !           726:                            resetbc(0);
        !           727:                            } break;
        !           728: case 110:
        !           729: # line 517 "../fmip/cgram.y"
        !           730: {  deflab( contlab );
        !           731:                            if( flostat&FCONT ) reached = 1;
        !           732:                            if( yypvt[-2].nodep ) ecomp( yypvt[-2].nodep );
        !           733:                            branch( yypvt[-3].intval );
        !           734:                            deflab( brklab );
        !           735:                            if( (flostat&FBRK) || !(flostat&FLOOP) ) reached = 1;
        !           736:                            else reached = 0;
        !           737:                            resetbc(0);
        !           738:                            } break;
        !           739: case 111:
        !           740: # line 527 "../fmip/cgram.y"
        !           741: {  if( reached ) branch( brklab );
        !           742:                            deflab( yypvt[-1].intval );
        !           743:                           swend();
        !           744:                            deflab(brklab);
        !           745:                            if( (flostat&FBRK) || !(flostat&FDEF) ) reached = 1;
        !           746:                            resetbc(FCONT);
        !           747:                            } break;
        !           748: case 112:
        !           749: # line 535 "../fmip/cgram.y"
        !           750: {  if( brklab == NOLAB ) uerror( "illegal break");
        !           751:                            else if(reached) branch( brklab );
        !           752:                            flostat |= FBRK;
        !           753:                            if( brkflag ) goto rch;
        !           754:                            reached = 0;
        !           755:                            } break;
        !           756: case 113:
        !           757: # line 542 "../fmip/cgram.y"
        !           758: {  if( contlab == NOLAB ) uerror( "illegal continue");
        !           759:                            else branch( contlab );
        !           760:                            flostat |= FCONT;
        !           761:                            goto rch;
        !           762:                            } break;
        !           763: case 114:
        !           764: # line 548 "../fmip/cgram.y"
        !           765: {  retstat |= NRETVAL;
        !           766:                            branch( retlab );
        !           767:                        rch:
        !           768:                            if( !reached ) werror( "statement not reached");
        !           769:                            reached = 0;
        !           770:                            } break;
        !           771: case 115:
        !           772: # line 555 "../fmip/cgram.y"
        !           773: {  register NODE *temp;
        !           774:                            idname = curftn;
        !           775:                            temp = buildtree( NAME, NIL, NIL );
        !           776:                            if(temp->in.type == TVOID)
        !           777:                                uerror("void function %s cannot return value",
        !           778:                                        stab[idname].sname);
        !           779:                            temp->in.type = DECREF( temp->in.type );
        !           780:                            temp = buildtree( RETURN, temp, yypvt[-1].nodep );
        !           781:                            /* now, we have the type of the RHS correct */
        !           782:                            temp->in.left->in.op = FREE;
        !           783:                            temp->in.op = FREE;
        !           784:                            ecomp( buildtree( FORCE, temp->in.right, NIL ) );
        !           785:                            retstat |= RETVAL;
        !           786:                            branch( retlab );
        !           787:                            reached = 0;
        !           788:                            } break;
        !           789: case 116:
        !           790: # line 572 "../fmip/cgram.y"
        !           791: {  register NODE *q;
        !           792:                            q = block( FREE, NIL, NIL, INT|ARY, 0, INT );
        !           793:                            q->tn.rval = idname = yypvt[-1].intval;
        !           794:                            defid( q, ULABEL );
        !           795:                            stab[idname].suse = -lineno;
        !           796:                            branch( stab[idname].offset );
        !           797:                            goto rch;
        !           798:                            } break;
        !           799: case 121:
        !           800: # line 586 "../fmip/cgram.y"
        !           801: {  register NODE *q;
        !           802:                            q = block( FREE, NIL, NIL, INT|ARY, 0, LABEL );
        !           803:                            q->tn.rval = yypvt[-1].intval;
        !           804:                            defid( q, LABEL );
        !           805:                            reached = 1;
        !           806:                            } break;
        !           807: case 122:
        !           808: # line 593 "../fmip/cgram.y"
        !           809: {  addcase(yypvt[-1].nodep);
        !           810:                            reached = 1;
        !           811:                            } break;
        !           812: case 123:
        !           813: # line 597 "../fmip/cgram.y"
        !           814: {  reached = 1;
        !           815:                            adddef();
        !           816:                            flostat |= FDEF;
        !           817:                            } break;
        !           818: case 124:
        !           819: # line 603 "../fmip/cgram.y"
        !           820: {  savebc();
        !           821:                            if( !reached ) werror( "loop not entered at top");
        !           822:                            brklab = getlab();
        !           823:                            contlab = getlab();
        !           824:                            deflab( yyval.intval = getlab() );
        !           825:                            reached = 1;
        !           826:                            } break;
        !           827: case 125:
        !           828: # line 612 "../fmip/cgram.y"
        !           829: {  ecomp( buildtree( CBRANCH, yypvt[-1].nodep, bcon( yyval.intval=getlab()) ) ) ;
        !           830:                            reached = 1;
        !           831:                            } break;
        !           832: case 126:
        !           833: # line 617 "../fmip/cgram.y"
        !           834: {  if( reached ) branch( yyval.intval = getlab() );
        !           835:                            else yyval.intval = NOLAB;
        !           836:                            deflab( yypvt[-2].intval );
        !           837:                            reached = 1;
        !           838:                            } break;
        !           839: case 127:
        !           840: # line 625 "../fmip/cgram.y"
        !           841: {  savebc();
        !           842:                            if( !reached ) werror( "loop not entered at top");
        !           843:                            if( yypvt[-1].nodep->in.op == ICON && yypvt[-1].nodep->tn.lval != 0 ) flostat = FLOOP;
        !           844:                            deflab( contlab = getlab() );
        !           845:                            reached = 1;
        !           846:                            brklab = getlab();
        !           847:                            if( flostat == FLOOP ) tfree( yypvt[-1].nodep );
        !           848:                            else ecomp( buildtree( CBRANCH, yypvt[-1].nodep, bcon( brklab) ) );
        !           849:                            } break;
        !           850: case 128:
        !           851: # line 636 "../fmip/cgram.y"
        !           852: {  if( yypvt[-3].nodep ) ecomp( yypvt[-3].nodep );
        !           853:                            else if( !reached ) werror( "loop not entered at top");
        !           854:                            savebc();
        !           855:                            contlab = getlab();
        !           856:                            brklab = getlab();
        !           857:                            deflab( yyval.intval = getlab() );
        !           858:                            reached = 1;
        !           859:                            if( yypvt[-1].nodep ) ecomp( buildtree( CBRANCH, yypvt[-1].nodep, bcon( brklab) ) );
        !           860:                            else flostat |= FLOOP;
        !           861:                            } break;
        !           862: case 129:
        !           863: # line 648 "../fmip/cgram.y"
        !           864: {  savebc();
        !           865:                            brklab = getlab();
        !           866:                            ecomp( buildtree( FORCE, yypvt[-1].nodep, NIL ) );
        !           867:                            branch( yyval.intval = getlab() );
        !           868:                            swstart();
        !           869:                            reached = 0;
        !           870:                            } break;
        !           871: case 130:
        !           872: # line 657 "../fmip/cgram.y"
        !           873: { yyval.intval=instruct; stwart=instruct=0; } break;
        !           874: case 131:
        !           875: # line 659 "../fmip/cgram.y"
        !           876: {  yyval.intval = icons( yypvt[-0].nodep );  instruct=yypvt[-1].intval; } break;
        !           877: case 133:
        !           878: # line 663 "../fmip/cgram.y"
        !           879: { yyval.nodep=0; } break;
        !           880: case 135:
        !           881: # line 668 "../fmip/cgram.y"
        !           882: {  goto bop; } break;
        !           883: case 136:
        !           884: # line 672 "../fmip/cgram.y"
        !           885: {
        !           886:                        preconf:
        !           887:                            if( yychar==RELOP||yychar==EQUOP||yychar==AND||yychar==OR||yychar==ER ){
        !           888:                            precplaint:
        !           889:                                if( hflag ) werror( "precedence confusion possible: parenthesize!" );
        !           890:                                }
        !           891:                        bop:
        !           892:                            yyval.nodep = buildtree( yypvt[-1].intval, yypvt[-2].nodep, yypvt[-0].nodep );
        !           893:                            } break;
        !           894: case 137:
        !           895: # line 682 "../fmip/cgram.y"
        !           896: {  yypvt[-1].intval = COMOP;
        !           897:                            goto bop;
        !           898:                            } break;
        !           899: case 138:
        !           900: # line 686 "../fmip/cgram.y"
        !           901: {  goto bop; } break;
        !           902: case 139:
        !           903: # line 688 "../fmip/cgram.y"
        !           904: {  if(yychar==SHIFTOP) goto precplaint; else goto bop; } break;
        !           905: case 140:
        !           906: # line 690 "../fmip/cgram.y"
        !           907: {  if(yychar==SHIFTOP ) goto precplaint; else goto bop; } break;
        !           908: case 141:
        !           909: # line 692 "../fmip/cgram.y"
        !           910: {  if(yychar==PLUS||yychar==MINUS) goto precplaint; else goto bop; } break;
        !           911: case 142:
        !           912: # line 694 "../fmip/cgram.y"
        !           913: {  goto bop; } break;
        !           914: case 143:
        !           915: # line 696 "../fmip/cgram.y"
        !           916: {  goto preconf; } break;
        !           917: case 144:
        !           918: # line 698 "../fmip/cgram.y"
        !           919: {  if( yychar==RELOP||yychar==EQUOP ) goto preconf;  else goto bop; } break;
        !           920: case 145:
        !           921: # line 700 "../fmip/cgram.y"
        !           922: {  if(yychar==RELOP||yychar==EQUOP) goto preconf; else goto bop; } break;
        !           923: case 146:
        !           924: # line 702 "../fmip/cgram.y"
        !           925: {  if(yychar==RELOP||yychar==EQUOP) goto preconf; else goto bop; } break;
        !           926: case 147:
        !           927: # line 704 "../fmip/cgram.y"
        !           928: {  goto bop; } break;
        !           929: case 148:
        !           930: # line 706 "../fmip/cgram.y"
        !           931: {  goto bop; } break;
        !           932: case 149:
        !           933: # line 708 "../fmip/cgram.y"
        !           934: {  abop:
        !           935:                                yyval.nodep = buildtree( ASG yypvt[-2].intval, yypvt[-3].nodep, yypvt[-0].nodep );
        !           936:                                } break;
        !           937: case 150:
        !           938: # line 712 "../fmip/cgram.y"
        !           939: {  goto abop; } break;
        !           940: case 151:
        !           941: # line 714 "../fmip/cgram.y"
        !           942: {  goto abop; } break;
        !           943: case 152:
        !           944: # line 716 "../fmip/cgram.y"
        !           945: {  goto abop; } break;
        !           946: case 153:
        !           947: # line 718 "../fmip/cgram.y"
        !           948: {  goto abop; } break;
        !           949: case 154:
        !           950: # line 720 "../fmip/cgram.y"
        !           951: {  goto abop; } break;
        !           952: case 155:
        !           953: # line 722 "../fmip/cgram.y"
        !           954: {  goto abop; } break;
        !           955: case 156:
        !           956: # line 724 "../fmip/cgram.y"
        !           957: {  goto abop; } break;
        !           958: case 157:
        !           959: # line 726 "../fmip/cgram.y"
        !           960: {  yyval.nodep=buildtree(QUEST, yypvt[-4].nodep, buildtree( COLON, yypvt[-2].nodep, yypvt[-0].nodep ) );
        !           961:                            } break;
        !           962: case 158:
        !           963: # line 729 "../fmip/cgram.y"
        !           964: {  werror( "old-fashioned assignment operator" );  goto bop; } break;
        !           965: case 159:
        !           966: # line 731 "../fmip/cgram.y"
        !           967: {  goto bop; } break;
        !           968: case 161:
        !           969: # line 735 "../fmip/cgram.y"
        !           970: {  yyval.nodep = buildtree( yypvt[-0].intval, yypvt[-1].nodep, bcon(1) ); } break;
        !           971: case 162:
        !           972: # line 737 "../fmip/cgram.y"
        !           973: { ubop:
        !           974:                            yyval.nodep = buildtree( UNARY yypvt[-1].intval, yypvt[-0].nodep, NIL );
        !           975:                            } break;
        !           976: case 163:
        !           977: # line 741 "../fmip/cgram.y"
        !           978: {  if( ISFTN(yypvt[-0].nodep->in.type) || ISARY(yypvt[-0].nodep->in.type) ){
        !           979:                                werror( "& before array or function: ignored" );
        !           980:                                yyval.nodep = yypvt[-0].nodep;
        !           981:                                }
        !           982:                            else goto ubop;
        !           983:                            } break;
        !           984: case 164:
        !           985: # line 748 "../fmip/cgram.y"
        !           986: {  goto ubop; } break;
        !           987: case 165:
        !           988: # line 750 "../fmip/cgram.y"
        !           989: {
        !           990:                            yyval.nodep = buildtree( yypvt[-1].intval, yypvt[-0].nodep, NIL );
        !           991:                            } break;
        !           992: case 166:
        !           993: # line 754 "../fmip/cgram.y"
        !           994: {  yyval.nodep = buildtree( yypvt[-1].intval==INCR ? ASG PLUS : ASG MINUS,
        !           995:                                                yypvt[-0].nodep,
        !           996:                                                bcon(1)  );
        !           997:                            } break;
        !           998: case 167:
        !           999: # line 759 "../fmip/cgram.y"
        !          1000: {  yyval.nodep = doszof( yypvt[-0].nodep ); } break;
        !          1001: case 168:
        !          1002: # line 761 "../fmip/cgram.y"
        !          1003: {  yyval.nodep = buildtree( CAST, yypvt[-2].nodep, yypvt[-0].nodep );
        !          1004:                            yyval.nodep->in.left->in.op = FREE;
        !          1005:                            yyval.nodep->in.op = FREE;
        !          1006:                            yyval.nodep = yyval.nodep->in.right;
        !          1007:                            } break;
        !          1008: case 169:
        !          1009: # line 767 "../fmip/cgram.y"
        !          1010: {  yyval.nodep = doszof( yypvt[-1].nodep ); } break;
        !          1011: case 170:
        !          1012: # line 769 "../fmip/cgram.y"
        !          1013: {  yyval.nodep = buildtree( UNARY MUL, buildtree( PLUS, yypvt[-3].nodep, yypvt[-1].nodep ), NIL ); } break;
        !          1014: case 171:
        !          1015: # line 771 "../fmip/cgram.y"
        !          1016: {  yyval.nodep=buildtree(UNARY CALL,yypvt[-1].nodep,NIL); } break;
        !          1017: case 172:
        !          1018: # line 773 "../fmip/cgram.y"
        !          1019: {  yyval.nodep=buildtree(CALL,yypvt[-2].nodep,yypvt[-1].nodep); } break;
        !          1020: case 173:
        !          1021: # line 775 "../fmip/cgram.y"
        !          1022: {  if( yypvt[-1].intval == DOT ){
        !          1023:                                if( notlval( yypvt[-2].nodep ) )uerror("structure reference must be addressable");
        !          1024:                                yypvt[-2].nodep = buildtree( UNARY AND, yypvt[-2].nodep, NIL );
        !          1025:                                }
        !          1026:                            idname = yypvt[-0].intval;
        !          1027:                            yyval.nodep = buildtree( STREF, yypvt[-2].nodep, buildtree( NAME, NIL, NIL ) );
        !          1028:                            } break;
        !          1029: case 174:
        !          1030: # line 783 "../fmip/cgram.y"
        !          1031: {  idname = yypvt[-0].intval;
        !          1032:                            /* recognize identifiers in initializations */
        !          1033:                            if( blevel==0 && stab[idname].stype == UNDEF ) {
        !          1034:                                register NODE *q;
        !          1035: #ifndef FLEXNAMES
        !          1036:                                werror( "undeclared initializer name %.8s", stab[idname].sname );
        !          1037: #else
        !          1038:                                werror( "undeclared initializer name %s", stab[idname].sname );
        !          1039: #endif
        !          1040:                                q = block( FREE, NIL, NIL, INT, 0, INT );
        !          1041:                                q->tn.rval = idname;
        !          1042:                                defid( q, EXTERN );
        !          1043:                                }
        !          1044:                            yyval.nodep=buildtree(NAME,NIL,NIL);
        !          1045:                            stab[yypvt[-0].intval].suse = -lineno;
        !          1046:                        } break;
        !          1047: case 175:
        !          1048: # line 800 "../fmip/cgram.y"
        !          1049: {  yyval.nodep=bcon(0);
        !          1050:                            yyval.nodep->tn.lval = lastcon;
        !          1051:                            yyval.nodep->tn.rval = NONAME;
        !          1052:                            if( yypvt[-0].intval ) yyval.nodep->fn.csiz = yyval.nodep->in.type = ctype(LONG);
        !          1053:                            } break;
        !          1054: case 176:
        !          1055: # line 806 "../fmip/cgram.y"
        !          1056: {  yyval.nodep=buildtree(FCON,NIL,NIL);
        !          1057:                            yyval.nodep->fpn.dval = dcon;
        !          1058:                            } break;
        !          1059: case 177:
        !          1060: # line 810 "../fmip/cgram.y"
        !          1061: {  yyval.nodep = getstr(); /* get string contents */ } break;
        !          1062: case 178:
        !          1063: # line 812 "../fmip/cgram.y"
        !          1064: { yyval.nodep=yypvt[-1].nodep; } break;
        !          1065: case 179:
        !          1066: # line 816 "../fmip/cgram.y"
        !          1067: {
        !          1068:                        yyval.nodep = tymerge( yypvt[-1].nodep, yypvt[-0].nodep );
        !          1069:                        yyval.nodep->in.op = NAME;
        !          1070:                        yypvt[-1].nodep->in.op = FREE;
        !          1071:                        } break;
        !          1072: case 180:
        !          1073: # line 824 "../fmip/cgram.y"
        !          1074: { yyval.nodep = bdty( NAME, NIL, -1 ); } break;
        !          1075: case 181:
        !          1076: # line 826 "../fmip/cgram.y"
        !          1077: { yyval.nodep = bdty( UNARY CALL, bdty(NAME,NIL,-1),0); } break;
        !          1078: case 182:
        !          1079: # line 828 "../fmip/cgram.y"
        !          1080: {  yyval.nodep = bdty( UNARY CALL, yypvt[-3].nodep, 0 ); } break;
        !          1081: case 183:
        !          1082: # line 830 "../fmip/cgram.y"
        !          1083: {  goto umul; } break;
        !          1084: case 184:
        !          1085: # line 832 "../fmip/cgram.y"
        !          1086: {  goto uary; } break;
        !          1087: case 185:
        !          1088: # line 834 "../fmip/cgram.y"
        !          1089: {  goto bary;  } break;
        !          1090: case 186:
        !          1091: # line 836 "../fmip/cgram.y"
        !          1092: { yyval.nodep = yypvt[-1].nodep; } break;
        !          1093: case 187:
        !          1094: # line 840 "../fmip/cgram.y"
        !          1095: {  if( stab[yypvt[-1].intval].stype == UNDEF ){
        !          1096:                                register NODE *q;
        !          1097:                                q = block( FREE, NIL, NIL, FTN|INT, 0, INT );
        !          1098:                                q->tn.rval = yypvt[-1].intval;
        !          1099:                                defid( q, EXTERN );
        !          1100:                                }
        !          1101:                            idname = yypvt[-1].intval;
        !          1102:                            yyval.nodep=buildtree(NAME,NIL,NIL);
        !          1103:                            stab[idname].suse = -lineno;
        !          1104:                        } break;
        !          1105:                }
        !          1106:                goto yystack;  /* stack new state and value */
        !          1107: 
        !          1108:        }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.