Return to 7.i CVS log

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

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

1.1     ! root        1: /* local2.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:        char            *hash();
        !            15:        char            *savestr();
        !            16:        char            *tstr();
        !            17:        extern int      tstrused;
        !            18:        extern char     *tstrbuf[];
        !            19:        extern char     **curtstr;
        !            20: extern int nerrors;  
        !            21: typedef union ndu NODE;
        !            22: typedef unsigned int TWORD;
        !            23: typedef long CONSZ;  
        !            24:        
        !            25:        
        !            26: extern int dope[];  
        !            27: extern char *opst[];  
        !            28:        
        !            29: union ndu {
        !            30:        struct {
        !            31:                int op;
        !            32:                int goal;
        !            33:                TWORD type;
        !            34:                int cst[(6+4)];
        !            35:                char * name;
        !            36:                char pad[8  -sizeof(char *)];   
        !            37:                NODE *left;
        !            38:                NODE *right;
        !            39:        }in;    
        !            40:        
        !            41:        struct {
        !            42:                int op;
        !            43:                int goal;
        !            44:                TWORD type;
        !            45:                int cst[(6+4)];
        !            46:                char * name;
        !            47:                char pad[8  -sizeof(char *)];   
        !            48:                CONSZ lval;
        !            49:                int rval;
        !            50:        }tn;    
        !            51:        
        !            52:        struct {
        !            53:                int op;
        !            54:                int goal;
        !            55:                TWORD type;
        !            56:                int cst[(6+4)];
        !            57:                int label;  
        !            58:                int lop;  
        !            59:        }bn;    
        !            60:        struct {
        !            61:                int op;
        !            62:                int goal;
        !            63:                TWORD type;
        !            64:                int cst[(6+4)];
        !            65:                int stsize;  
        !            66:                short stalign;  
        !            67:                short argsize;  
        !            68:        }stn;   
        !            69:        struct {
        !            70:                int op;
        !            71:                int goal;
        !            72:                TWORD type;
        !            73:                int cdim;
        !            74:                int csiz;
        !            75:        }fn;    
        !            76:        
        !            77:        struct {
        !            78:                
        !            79:                int op;
        !            80:                int goal;
        !            81:                TWORD type;
        !            82:                int cdim;
        !            83:                int csiz;
        !            84:                double dval;
        !            85:        }fpn;   
        !            86: };
        !            87:        
        !            88:        
        !            89:                
        !            90:        
        !            91:        
        !            92:        
        !            93:  
        !            94:        
        !            95: extern int busy[];
        !            96: extern NODE node[];
        !            97: typedef struct shape SHAPE;
        !            98:        
        !            99: extern struct shape {
        !           100:        int     op;     
        !           101:        SHAPE   *sl;    
        !           102:        SHAPE   *sr;
        !           103:        int     sh;     
        !           104:        int     sc;     
        !           105: } shapes[];
        !           106: extern SHAPE   *pshape[];
        !           107: typedef struct optab OPTAB;
        !           108: struct optab {
        !           109:        int     op;     
        !           110:        int     tyop;   
        !           111:        OPTAB   *nextop;
        !           112:        SHAPE   **lshape;       
        !           113:        int     ltype;          
        !           114:        SHAPE   **rshape;       
        !           115:        int     rtype;
        !           116:        int     needs;
        !           117:        int     rewrite;
        !           118:        char    *cstring;
        !           119:        int     cost;
        !           120:        int     lcount;         
        !           121:        int     rcount;         
        !           122:        int     stinline;       
        !           123: };
        !           124: extern OPTAB
        !           125:        *match(),
        !           126:        *ophead[],
        !           127:        table[];
        !           128: extern NODE resc[];
        !           129: extern int tmpoff;
        !           130: extern int maxboff;
        !           131: extern int maxtemp;
        !           132: extern int maxarg;
        !           133: extern int ftnno;
        !           134: extern int sideff;
        !           135: extern NODE
        !           136:        *talloc(),
        !           137:        *ind2type(),
        !           138:        *tcopy(),
        !           139:        *getadr(),
        !           140:        *getlr();
        !           141: extern CONSZ rdin();
        !           142: extern char *rnames[];
        !           143: extern int lineno;
        !           144: extern char ftitle[];
        !           145: extern int fldshf, fldsz;
        !           146: extern int lflag, udebug, e2debug, odebug, rdebug, radebug, sdebug;
        !           147: extern int fast;  
        !           148:        
        !           149:        
        !           150:        
        !           151:        
        !           152: typedef struct inst INST;
        !           153: struct inst {
        !           154:        NODE    *p;
        !           155:        OPTAB   *q;
        !           156:        int     goal;
        !           157: };
        !           158: extern INST inst[300];
        !           159: extern nins;
        !           160:        
        !           161:        
        !           162: typedef SHAPE  *SHTABLE[2][20];
        !           163: extern SHTABLE sha;
        !           164: eobl2()                        
        !           165: {
        !           166: }
        !           167: char *
        !           168: exname( ix )
        !           169: char *ix;
        !           170: {
        !           171:        
        !           172:        static char text[100];
        !           173:        if( ix == 0 ) cerror("no name in exname");
        !           174:        sprintf( text, "_%s", ix );
        !           175:        return( text );
        !           176: }
        !           177: lineid( l, fn )
        !           178: int l;
        !           179: char *fn;
        !           180: {
        !           181:        extern int gdebug;
        !           182:        
        !           183:        printf( "#      line %d, file %s\n", l, fn );
        !           184: }
        !           185: deflab( n )
        !           186: int n;
        !           187: {
        !           188:        printf( "L%d:\n", n );
        !           189: }
        !           190: genubr( n )
        !           191: int n;
        !           192: {
        !           193:        
        !           194:        printf( "       jbr     L%d\n", n );
        !           195: }
        !           196: genret( s, l, n )
        !           197: int s, l, n;
        !           198: {
        !           199:        
        !           200:        
        !           201:        deflab(n);
        !           202:        if( s ) printf( "       movab   L%d,r0\n", l );
        !           203:        dbfunret();
        !           204:        printf( "       ret\n" );
        !           205: }
        !           206: defalign(n)
        !           207: int n;
        !           208: {
        !           209:        
        !           210:        if( n % 8 ) cerror( "funny alignment: %d", n );
        !           211:        else n /= 8;
        !           212:        if( n == 1 ) return;
        !           213:        else if( n==2 ) n=1;
        !           214:        else if( n==4 ) n=2;
        !           215:        else cerror( "funny alignment: %d", n );
        !           216:        printf( "       .align  %d\n", n );
        !           217: }
        !           218: char *locnames[] = {
        !           219:        
        !           220:        "       .text\n",
        !           221:        "       .data\n",
        !           222:        "       .data\n",
        !           223:        "       .data   2\n",
        !           224:        "       .data   1\n",
        !           225:        };
        !           226: bycode( t, i )
        !           227: int t, i;
        !           228: {
        !           229:        
        !           230:        i &= 07;
        !           231:        if( t < 0 )
        !           232:        { 
        !           233:                if( i != 0 ) printf("\n");
        !           234:        }
        !           235:        else
        !           236:        { 
        !           237:                if( i == 0 ) printf( "\n        .byte   " );
        !           238:                else printf(",");
        !           239:                printf("0x%x", t);
        !           240:        }
        !           241: }
        !           242: genshort( s )
        !           243: short s;
        !           244: {
        !           245:        
        !           246:        printf( "       .short  %d\n", (short) s );
        !           247: }
        !           248: genlong( l )
        !           249: long l;
        !           250: {
        !           251:        
        !           252:        printf( "       .long   0x%lx\n", l );
        !           253: }
        !           254: char *
        !           255: rnames[]= {  
        !           256:        "r0", "r1",
        !           257:        "r2", "r3", "r4",
        !           258:        "r5", "r6", "r7", "r8", "r9", "r10", "r11",
        !           259:        "ap", "fp", "sp", "pc" 
        !           260:        };
        !           261: zzzcode( p, ppc, q )
        !           262: NODE *p; char **ppc; OPTAB *q;
        !           263: {
        !           264:        register c;
        !           265:        switch( c= *++(*ppc) )
        !           266:        {
        !           267:        case 'I':
        !           268:                cbgen( p->bn.lop, p->bn.label, c );
        !           269:                return;
        !           270:        case 'k':       
        !           271:                printf("$%ld", ~p->in.right->tn.lval);
        !           272:                return;
        !           273:        case 'c':
        !           274:                
        !           275:                printf( "$%d", p->stn.argsize/32);
        !           276:                return;
        !           277:        case 'U':       
        !           278:                printf("$%d", 32 - p->in.right->tn.lval );
        !           279:                return;
        !           280:        case 'T':       
        !           281:                printf("$%d", p->stn.stsize/8);
        !           282:                break;
        !           283:        case 'M':       
        !           284:                staradr( p->in.right );
        !           285:                break;
        !           286:        case 'S':  
        !           287:                {
        !           288:                        register NODE *l, *r;
        !           289:                        register size;
        !           290:                        if( p->in.op == 98 )
        !           291:                        {
        !           292:                                l = p->in.left;
        !           293:                                r = p->in.right;
        !           294:                        }
        !           295:                        else if( p->in.op == 99 )
        !           296:                        {  
        !           297:                                r = p->in.left;
        !           298:                        }
        !           299:                        else cerror( "STASG bad" );
        !           300:                        size = p->stn.stsize/8;
        !           301:                        if( size <= 0 || size > 65535 )
        !           302:                                cerror("structure size <0=0 or >65535");
        !           303:                        switch(size)
        !           304:                        {
        !           305:                        case 1:
        !           306:                                printf("        movb    ");
        !           307:                                break;
        !           308:                        case 2:
        !           309:                                printf("        movw    ");
        !           310:                                break;
        !           311:                        case 4:
        !           312:                                printf("        movl    ");
        !           313:                                break;
        !           314:                        case 8:
        !           315:                                printf("        movq    ");
        !           316:                                break;
        !           317:                        default:
        !           318:                                printf("        movc3   $%d,", size);
        !           319:                                break;
        !           320:                        }
        !           321:                        staradr( r );
        !           322:                        printf(",");
        !           323:                        if( p->in.op == 99 ) printf( "(sp)" );
        !           324:                        else staradr( l );
        !           325:                        printf("\n");
        !           326:                }
        !           327:                break;
        !           328:        default:
        !           329:                cerror( "illegal zzzcode" );
        !           330:        }
        !           331: }
        !           332: staradr( p )
        !           333: NODE *p;
        !           334: {
        !           335:        NODE *pp;
        !           336:        pp = talloc();
        !           337:        pp->in.op = (2+ 11);
        !           338:        pp->in.left = p;
        !           339:        upput( pp );
        !           340:        pp->in.op = 97;
        !           341: }
        !           342: conput( p )
        !           343: register NODE *p;
        !           344: {
        !           345:        switch( p->in.op )
        !           346:        {
        !           347:        case 4:
        !           348:                acon( p );
        !           349:                return;
        !           350:        case 94:
        !           351:                printf( "%s", rnames[p->tn.rval] );
        !           352:                return;
        !           353:        default:
        !           354:                cerror( "illegal conput" );
        !           355:        }
        !           356: }
        !           357: insput( p )
        !           358: NODE *p;
        !           359: {
        !           360:        cerror( "insput" );
        !           361: }
        !           362: upput( p )
        !           363: NODE *p;
        !           364: {
        !           365:        register NODE *r, *l, *pp;
        !           366:        register o;
        !           367:        pp = ( (2+ 11) == p->in.op ) ? p->in.left : p ;
        !           368:        o = pp->in.op;
        !           369:        if( o==2 || o==(2+ 11) || o==95 || o==116 || o==117 )
        !           370:        {
        !           371:                printf( "*" );
        !           372:                adrput(pp);
        !           373:                return;
        !           374:        }
        !           375:        if( o==4 )
        !           376:        {
        !           377:                acon( pp );
        !           378:                sideff = 0;
        !           379:                return;
        !           380:        }
        !           381:        if( o == 6 )
        !           382:        {
        !           383:                r = pp->in.right;
        !           384:                l = pp->in.left;
        !           385:                if( l->in.op == 94 && r->in.op == 4 )
        !           386:                {
        !           387:                        acon( r );
        !           388:                        pp = pp->in.left;
        !           389:                }
        !           390:                else
        !           391:                {
        !           392:                        
        !           393:                        
        !           394:                        if( l->in.op == 2+ 14 )
        !           395:                        { 
        !           396:                                adrput( l->in.left );
        !           397:                                l = r;
        !           398:                        }
        !           399:                        else
        !           400:                        {
        !           401:                                p->in.left = r;
        !           402:                                adrput( p );
        !           403:                                p->in.left = pp;  
        !           404:                        }
        !           405:                        if( l->in.op == 64 ) l = l->in.left;
        !           406:                        if( l->in.op != 94 ) cerror("illegal address");
        !           407:                        printf( "[%s]", rnames[l->tn.rval] );
        !           408:                        return;
        !           409:                }
        !           410:        }
        !           411:        else if( o == 8 )
        !           412:        {
        !           413:                r = pp->in.right;
        !           414:                if( r->tn.op != 4 || r->tn.name ) cerror("illegal address");
        !           415:                r->tn.lval = -r->tn.lval;
        !           416:                acon( r );
        !           417:                r->tn.lval = -r->tn.lval;
        !           418:                pp = pp->in.left;
        !           419:        }
        !           420:        else if( o == 1+ 8 )
        !           421:        {
        !           422:                r = pp->in.right;
        !           423:                if( r->tn.op != 4 ) cerror("illegal address");
        !           424:                r = pp->in.left;
        !           425:                if( r->tn.op != 94 ) cerror("illegal address");
        !           426:                
        !           427:                printf( "-(%s)", rnames[r->tn.rval] );
        !           428:                sideff = 1;  
        !           429:                return;
        !           430:        }
        !           431:        else if( o == 78 )
        !           432:        {
        !           433:                r = pp->in.right;
        !           434:                if( r->tn.op != 4 ) cerror("illegal address");
        !           435:                r = pp->in.left;
        !           436:                if( r->tn.op != 94 ) cerror("illegal address");
        !           437:                if( sideff ) printf( "(%s)+", rnames[r->tn.rval] );
        !           438:                else printf( "(%s)", rnames[r->tn.rval] );
        !           439:                return;
        !           440:        }
        !           441:        if( pp->tn.op != 94 ) cerror("illegal address");
        !           442:        printf( "(%s)", rnames[pp->tn.rval] );
        !           443:        return;
        !           444: }
        !           445: adrput( p )
        !           446: register NODE *p;
        !           447: {
        !           448:        
        !           449:        register o;
        !           450:        while( (o=p->in.op) == 103 || o==104 )
        !           451:        {
        !           452:                p = p->in.left;
        !           453:                o = p->in.op;
        !           454:        }
        !           455:        switch( o )
        !           456:        {
        !           457:        case 2:
        !           458:                acon( p );
        !           459:                sideff = 0;
        !           460:                return;
        !           461:        case 4:
        !           462:                
        !           463:                printf( "$" );
        !           464:                acon( p );
        !           465:                sideff = 0;
        !           466:                return;
        !           467:        case 94:
        !           468:                printf( "%s", rnames[p->tn.rval] );
        !           469:                sideff = 0;
        !           470:                return;
        !           471:        case (2+ 11):
        !           472:                upput( p );
        !           473:                return;
        !           474:        case 95:
        !           475:                sideff = 0;
        !           476:                printf( "%ld(fp)", p->tn.lval - maxboff );
        !           477:                return;
        !           478:        case 116:
        !           479:                sideff = 0;
        !           480:                printf( "%ld(fp)", p->tn.lval );
        !           481:                return;
        !           482:        case 117:
        !           483:                sideff = 0;
        !           484:                printf( "%ld(ap)", p->tn.lval );
        !           485:                return;
        !           486:        default:
        !           487:                cerror( "illegal address" );
        !           488:                return;
        !           489:        }
        !           490: }
        !           491: acon(p)
        !           492: NODE *p;
        !           493: { 
        !           494:        if( p->tn.name == 0 )
        !           495:        {       
        !           496:                printf( "%ld", p->tn.lval);
        !           497:        }
        !           498:        else if( p->tn.lval == 0 )
        !           499:        {       
        !           500:                printf( "%s", p->tn.name );
        !           501:        }
        !           502:        else
        !           503:        {                               
        !           504:                printf( "%s+%ld", p->tn.name, p->tn.lval );
        !           505:        }
        !           506: }
        !           507: char *
        !           508: ccbranches[] = {
        !           509:        "       jeql    L%d\n",
        !           510:        "       jneq    L%d\n",
        !           511:        "       jleq    L%d\n",
        !           512:        "       jlss    L%d\n",
        !           513:        "       jgeq    L%d\n",
        !           514:        "       jgtr    L%d\n",
        !           515:        "       jlequ   L%d\n",
        !           516:        "       jlssu   L%d\n",
        !           517:        "       jgequ   L%d\n",
        !           518:        "       jgtru   L%d\n",
        !           519:        };
        !           520: cbgen( o, lab, mode )
        !           521: int o, lab, mode;
        !           522: { 
        !           523:        if( !o ) printf( "      jbr     L%d\n", lab );
        !           524:        else    if( o > 89 ) cerror( "bad conditional branch: %s", opst[o] );
        !           525:        else printf( ccbranches[o-80], lab );
        !           526: }
        !           527: special()
        !           528: {
        !           529:        cerror("reached special");
        !           530: }

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