Return to 6.i CVS log

Up to [Research Unix] / researchv10no / cmd / ccom / vax / tests

Annotation of researchv10no/cmd/ccom/vax/tests/6.i, revision 1.1

1.1     ! root        1: /* local.c */
        !             2: extern struct  _iobuf {
        !             3:        int     _cnt;
        !             4:        char    *_ptr;
        !             5:        char    *_base;
        !             6:        short   _flag;
        !             7:        char    _file;
        !             8: } _iob[20];
        !             9: struct _iobuf  *fopen();
        !            10: struct _iobuf  *fdopen();
        !            11: struct _iobuf  *freopen();
        !            12: long   ftell();
        !            13: char   *fgets();
        !            14: struct _iobuf  *fopen();
        !            15: struct _iobuf  *fdopen();
        !            16: struct _iobuf  *freopen();
        !            17: long   ftell();
        !            18: char   *fgets();
        !            19:        char            *hash();
        !            20:        char            *savestr();
        !            21:        char            *tstr();
        !            22:        extern int      tstrused;
        !            23:        extern char     *tstrbuf[];
        !            24:        extern char     **curtstr;
        !            25: extern int nerrors;  
        !            26: typedef union ndu NODE;
        !            27: typedef unsigned int TWORD;
        !            28: typedef long CONSZ;  
        !            29:        
        !            30:        
        !            31: extern int dope[];  
        !            32: extern char *opst[];  
        !            33:        
        !            34: union ndu {
        !            35:        struct {
        !            36:                int op;
        !            37:                int goal;
        !            38:                TWORD type;
        !            39:                int cst[(6+4)];
        !            40:                char * name;
        !            41:                char pad[8  -sizeof(char *)];   
        !            42:                NODE *left;
        !            43:                NODE *right;
        !            44:        }in;    
        !            45:        
        !            46:        struct {
        !            47:                int op;
        !            48:                int goal;
        !            49:                TWORD type;
        !            50:                int cst[(6+4)];
        !            51:                char * name;
        !            52:                char pad[8  -sizeof(char *)];   
        !            53:                CONSZ lval;
        !            54:                int rval;
        !            55:        }tn;    
        !            56:        
        !            57:        struct {
        !            58:                int op;
        !            59:                int goal;
        !            60:                TWORD type;
        !            61:                int cst[(6+4)];
        !            62:                int label;  
        !            63:                int lop;  
        !            64:        }bn;    
        !            65:        struct {
        !            66:                int op;
        !            67:                int goal;
        !            68:                TWORD type;
        !            69:                int cst[(6+4)];
        !            70:                int stsize;  
        !            71:                short stalign;  
        !            72:                short argsize;  
        !            73:        }stn;   
        !            74:        struct {
        !            75:                int op;
        !            76:                int goal;
        !            77:                TWORD type;
        !            78:                int cdim;
        !            79:                int csiz;
        !            80:        }fn;    
        !            81:        
        !            82:        struct {
        !            83:                
        !            84:                int op;
        !            85:                int goal;
        !            86:                TWORD type;
        !            87:                int cdim;
        !            88:                int csiz;
        !            89:                double dval;
        !            90:        }fpn;   
        !            91: };
        !            92:        
        !            93: extern char *scnames();
        !            94: typedef long OFFSZ;
        !            95: struct symtab {
        !            96:        char *sname;
        !            97:        TWORD stype;  
        !            98:        char sclass;  
        !            99:        char slevel;  
        !           100:        char sflags;  
        !           101:        int offset;  
        !           102:        short dimoff; 
        !           103:        short sizoff; 
        !           104:        short suse;  
        !           105:        struct symtab *scopelink;       
        !           106: };
        !           107: struct sw {
        !           108:        CONSZ sval;
        !           109:        int slab;
        !           110: };
        !           111: extern struct sw swtab[];
        !           112: extern struct sw *swp;
        !           113: extern int swx;
        !           114: extern int ftnno;
        !           115: extern int blevel;
        !           116: extern int instruct, stwart;
        !           117: extern int lineno, nerrors;
        !           118: typedef union {
        !           119:        int intval;
        !           120:        NODE * nodep;
        !           121: } YYSTYPE;
        !           122: extern YYSTYPE yylval;
        !           123: extern CONSZ lastcon;
        !           124: extern CONSZ ccast();
        !           125: extern double dcon;
        !           126: extern char ftitle[];
        !           127: extern struct symtab stab[];
        !           128: extern int curftn;
        !           129: extern int strftn;
        !           130: extern char *locnames[];
        !           131: extern int curloc;
        !           132: extern int curclass;
        !           133: extern int curdim;
        !           134: extern int dimtab[];
        !           135: extern int paramstk[];
        !           136: extern int paramno;
        !           137: extern int argstk[];
        !           138: extern int argsoff[];
        !           139: extern TWORD argty[];
        !           140: extern int argno;
        !           141: extern int autooff, argoff, strucoff;
        !           142: extern int regvar;
        !           143: extern int nextrvar;
        !           144: extern int brkflag;
        !           145: extern char yytext[];
        !           146: extern int strflg;
        !           147: extern OFFSZ inoff;
        !           148: extern int reached;
        !           149: extern int idname;
        !           150: extern NODE node[];
        !           151: extern NODE *lastfree;
        !           152: extern int cflag, hflag, pflag;
        !           153: extern int brklab;
        !           154: extern int contlab;
        !           155: extern int flostat;
        !           156: extern int retlab;
        !           157: extern int retstat;
        !           158: extern int asavbc[], *psavbc;
        !           159:        
        !           160: extern NODE
        !           161:        *aadjust(),
        !           162:        *bcon(),
        !           163:        *bdty(),
        !           164:        *block(),
        !           165:        *bpsize(),
        !           166:        *buildtree(),
        !           167:        *clocal(),
        !           168:        *conval(),
        !           169:        *convert(),
        !           170:        *dclstruct(),
        !           171:        *doszof(),
        !           172:        *getstr(),
        !           173:        *makety(),
        !           174:        *mkty(),
        !           175:        *oconvert(),
        !           176:        *offcon(),
        !           177:        *optim(),
        !           178:        *pconvert(),
        !           179:        *ptmatch(),
        !           180:        *pvconvert(),
        !           181:        *rstruct(),
        !           182:        *sconvert(),
        !           183:        *strargs(),
        !           184:        *stref(),
        !           185:        *talloc(),
        !           186:        *tymatch(),
        !           187:        *tymerge(),
        !           188:        *unconvert(),
        !           189:        *xicolon();
        !           190: OFFSZ  tsize(),
        !           191:        psize();
        !           192: TWORD  types(),
        !           193:        ctype();
        !           194: char *exname(), *exdcon();
        !           195: int minrvar = 11;
        !           196: int wloop_level = 1    ;
        !           197: int floop_level = 1    ;
        !           198: int maxboff;
        !           199: int maxtemp;
        !           200: extern int gdebug;
        !           201: main( argc, argv ) char *argv[];
        !           202: {
        !           203:        extern int proflag;  
        !           204: 
        !           205: 
        !           206:        int r;
        !           207:        r = mainp1( argc, argv );
        !           208:        return( r );
        !           209: }
        !           210: beg_file()
        !           211: {
        !           212:        
        !           213:        register char *p, *s;
        !           214:        char *tempnam();
        !           215:                        
        !           216:        p = ftitle + strlen( ftitle ) - 2;
        !           217:        s = p - 14;     
        !           218:        while ( p > s && *p != '"' && *p != '/' )
        !           219:                --p;
        !           220:        regvar = minrvar;
        !           221:        if (gdebug)
        !           222:                dbline();
        !           223: }
        !           224: NODE *
        !           225: treecpy(p)             
        !           226:        register NODE *p; 
        !           227: {
        !           228:        
        !           229:        register NODE *q;
        !           230:        q = talloc();
        !           231:        *q = *p;
        !           232:        switch ( (dope[q->in.op]&016))
        !           233:        {
        !           234:        case 010:
        !           235:                q->in.right = treecpy(p->in.right);
        !           236:        case 04:
        !           237:                q->in.left = treecpy(p->in.left);
        !           238:        }
        !           239:        return (q);
        !           240: }
        !           241: NODE *
        !           242: clocal(p) NODE *p;
        !           243: {
        !           244:        register NODE *l,*ll,*temp;
        !           245:        if( p->in.op == (2+ 11) )
        !           246:        {       
        !           247:                
        !           248:                l = p->in.left;
        !           249:                if( l->in.op == 6 )
        !           250:                {
        !           251:                        ll = l->in.left;
        !           252:                        if( ll->in.op != 11 && ll->in.op != 2+ 14 )
        !           253:                        {
        !           254:                                if( (l->in.right)->in.op == 11 )
        !           255:                                {
        !           256:                                        temp = l->in.right;
        !           257:                                        l->in.right = l->in.left;
        !           258:                                        l->in.left = temp;
        !           259:                                }
        !           260:                        }
        !           261:                }
        !           262:        }
        !           263:        return(p);
        !           264: }
        !           265: cisreg( t ) TWORD t;
        !           266: { 
        !           267:        if( t==4 || t==14 ||  ((t&(03<<5 ))== 040) || t==2 || t==12
        !           268:                   || t==3 || t==13 )
        !           269:        {
        !           270:                if( regvar >= 6 )
        !           271:                {
        !           272:                        nextrvar = regvar--;
        !           273:                        if( regvar < minrvar ) minrvar = regvar;
        !           274:                        return(1);
        !           275:                }
        !           276:        }
        !           277:        return(0);
        !           278: }
        !           279: opbigsz( op )
        !           280: {
        !           281:        
        !           282:        switch( op )
        !           283:        {
        !           284:        default:
        !           285:                return( 32 );
        !           286:        case 6:
        !           287:        case 8:
        !           288:        case 17:
        !           289:        case 14:
        !           290:        case 19:
        !           291:        case 77:
        !           292:        case 2+ 8:
        !           293:                return( 8 );
        !           294:        }
        !           295: }
        !           296: branch(n)                      
        !           297: int n;
        !           298: {
        !           299:        if (!reached)                   
        !           300:                return;
        !           301:        dbline();
        !           302:        genubr(n);
        !           303: }
        !           304:        
        !           305: static int tablelabel;
        !           306: struct sw heapsw[250 ];        
        !           307:        
        !           308:        
        !           309: genswitch(p,n) register struct sw *p;
        !           310: {
        !           311:        
        !           312:        register i;
        !           313:        register CONSZ j, range;
        !           314:        register dlab, swlab;
        !           315:        range = p[n].sval-p[1].sval;
        !           316:        if(  ( range>0 &&  range<=(3* n ) &&  n >=4) )
        !           317:        {       
        !           318:                swlab = getlab();
        !           319:                dlab = ((p->slab >= 0) ? p->slab : getlab());
        !           320:                dswbegin( n, p[1].sval, range, swlab, dlab );
        !           321:                for( i=1,j=p[1].sval; i<=n; j++)
        !           322:                {
        !           323:                        if( j == p[i].sval )
        !           324:                        {
        !           325:                                dswcase( p[i].slab );
        !           326:                                j = p[i++].sval;
        !           327:                        }
        !           328:                        else
        !           329:                        {
        !           330:                                dswcase( dlab );
        !           331:                        }
        !           332:                }
        !           333:                
        !           334:                locctr( 0 );
        !           335:                if( p->slab >= 0 ) genubr( dlab );
        !           336:                else deflab( dlab );
        !           337:                return;
        !           338:        }
        !           339:        if(  (n>8) )
        !           340:        {       
        !           341:                heapsw[0].slab = dlab = (p->slab >= 0 ? p->slab : getlab());
        !           342:                makeheap(p, n, 1);      
        !           343:                walkheap(1, n);         
        !           344:                if( p->slab >= 0 )
        !           345:                        genubr( dlab );
        !           346:                else
        !           347:                        deflab( dlab );
        !           348:                return;
        !           349:        }
        !           350:        
        !           351:        for( i=1; i<=n; ++i ) sswtest( p[i].sval, p[i].slab );
        !           352:        if( p->slab>=0 ) genubr( p->slab );
        !           353:        }
        !           354: makeheap(p, m, n)
        !           355: register struct sw *p;
        !           356: {
        !           357:        register int q;
        !           358:        q = select(m);
        !           359:        heapsw[n] = p[q];
        !           360:        if( q>1 ) makeheap(p, q-1, 2*n);
        !           361:        if( q<m ) makeheap(p+q, m-q, 2*n+1);
        !           362: }
        !           363: select(m) {
        !           364:        register int l,i,k;
        !           365:        for(i=1; ; i*=2)
        !           366:                if( (i-1) > m ) break;
        !           367:        l = ((k = i/2 - 1) + 1)/2;
        !           368:        return( l + (m-k < l ? m-k : l));
        !           369: }
        !           370: walkheap(start, limit)
        !           371: {
        !           372:        int label;
        !           373:        if( start > limit ) return;
        !           374:        sswtest( heapsw[start].sval, heapsw[start].slab );
        !           375:        if( (2*start) > limit ) {
        !           376:                genubr( heapsw[0].slab );
        !           377:                return;
        !           378:        }
        !           379:        if( (2*start+1) <= limit ) {
        !           380:                label = getlab();
        !           381:                hswelse( label );
        !           382:        } else
        !           383:                hswelse( heapsw[0].slab );
        !           384:        walkheap( 2*start, limit);
        !           385:        if( (2*start+1) <= limit ) {
        !           386:                deflab( label );
        !           387:                walkheap( 2*start+1, limit);
        !           388:        }
        !           389: }
        !           390: dswbegin( numb, first, range, labl, dlab )
        !           391: CONSZ first, range;
        !           392: int numb, labl, dlab;
        !           393: {
        !           394:        printf("        casel   r0,$%ld,$%ld\n", first, range );
        !           395:        printf("L%d:\n", labl );
        !           396:        tablelabel = labl;
        !           397: }
        !           398: dswcase( l )
        !           399: int l;
        !           400: {
        !           401:        printf("        .word   L%d-L%d\n", l, tablelabel );
        !           402: }
        !           403: sswtest( val, lab )
        !           404: CONSZ val;
        !           405: int lab;
        !           406: {
        !           407:        printf( "       cmpl    r0,$%ld\n       jeql    L%d\n", val, lab );
        !           408: }
        !           409: hswelse( lab )
        !           410: int lab;
        !           411: {
        !           412:        printf("        jgtr    L%d\n", lab );
        !           413: }
        !           414: OFFSZ inoff;           
        !           415: static inwd;           
        !           416: static long word;      
        !           417: zecode( n )
        !           418: int n;
        !           419: {
        !           420:        
        !           421:        if (n <= 0) return;
        !           422:        printf( "       .space  %d\n", 4*n );
        !           423:        inoff += n*32;
        !           424: }
        !           425: vfdzero( n ){ 
        !           426:        
        !           427:        sz_incode( (CONSZ)0, n );
        !           428:        }
        !           429: incode (p, sz)
        !           430: NODE *p;
        !           431: {
        !           432:        sz_incode(p->tn.lval, sz);
        !           433: }
        !           434: sz_incode( val, sz )
        !           435: CONSZ val;
        !           436: {
        !           437:        
        !           438:        
        !           439:        
        !           440:        if((sz+inwd) > 32) cerror("incode: field > long");
        !           441:        
        !           442:        word |= ((unsigned)(val<<(32-sz))) >> (32-sz-inwd);
        !           443:        inwd += sz;
        !           444:        inoff += sz;
        !           445:        
        !           446:        if( inwd == 32 )
        !           447:        {
        !           448:                genlong( word );
        !           449:                word = inwd = 0;
        !           450:        }
        !           451: }
        !           452: fincode( d, sz )
        !           453: double d;
        !           454: int sz;
        !           455: {
        !           456:        
        !           457:        
        !           458:        
        !           459:        union { float f; double d; int i[2]; } cheat;
        !           460:        if (sz == 64)
        !           461:        {
        !           462:                cheat.d = d;
        !           463:                printf("\t.long\t0x%x,0x%x\t# %.20e\n", cheat.i[0], cheat.i[1],
        !           464:                    cheat.d);
        !           465:        }
        !           466:        else
        !           467:        {
        !           468:                cheat.f = d;
        !           469:                printf("\t.long\t0x%x\t# %.20e\n", cheat.i[0], cheat.f);
        !           470:        }
        !           471:        inoff += sz;
        !           472: }
        !           473: int ftlab1, ftlab2;
        !           474: int proflag;
        !           475: int ent_mask[] = {
        !           476:        0,0,0,0,0, 0xfc0, 0xf80, 0xf00, 0xe00, 0xc00, 0x800, 0};
        !           477: efcode()
        !           478: {
        !           479:        
        !           480:        long spoff;     
        !           481:        genret( strftn, strftn, retlab );
        !           482:        printf( "       .set    L.R%d,0x%x\n", ftnno, ent_mask[minrvar] );
        !           483:        spoff = maxboff;
        !           484:        if( spoff >=  ((0 )/8) ) spoff -=  ((0 )/8);
        !           485:        spoff += maxtemp;
        !           486:        spoff /= 8;
        !           487:        deflab( ftlab1 );
        !           488:        if( spoff!=0 )
        !           489:                if( spoff < 64 )
        !           490:                        printf( "       subl2   $%ld,sp\n", spoff );
        !           491:                else
        !           492:                        printf( "       movab   -%ld(sp),sp\n", spoff);
        !           493:        genubr( ftlab2 );
        !           494:        regvar = minrvar = 11;
        !           495:        if (gdebug)
        !           496:                dbfunend(getlab());
        !           497: }
        !           498: bfcode( a, n )
        !           499: int a[], n;
        !           500: {
        !           501:        
        !           502:        register i;
        !           503:        
        !           504:        printf( "       .word   L.R%d\n", ftnno);
        !           505:        genubr( ftlab1 = getlab() );
        !           506:        deflab( ftlab2 = getlab() );
        !           507:        retlab = getlab();
        !           508:        if( proflag )
        !           509:        {       
        !           510:                i = getlab();
        !           511:                printf("        movab   L%d,r0\n", i);
        !           512:                printf("        jsb     mcount\n");
        !           513:                printf("        .data\n");
        !           514:                printf("        .align  2\n");
        !           515:                printf("L%d:    .long   0\n", i);
        !           516:                printf("        .text\n");
        !           517:        }
        !           518:        if (gdebug)
        !           519:        {
        !           520:                dbfunbeg(&stab[curftn]);
        !           521:                dbnargs(n);
        !           522:                for (i = 0; i < n; ++i)
        !           523:                        dbfunarg(&stab[a[i]]);
        !           524:        }
        !           525: }
        !           526: defnam( psym )
        !           527: register struct symtab *psym;
        !           528: {
        !           529:        
        !           530:        
        !           531:        
        !           532:        if (psym->sclass == 5)
        !           533:                printf( "       .globl  %s\n", exname(psym->sname) );
        !           534:        printf("%s:\n", exname(psym->sname));
        !           535: }
        !           536: commdec(id)            
        !           537: int id;
        !           538: {
        !           539:        register struct symtab *psym;
        !           540:        OFFSZ n;
        !           541:        psym = &stab[id];
        !           542:        psym->sflags |= 0200;
        !           543:        n = tsize(psym->stype, psym->dimoff, psym->sizoff) / 8;
        !           544:        if (psym->sclass == 3)
        !           545:                if (psym->slevel)
        !           546:                        printf("        .lcomm  L%d,%ld\n", psym->offset, n);
        !           547:                else    
        !           548:                        printf("        .lcomm  %s,%ld\n", exname(psym->sname), n);
        !           549:        else if (psym->sclass == 2)
        !           550:                printf("        .comm   %s,%ld\n", exname(psym->sname), n);
        !           551:        else
        !           552:                cerror("Non-static/external in common");
        !           553: }

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