Return to t2print.c CVS log

Up to [Research Unix] / researchv8dc / cmd / ccom / common

Annotation of researchv8dc/cmd/ccom/common/t2print.c, revision 1.1

1.1     ! root        1: # include "mfile2.h"
        !             2: 
        !             3: char *cnames[] = 
        !             4: {
        !             5:        "CEFF",
        !             6:        "NRGS",
        !             7:        "CCC",
        !             8:        0,
        !             9: };
        !            10: 
        !            11: prgoal( goal ) 
        !            12: register goal;
        !            13: {
        !            14:        /* print a nice-looking description of goal */
        !            15: 
        !            16:        register i, flag;
        !            17: 
        !            18:        flag = 0;
        !            19:        for( i=0; cnames[i]; ++i )
        !            20:        {
        !            21:                if( goal & (1<<i) )
        !            22:                {
        !            23:                        if( flag ) printf( "|" );
        !            24:                        ++flag;
        !            25:                        printf( cnames[i] );
        !            26:                }
        !            27:        }
        !            28:        if( !flag ) printf( "?%o", goal );
        !            29: 
        !            30: }
        !            31: 
        !            32: #ifndef NODBG
        !            33: e2print( p )
        !            34: register NODE *p; 
        !            35: {
        !            36:        printf( "\n********* costs=(0,...,NRGS;EFF;TEMP;CC)\n" );
        !            37:        e22print( p ,"T");
        !            38:        printf("=========\n");
        !            39: }
        !            40: 
        !            41: e22print( p ,s)
        !            42: register NODE *p; 
        !            43: char *s;
        !            44: {
        !            45:        static down=0;
        !            46:        register ty;
        !            47: 
        !            48:        ty = optype( p->tn.op );
        !            49:        if( ty == BITYPE )
        !            50:        {
        !            51:                ++down;
        !            52:                e22print( p->in.right ,"R");
        !            53:                --down;
        !            54:        }
        !            55:        e222print( down, p, s );
        !            56: 
        !            57:        if( ty != LTYPE )
        !            58:        {
        !            59:                ++down;
        !            60:                e22print( p->in.left, "L" );
        !            61:                --down;
        !            62:        }
        !            63: }
        !            64: 
        !            65: e222print( down, p, s )
        !            66: NODE *p; 
        !            67: char *s;
        !            68: {
        !            69:        /* print one node */
        !            70:        int i, d;
        !            71: 
        !            72:        for( d=down; d>1; d -= 2 ) printf( "\t" );
        !            73:        if( d ) printf( "    " );
        !            74: 
        !            75:        printf( "%s.%d) op= '%s'",s, (int)(p-node), opst[p->in.op] );
        !            76:        switch( p->in.op ) 
        !            77:        {
        !            78:                 /* special cases */
        !            79:        case REG:
        !            80:                printf( " %s", rnames[p->tn.rval] );
        !            81:                break;
        !            82: 
        !            83:        case ICON:
        !            84:        case NAME:
        !            85:        case VAUTO:
        !            86:        case VPARAM:
        !            87:        case TEMP:
        !            88:                printf( " " );
        !            89:                adrput( p );
        !            90:                break;
        !            91: 
        !            92:        case STCALL:
        !            93:        case UNARY STCALL:
        !            94:                printf( " args=%d", p->stn.argsize );
        !            95:        case STARG:
        !            96:        case STASG:
        !            97:                printf( " size=%d", p->stn.stsize );
        !            98:                printf( " align=%d", p->stn.stalign );
        !            99:                break;
        !           100: 
        !           101:        case GENBR:
        !           102:                printf( " %d (%s)", p->bn.label, opst[p->bn.lop] );
        !           103:                break;
        !           104: 
        !           105:        case CALL:
        !           106:        case UNARY CALL:
        !           107:                printf( " args=%d", p->stn.argsize );
        !           108:                break;
        !           109: 
        !           110:        case GENUBR:
        !           111:        case GENLAB:
        !           112:                printf( " %d", p->bn.label );
        !           113:                break;
        !           114: 
        !           115:        case FUNARG:
        !           116:                printf( " offset=%d", p->tn.rval );
        !           117: 
        !           118:        }
        !           119: 
        !           120:        printf( ", " );
        !           121:        t2print( p->in.type );
        !           122:        printf( ", c=[" );
        !           123:        for( i=0; i<NRGS; ++i ) cprt( p->in.cst[i], "," );
        !           124:        cprt( p->in.cst[NRGS], "; " );
        !           125:        cprt( p->in.cst[CEFF], "; " );
        !           126:        cprt( p->in.cst[CTEMP], "; " );
        !           127:        cprt( p->in.cst[CCC], "]" );
        !           128:        if( p->tn.goal == CEFF ) printf( " (EFF)\n" );
        !           129:        else if( p->tn.goal == CCC ) printf( " (CC)\n" );
        !           130:        else if( p->tn.goal != NRGS ) printf( "(BAD GOAL: %d)\n", p->tn.goal );
        !           131:        else printf( "\n" );
        !           132: }
        !           133: 
        !           134: t2print( t )
        !           135: TWORD t;
        !           136: {
        !           137:        int i;
        !           138:        static struct {
        !           139:                TWORD mask;
        !           140:                char * string;
        !           141:                } t2tab[] = {
        !           142:                        TANY, "ANY",
        !           143:                        TINT, "INT",
        !           144:                        TUNSIGNED, "UNSIGNED",
        !           145:                        TCHAR, "CHAR",
        !           146:                        TUCHAR, "UCHAR",
        !           147:                        TSHORT, "SHORT",
        !           148:                        TUSHORT, "USHORT",
        !           149:                        TLONG, "LONG",
        !           150:                        TULONG, "ULONG",
        !           151:                        TFLOAT, "FLOAT",
        !           152:                        TDOUBLE, "DOUBLE",
        !           153:                        TPOINT, "POINTER",
        !           154:                        TPOINT2, "POINTER2",
        !           155:                        TSTRUCT, "STRUCT",
        !           156:                        TVOID, "VOID",
        !           157:                        0, 0
        !           158:                        };
        !           159: 
        !           160:        for( i=0; t && t2tab[i].mask; ++i ) {
        !           161:                if( (t&t2tab[i].mask) == t2tab[i].mask ) {
        !           162:                        printf( " %s", t2tab[i].string );
        !           163:                        t ^= t2tab[i].mask;
        !           164:                        }
        !           165:                }
        !           166:        }
        !           167: 
        !           168: # else
        !           169: e2print( p )
        !           170: NODE *p; 
        !           171: {
        !           172:        werror( "e2print not compiled" );
        !           173: }
        !           174: e222print( p, s )
        !           175: NODE *p; 
        !           176: char *s;
        !           177: {
        !           178:        werror( "e222print not compiled" );
        !           179: }
        !           180: # endif
        !           181: cprt( c, s )
        !           182: register char *s; 
        !           183: register c;
        !           184: {
        !           185:        if( c >= INFINITY ) printf( "*%s", s );
        !           186:        else printf( "%d%s", c, s );
        !           187: }

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