msdump.c

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C语言 代码 · 共 862 行 · 第 1/2 页

    case MS_RT_TYP_CURRENCY:
        printf( "currency" );
        switch( t & MS_RT_SZ_FIELD ) {
        case MS_RT_SZ_01:
            printf( "_8 " );
            break;
        }
        break;
    }
    switch( t & MS_RT_MD_FIELD ) {
    case MS_RT_MD_NEAR_PTR:
        printf( "near * " );
        break;
    case MS_RT_MD_FAR_PTR:
        printf( "far * " );
        break;
    case MS_RT_MD_HUGE_PTR:
        printf( "huge * " );
        break;
    case MS_RT_MD_DIRECT:
        break;
    }
}

void dumpLeaf( unsigned *len )
{
    uint_16 u2;
    uint_32 u4;
    int_8 s1;
    int_16 s2;
    int_32 s4;
    int leaf;
    unsigned slen;
    unsigned idx;

    leaf = getb();
    --*len;
    if( leaf < 0x80 ) {
        printf( "%u ", leaf );
        return;
    }
    switch( leaf ) {
    case MS_BCL_INT_8:
        s1 = getb();
        --*len;
        printf( "%d ", s1 );
        break;
    case MS_BCL_INT_16:
        s2 = getw();
        *len -= 2;
        printf( "%d ", s2 );
        break;
    case MS_BCL_INT_32:
        s4 = getl();
        *len -= 4;
        printf( "%ld ", s4 );
        break;
    case MS_BCL_UINT_16:
        u2 = getw();
        *len -= 2;
        printf( "%u ", u2 );
        break;
    case MS_BCL_UINT_32:
        u4 = getl();
        *len -= 4;
        printf( "%lu ", u4 );
        break;
    case MS_BCL_INDEX:
        if( obj_metaware ) {
            idx = getb();
            --*len;
            printf( "@%x ", idx + ( FIRST_DEFINED_TYPE - 1 ) );
            break;
        }
        idx = getw();
        *len -= 2;
        if( idx < FIRST_DEFINED_TYPE ) {
            dumpSpecial( idx );
            break;
        }
        printf( "@%x ", idx );
        break;
    case MS_BCL_STRING:
        slen = getb();
        --*len;
        putchar( '"' );
        while( slen ) {
            putchar( getb() );
            --*len;
            --slen;
        }
        putchar( '"' );
        putchar( ' ' );
        break;
    default:
        dumpCode( leaf, translateType );
    }
}

void dumpHexRec( void )
{
    char *p;

    if( dump_hex == 0 ) {
        return;
    }
    p = record;
    while( p != in_record ) {
        printf( "%02x ", *p );
        ++p;
    }
    putchar( '\n' );
    putchar( '\n' );
}

void dumpTypes( unsigned len )
{
    int linkage;
    unsigned tlen;
    int c;
    int lo, hi;
    int packed;
    int calling;

    for(;;) {
        if( len == 1 ) break;
        in_record = record;
        linkage = getb();
        lo = getb();
        if( linkage == 0 && lo == 0 ) {
            tlen = len - 3;
            len -= 2;
        } else {
            hi = getb();
            tlen = ( hi << 8 ) | lo;
            len -= 3;
        }
        printf( "%3x: %s (%u) ", type_index, linkage ? "T" : "F", tlen );
        ++type_index;
        len -= tlen;
        c = getb();
        --tlen;
        dumpCode( c, translateType );
        switch( c ) {
        case MS_SL_POINTER:
            dumpCode( getb(), translateType );
            --tlen;
            while( tlen ) {
                dumpLeaf( &tlen );
            }
            break;
        case MS_SL_SCALAR:
            dumpLeaf( &tlen );
            dumpSpecial( getb() );
            --tlen;
            while( tlen ) {
                dumpLeaf( &tlen );
            }
            break;
        case MS_SL_STRUCTURE:
            dumpLeaf( &tlen );
            dumpLeaf( &tlen );
            dumpLeaf( &tlen );
            dumpLeaf( &tlen );
            dumpLeaf( &tlen );
            packed = getb();
            --tlen;
            dumpCode( packed, translateType );
            flushRec( tlen );
            break;
        case MS_SL_PROCEDURE:
            dumpLeaf( &tlen );
            dumpLeaf( &tlen );
            calling = getb();
            --tlen;
            dumpCode( calling, translateType );
            dumpi( &tlen );
            dumpLeaf( &tlen );
            flushRec( tlen );
            break;
        case MS_SL_BITFIELD:
            putchar( ':' );
            dumpi( &tlen );
            dumpCode( getb(), translateType );
            dumpb();
            break;
        case MS_SL_ARRAY:
            while( tlen ) {
                dumpLeaf( &tlen );
            }
            break;
        case MS_SL_LIST:
            if( tlen ) {
                dumpLeaf( &tlen );
            }
            while( tlen ) {
                putchar( ',' );
                putchar( ' ' );
                dumpLeaf( &tlen );
            }
            break;
        default:
            flushRec( tlen );
        }
        putchar( '\n' );
        dumpHexRec();
    }
    getb();     /* checksum */
}

void dumpSymbols( unsigned len )
{
    unsigned slen;
    int c;

    for(;;) {
        if( len == 1 ) break;
        in_record = record;
        slen = getb();
        --len;
        printf( "(%u) ", slen );
        len -= slen;
        c = getb();
        --slen;
        if( c & MS_SYM_386_FLAG ) {
            obj_32 = 1;
        }
        c &= ~MS_SYM_386_FLAG;
        dumpCode( c, translateSymbol );
        switch( c ) {
        case MS_SYM_BP_RELATIVE:
            if( obj_32 ) {
                dumpl();
                slen -= 4;
            } else {
                dumpw();
                slen -= 2;
            }
            putchar( '@' );
            dumpw();
            slen -= 2;
            dumpName( &slen );
            break;
        case MS_SYM_LOCAL_SYM:
            if( obj_32 ) {
                dumpl();
                slen -= 4;
            } else {
                dumpw();
                slen -= 2;
            }
            dumpw();
            slen -= 2;
            putchar( '@' );
            dumpw();
            slen -= 2;
            dumpName( &slen );
            break;
        case MS_SYM_PROCEDURE_START:
            if( obj_32 ) {
                dumpl();
                slen -= 4;
            } else {
                dumpw();
                slen -= 2;
            }
            putchar( '@' );
            dumpw();
            slen -= 2;
            if( obj_metaware ) {
                dumpl();
                slen -= 4;
            } else {
                dumpw();
                slen -= 2;
            }
            dumpw();
            slen -= 2;
            if( obj_metaware ) {
                dumpl();
                slen -= 4;
            } else {
                dumpw();
                slen -= 2;
            }
            dumpw();
            slen -= 2;
            dumpb();
            dumpName( &slen );
            break;
        case MS_SYM_BLOCK_START:
            if( obj_32 ) {
                dumpl();
                slen -= 4;
            } else {
                dumpw();
                slen -= 2;
            }
            if( obj_metaware ) {
                dumpl();
                slen -= 4;
            } else {
                dumpw();
                slen -= 2;
            }
            dumpName( &slen );
            break;
        case MS_SYM_TYPEDEF_SYM:
            putchar( '@' );
            dumpw();
            slen -= 2;
            dumpName( &slen );
            break;
        case MS_SYM_CHANGE_DEF_SEG:
            dumpw();
            slen -= 2;
            dumpw();
            slen -= 2;
            break;
        default:
            flushRec( slen );
        }
        putchar( '\n' );
        dumpHexRec();
    }
    getb();     /* checksum */
}

void procLEDATA( unsigned len )
{
    unsigned seg_idx;

    seg_idx = geti( &len );
    if( seg_idx != type_seg && seg_idx != sym_seg ) {
        flushRec( len );
        return;
    }
    if( obj_32 ) {
        getl();
        len -= 4;
    } else {
        getw();
        len -= 2;
    }
    if( seg_idx == type_seg ) {
        dumpTypes( len );
    } else if( seg_idx == sym_seg ) {
        dumpSymbols( len );
    } else {
        flushRec( len );
    }
}

void main( int argc, char **argv )
{
    unsigned len;
    int rec;
    char *p;

    if( argc != 2 && argc != 3 ) {
        puts( "usage: MSDUMP <file> [-xm]" );
        puts( "-x     dump hex values of type/symbol records" );
        puts( "-m     use MetaWare CodeView interpretation" );
        puts( "options may be combined (i.e., -xm)" );
        exit( EXIT_FAILURE );
    }
    fp = fopen( argv[1], "rb" );
    if( fp == NULL ) {
        fatal( "could not open input file" );
    }
    dump_hex = 0;
    obj_32 = 0;
    obj_metaware = 0;
    if( argc == 3 ) {
        if( argv[2][0] == '-' || argv[2][0] == '/' ) {
            p = &argv[2][1];
            while( *p ) {
                switch( *p ) {
                case 'x':
                    dump_hex = 1;
                    break;
                case 'm':
                    obj_metaware = 1;
                    break;
                }
                ++p;
            }
        }
    }
    record_len = 256;
    record = memalloc( record_len );
    in_record = record;
    curr_lname = 1;
    curr_segdef = 1;
    for(;;) {
        rec = fgetc( fp );
        if( rec == EOF ) break;
        in_record = record;
        len = getw();
        if( len > record_len ) {
            record_len = (( len + 1 ) + 0x0f ) & ~0x0f;
            record = memrealloc( record, record_len );
            in_record = record;
        }
        switch( rec ) {
        case CMD_COMENT:
            procCOMENT( len );
            break;
        case CMD_LNAMES:
            procLNAMES( len );
            break;
        case CMD_SEGDEF:
        case CMD_SEGD32:
            procSEGDEF( len );
            break;
        case CMD_LEDATA:
        case CMD_LEDA32:
            procLEDATA( len );
            break;
        case CMD_TYPDEF:
            obj_metaware = 1;
            dumpTypes( len );
            break;
        default:
            flushRec( len );
        }
    }
    fclose( fp );
    exit( EXIT_SUCCESS );
}