can2txt.c

开放源码的编译器open watcom 1.6.0版的源代码

        PrtFmt( " length %X\n" END, type->d.charb.length );
        break;

    case CANT_CHARBLOCK_IND:
        PrtFmt( " length_type %x\n", type->d.charbi.length_type );
        printAddrHdl( INDENT "length ", type->d.charbi.length );
        PrtFmt( END );
        break;

    default:
/**/    never_reach();
    }
    return( 0 );
}

STATIC const char *regNames[] = {
/*CANS_REG_AL   */  "AL",
/*CANS_REG_AH   */  "AH",
/*CANS_REG_BL   */  "BL",
/*CANS_REG_BH   */  "BH",
/*CANS_REG_CL   */  "CL",
/*CANS_REG_CH   */  "CH",
/*CANS_REG_DL   */  "DL",
/*CANS_REG_DH   */  "DH",
/*CANS_REG_AX   */  "AX",
/*CANS_REG_BX   */  "BX",
/*CANS_REG_CX   */  "CX",
/*CANS_REG_DX   */  "DX",
/*CANS_REG_SI   */  "SI",
/*CANS_REG_DI   */  "DI",
/*CANS_REG_BP   */  "BP",
/*CANS_REG_SP   */  "SP",
/*CANS_REG_CS   */  "CS",
/*CANS_REG_SS   */  "SS",
/*CANS_REG_DS   */  "DS",
/*CANS_REG_ES   */  "ES",
/*CANS_REG_ST0  */  "ST0",
/*CANS_REG_ST1  */  "ST1",
/*CANS_REG_ST2  */  "ST2",
/*CANS_REG_ST3  */  "ST3",
/*CANS_REG_ST4  */  "ST4",
/*CANS_REG_ST5  */  "ST5",
/*CANS_REG_ST6  */  "ST6",
/*CANS_REG_ST7  */  "ST7",
/*CANS_REG_EAX  */  "EAX",
/*CANS_REG_EBX  */  "EBX",
/*CANS_REG_ECX  */  "ECX",
/*CANS_REG_EDX  */  "EDX",
/*CANS_REG_ESI  */  "ESI",
/*CANS_REG_EDI  */  "EDI",
/*CANS_REG_EBP  */  "EBP",
/*CANS_REG_ESP  */  "ESP",
/*CANS_REG_FS   */  "FS",
/*CANS_REG_GS   */  "GS",
/*CANS_REG_FLAGS*/  "FLAGS"
};

#define IND_WIDTH   4
#define MAX_SPACES  160

#pragma on (check_stack);
STATIC void doPrintSymbs( void ) {

    symb_handle hdl;
    symb_handle head;
    char        spaces[ MAX_SPACES + 1 ];
    char        *indent;
    char        *stg_class;
    unsigned    i;
    enum {
        NORMAL_LOCALS,
        WAITING_FOR_PARM,
        IN_PARMS,
        NEXT_IS_RET_VAL
    }           locals_state;

    spaces[ MAX_SPACES ] = 0;
    indent = spaces + MAX_SPACES;
    memset( spaces, ' ', MAX_SPACES );

    locals_state = NORMAL_LOCALS;
    head = CanSGetHead();
    if( head == NULL ) {
        return;
    }
    hdl = head;
    do {
        switch( hdl->class ) {
        case CANS_CHANGE_SEG:
            PrtFmt( "%sCHANGE_SEG\n", indent );
            indent -= IND_WIDTH;
            printAddrHdl( indent, hdl->d.cseg.seg );
            indent += IND_WIDTH;
            break;
        case CANS_BLOCK:
            PrtFmt( "%sBLOCK name \"%s\" type %x start_offset %X size %X\n",
                indent, NameGet( hdl->d.nat.name_hdl ), hdl->d.nat.type_hdl,
                hdl->d.block.start_offset, hdl->d.block.size );
            locals_state = WAITING_FOR_PARM;
            indent -= IND_WIDTH;
            break;
        case CANS_BP_OFFSET:
        case CANS_MEM_LOC:
        case CANS_REGISTER:
        case CANS_IND_REG:
            switch( locals_state ) {
            case WAITING_FOR_PARM:
                locals_state = IN_PARMS;
                PrtFmt( "%sParms:\n", indent );
                indent -= IND_WIDTH;
                break;
            case NEXT_IS_RET_VAL:
                PrtFmt( "%sReturn Value:\n", indent );
                indent -= IND_WIDTH;
                break;
            }
            switch( hdl->class ) {
            case CANS_BP_OFFSET:
                PrtFmt( "%sBP_OFFSET %X name \"%s\" type %x\n", indent,
                    hdl->d.bpoff.offset, NameGet( hdl->d.nat.name_hdl ),
                    hdl->d.nat.type_hdl );
                break;
            case CANS_MEM_LOC:
                if( hdl->d.memloc.is_static ) {
                    stg_class = "static";
                } else {
                    stg_class = "extern";
                }
                PrtFmt( "%sMEM_LOC (%s) name \"%s\" type %x\n",indent,stg_class,
                    NameGet( hdl->d.nat.name_hdl ), hdl->d.nat.type_hdl );
                indent -= IND_WIDTH;
                printAddrHdl( indent, hdl->d.memloc.mem_hdl );
                indent += IND_WIDTH;
                break;
            case CANS_REGISTER:
                PrtFmt( "%sREGISTER name \"%s\" type %x: ", indent,
                    NameGet( hdl->d.nat.name_hdl ), hdl->d.nat.type_hdl );
                for( i = hdl->d.reg.num_regs; i > 0; --i ) {
                    PrtFmt( "%s%c", regNames[ hdl->d.reg.reg[i-1] ],
                        ( i > 1 ) ? ':' : '\n' );
                }
                break;
            case CANS_IND_REG:
                PrtFmt( "%sIND_REG name \"%s\" type %x %s ", indent,
                    NameGet( hdl->d.nat.name_hdl ), hdl->d.nat.type_hdl,
                    hdl->d.indr.calloc ? "CALLOC" : "RALLOC" );
                if( hdl->d.indr.far_ptr ) {
                    PrtFmt( "%s:%s\n", regNames[ hdl->d.indr.seg ],
                        regNames[ hdl->d.indr.off ] );
                } else {
                    PrtFmt( "%s\n", regNames[ hdl->d.indr.off ] );
                }
                break;
            }
            if( locals_state == NEXT_IS_RET_VAL ) {
                locals_state = NORMAL_LOCALS;
                indent += IND_WIDTH;
            }
            break;
        case CANS_PROLOG:
            switch( locals_state ) {
            case WAITING_FOR_PARM:
                locals_state = NORMAL_LOCALS;
                break;
            case IN_PARMS:
                indent += IND_WIDTH;
                locals_state = NORMAL_LOCALS;
                break;
            }
            if( hdl->d.prolog.has_ret_val ) {
                locals_state = NEXT_IS_RET_VAL;
            }
            if( hdl->d.prolog.has_ret_addr ) {
                PrtFmt( "%sPROLOG size %t ret_addr_offset %X\n", indent,
                    hdl->d.prolog.size, hdl->d.prolog.ret_addr_offset );
            } else {
                PrtFmt( "%sPROLOG size %t\n", indent, hdl->d.prolog.size );
            }
            break;
        case CANS_EPILOG:
            PrtFmt( "%sEPILOG size %t\n", indent, hdl->d.epilog.size );
            break;
        case CANS_BLOCK_END:
            indent += IND_WIDTH;
            PrtFmt( "%sBLOCK_END\n", indent );
            break;
        default:
/**/        never_reach();
        }
        if( indent < spaces + IND_WIDTH ) {
            indent = spaces + IND_WIDTH;
        }
        hdl = CanSFwd( hdl );
    } while( hdl != head );
}
#pragma off(check_stack);

STATIC void doPrintMisc( void ) {

    if( CanMisc.compiler != NULL ) {
              /* 12345678901234567 */
        PrtMsg( MSG_TXT_COMPILER, CanMisc.compiler );
    }
    if( CanMisc.processor == CAN_PROC_8086 ) {
        PrtMsg( MSG_TXT_8086_PRCSR );
    } else {
        PrtMsg( MSG_TXT_80X86_PRCSR, CanMisc.processor );
    }
/**/myassert( CanMisc.memory_model <= CAN_MODEL_TINY );
          /* 12345678901234567 */
    PrtMsg( MSG_TXT_MEM_MODEL, MSG_TXT_MODEL_0+CanMisc.memory_model );
/**/myassert( CanMisc.floating_point <= CAN_FLOAT_ALTERNATE );
    PrtMsg( MSG_TXT_FLOAT_PT, MSG_TXT_FP_0+CanMisc.floating_point );
    PrtMsg( MSG_TXT_OPTIMIZED, CanMisc.optimized ? MSG_TXT_YES : MSG_TXT_NO );
    PrtMsg( MSG_TXT_LINES_PRST,
                        CanMisc.lines_present ? MSG_TXT_YES : MSG_TXT_NO );
    PrtMsg( MSG_TXT_TYPES_PRST,
                        CanMisc.types_present ? MSG_TXT_YES : MSG_TXT_NO );
    PrtMsg( MSG_TXT_SYMBS_PRST,
                        CanMisc.symbs_present ? MSG_TXT_YES : MSG_TXT_NO );
/**/myassert( CanMisc.src_language <= CAN_LANG_BASIC );
    PrtMsg( MSG_TXT_SOURCE_LANG, MSG_TXT_LANG_0+CanMisc.src_language );
    PrtFmt( "\n" );
}

#pragma on (check_stack);
STATIC void center( const char *text ) {

    char        buf[81];
    unsigned    len;
    unsigned    spaces;

    len = strlen( text );
/**/myassert( len <= 80 );
    spaces = 40 - len / 2;
    memset( buf, ' ', spaces );
    buf[ spaces ] = 0;
    PrtFmt( "%s%s\n", buf, text );
    memset( buf + spaces, '-', len );
    buf[ spaces + len ] = 0;
    PrtFmt( "%s\n", buf );
}
#pragma off(check_stack);

STATIC void centerMsg( int msgnum ) {

    char        msgbuff[MAX_RESOURCE_SIZE];

    MsgGet( msgnum, msgbuff );
    center( msgbuff );
}

STATIC int can2txt( obj_rec *objr, pobj_state *state ) {

/**/myassert( objr != NULL && objr->command == CMD_MODEND );
/**/myassert( state != NULL && state->pass == POBJ_WRITE_PASS );
    objr = objr;
    state = state;
    centerMsg( MSG_TXT_MISC_INFO );
    doPrintMisc();
    if( CanMisc.types_present ) {
        centerMsg( MSG_TXT_TYPE_INFO );
        CanTWalk( NULL, doPrintType );
    }
    if( CanMisc.symbs_present ) {
        centerMsg( MSG_TXT_SYMB_INFO );
        doPrintSymbs();
    }
    return( 0 );
}

void Can2TxtInit( void ) {
/**********************/

    PObjRegister( CMD_MODEND, POBJ_WRITE_PASS, can2txt );
}

void Can2TxtFini( void ) {
/**********************/

    PObjUnRegister( CMD_MODEND, POBJ_WRITE_PASS, can2txt );
}