madman.c

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

    max = *maxp;
    switch( radix ) {
    case 16:
        p = d;
#if !defined( __BIG_ENDIAN__ )
        p += mti->b.bits / BITS_PER_BYTE;
#endif
        for( len = 0; len < mti->b.bits / (BITS_PER_BYTE / 2); len += 2 ) {
#if !defined( __BIG_ENDIAN__ )
            --p;
#endif
            if( len < max ) {
                res[len+0] = DigitTab[ *p >>   4 ];
                res[len+1] = DigitTab[ *p &  0xf ];
            }
#if defined( __BIG_ENDIAN__ )
            ++p;
#endif
        }
        if( max > 0 )
            res[ min( len, max ) ] = '\0';
        *maxp = len;
        return( MS_OK );
    case 10:
        MADTypeInfoForHost( MTK_FLOAT, sizeof( val ), &host );
        ms = MADTypeConvert( mti, d, &host, &val, 0 );
        if( ms != MS_OK )
            return( ms );
        DoStrReal( (long_double *)&val, res, mti );
        *maxp = strlen( res );
        return( MS_OK );
    }
    return( MS_UNSUPPORTED );
}

#endif

mad_status MADTypeToString( unsigned radix, const mad_type_info *mti, const void *d, unsigned *max, char *buff )
{
    if( mti->b.handler_code == MAD_DEFAULT_HANDLING ) {
        switch( mti->b.kind ) {
        case MTK_INTEGER:
           if( IntTypeToString( radix, mti, d, max, buff ) == MS_OK ) return( MS_OK );
           break;
        case MTK_ADDRESS:
           if( AddrTypeToString( radix, mti, d, max, buff ) == MS_OK ) return( MS_OK );
           break;
#if !defined(MAD_OMIT_FLOAT_CVT)
        case MTK_FLOAT:
           if( FloatTypeToString( radix, mti, d, max, buff ) == MS_OK ) return( MS_OK );
           break;
        }
#endif
    }
    return( Active->rtns->MITypeToString( radix, mti, d, max, buff ) );
}

mad_status MADTypeHandleToString( unsigned radix, mad_type_handle th, const void *d, unsigned *max, char *buff )
{
    mad_type_info       mti;

    MADTypeInfo( th, &mti );
    return( MADTypeToString( radix, &mti, d, max, buff ) );
}


/*
 *      Machine Registers
 */

static unsigned DIGREGISTER DummyRegistersSize( void )
{
    return( 1 );
}

unsigned        MADRegistersSize( void )
{
    return( Active->rtns->MIRegistersSize() );
}

static mad_status DIGREGISTER DummyRegistersHost( mad_registers *mr )
{
    mr = mr;
    return( MS_OK );
}

mad_status      MADRegistersHost( mad_registers *mr )
{
    return( Active->rtns->MIRegistersHost( mr ) );
}

static mad_status DIGREGISTER DummyRegistersTarget( mad_registers *mr )
{
    mr = mr;
    return( MS_OK );
}

mad_status      MADRegistersTarget( mad_registers *mr )
{
    return( Active->rtns->MIRegistersTarget( mr ) );
}

static walk_result DIGREGISTER DummyRegSetWalk( mad_type_kind tk, MI_REG_SET_WALKER *wk, void *d )
{
    tk = tk;
    wk = wk;
    d  = d;
    return( WR_CONTINUE );
}

struct regset_glue {
    MAD_REG_SET_WALKER  *wk;
    void                *d;
};

static walk_result DIGCLIENT RegSetGlue( const mad_reg_set_data *rsd, void *d )
{
    struct regset_glue  *gd = d;

    return( gd->wk( rsd, gd->d ) );
}

walk_result     MADRegSetWalk( mad_type_kind tk, MAD_REG_SET_WALKER *wk, void *d )
{
    struct regset_glue  glue;

    glue.wk = wk;
    glue.d  = d;
    return( Active->rtns->MIRegSetWalk( tk, &RegSetGlue, &glue ) );
}

static mad_string DIGREGISTER DummyRegSetName( const mad_reg_set_data *rsd )
{
    rsd = rsd;
    return( MSTR_NIL );
}

mad_string      MADRegSetName( const mad_reg_set_data *rsd )
{
    return( Active->rtns->MIRegSetName( rsd ) );
}

static unsigned DIGREGISTER DummyRegSetLevel( const mad_reg_set_data *rsd, unsigned max, char *buff )
{
    rsd = rsd;
    max = max;
    if( buff != NULL ) *buff = '\0';
    return( 0 );
}

unsigned        MADRegSetLevel( const mad_reg_set_data *rsd, unsigned max, char *buff )
{
    return( Active->rtns->MIRegSetLevel( rsd, max, buff ) );
}

static unsigned DIGREGISTER DummyRegSetDisplayGrouping( const mad_reg_set_data *rsd )
{
    rsd = rsd;
    return( 0 );
}

unsigned        MADRegSetDisplayGrouping( const mad_reg_set_data *rsd )
{
    return( Active->rtns->MIRegSetDisplayGrouping( rsd ) );
}

static mad_status DIGREGISTER DummyRegSetDisplayGetPiece( const mad_reg_set_data *rsd, const mad_registers *mr, unsigned piece, char **descript, unsigned *max_descript, const mad_reg_info **reg, mad_type_handle *disp_type, unsigned *max_value )
{
    rsd = rsd;
    mr = mr;
    piece = piece;
    descript = descript;
    max_descript = max_descript;
    reg = reg;
    disp_type = disp_type;
    max_value = max_value;
    return( MS_FAIL );
}

mad_status      MADRegSetDisplayGetPiece( const mad_reg_set_data *rsd, const mad_registers *mr, unsigned piece, char **descript, unsigned *max_descript, const mad_reg_info **reg, mad_type_handle *disp_type, unsigned *max_value )
{
    return( Active->rtns->MIRegSetDisplayGetPiece( rsd, mr, piece, descript,
                max_descript, reg, disp_type, max_value ) );
}

static mad_status DIGREGISTER DummyRegSetDisplayModify( const mad_reg_set_data *rsd, const mad_reg_info *reg, const mad_modify_list **possible, unsigned *num_possible )
{
    rsd = rsd;
    reg = reg;
    *possible = NULL;
    *num_possible = 0;
    return( MS_FAIL );
}

mad_status      MADRegSetDisplayModify( const mad_reg_set_data *rsd, const mad_reg_info *reg, const mad_modify_list **possible, unsigned *num_possible )
{
    return( Active->rtns->MIRegSetDisplayModify( rsd, reg, possible, num_possible ) );
}


static const mad_toggle_strings *DIGREGISTER DummyRegSetDisplayToggleList( const mad_reg_set_data *rsd )
{
    rsd = rsd;
    return( EmptyToggleList );
}

const mad_toggle_strings *MADRegSetDisplayToggleList( const mad_reg_set_data *rsd )
{
    return( Active->rtns->MIRegSetDisplayToggleList( rsd ) );
}

static unsigned DIGREGISTER DummyRegSetDisplayToggle( const mad_reg_set_data *rsd, unsigned on, unsigned off )
{
    rsd = rsd;
    on = on;
    off = off;
    return( 0 );
}

unsigned        MADRegSetDisplayToggle( const mad_reg_set_data *rsd, unsigned on, unsigned off )
{
    return( Active->rtns->MIRegSetDisplayToggle( rsd, on, off ) );
}

static mad_status DIGREGISTER DummyRegModified( const mad_reg_set_data *rsd, const mad_reg_info *ri, const mad_registers *old, const mad_registers *curr )
{
    rsd = rsd;
    ri = ri;
    old = old;
    curr = curr;
    return( MS_OK );
}

mad_status      MADRegModified( const mad_reg_set_data *rsd, const mad_reg_info *ri, const mad_registers *old, const mad_registers *curr )
{
    return( Active->rtns->MIRegModified( rsd, ri, old, curr ) );
}

static mad_status DIGREGISTER DummyRegInspectAddr( const mad_reg_info *ri, const mad_registers *mr, address *a )
{
    ri = ri;
    mr = mr;
    a = a;
    return( MS_FAIL );
}

mad_status      MADRegInspectAddr( const mad_reg_info *ri, const mad_registers *mr, address *a )
{
    return( Active->rtns->MIRegInspectAddr( ri, mr, a ) );
}

static walk_result DIGREGISTER DummyRegWalk( const mad_reg_set_data *rsd, const mad_reg_info *ri, MI_REG_WALKER *wk, void *d )
{
    rsd = rsd;
    ri = ri;
    wk = wk;
    d = d;
    return( WR_CONTINUE );
}

struct reg_glue {
    MAD_REG_WALKER      *wk;
    void                *d;
};

static walk_result DIGCLIENT RegGlue( const mad_reg_info *ri, int has_sublist, void *d )
{
    struct reg_glue     *gd = d;

    return( gd->wk( ri, has_sublist, gd->d ) );
}

static walk_result DIGCLIENT AllRegWalk( const mad_reg_set_data *rsd, void *d )
{
    return( Active->rtns->MIRegWalk( rsd, NULL, &RegGlue, d ) );
}

walk_result     MADRegWalk( const mad_reg_set_data *rsd, const mad_reg_info *ri, MAD_REG_WALKER *wk, void *d )
{
    struct reg_glue     glue;

    glue.wk = wk;
    glue.d  = d;
    if( rsd == NULL && ri == NULL ) {
        return( Active->rtns->MIRegSetWalk( MTK_ALL, &AllRegWalk, &glue ) );
    }
    return( Active->rtns->MIRegWalk( rsd, ri, &RegGlue, &glue ) );
}

struct full_name_component {
    struct full_name_component  *parent;
    mad_reg_info const          *ri;
};

struct full_name {
    struct full_name_component  *components;
    mad_reg_info  const         *ri;
    const char                  *op;
    char                        *buff;
    unsigned                    max;
    unsigned                    len;
};

static walk_result FindFullName( const mad_reg_info *ri, int has_sublist, void *d )
{
    struct full_name            *name = d;
    struct full_name_component  curr;
    struct full_name_component  *p;
    struct full_name_component  *h;
    struct full_name_component  *t;
    walk_result                 wr;
    unsigned                    op_len;
    unsigned                    amount;
    int                         first;

    curr.parent = name->components;
    name->components = &curr;
    curr.ri = ri;
    if( ri == name->ri ) {
        op_len = strlen( name->op );
        /* reverse the list, calculate length */
        p = name->components;
        h = NULL;
        while( p != NULL ) {
            name->len += strlen( p->ri->name ) + op_len;
            t = p->parent;
            p->parent = h;
            h = p;
            p = t;
        }
        name->len -= op_len; /* take off extra op_len */
        /* lay down name */
        first = 1;
        p = h;
        while( p != NULL ) {
            if( !first ) {
                amount = name->max;
                if( amount > op_len  ) amount = op_len;
                memcpy( name->buff, name->op, amount );
                name->buff += amount;
                name->max  -= amount;
            }
            first = 0;
            amount = strlen( p->ri->name );
            if( amount > name->max ) amount = name->max;
            memcpy( name->buff, p->ri->name, amount );
            name->buff += amount;
            name->max  -= amount;
            p = p->parent;
        }
        return( WR_STOP );
    }
    wr = WR_CONTINUE;
    if( has_sublist ) {
        wr = MADRegWalk( NULL, ri, FindFullName, name );
    }
    name->components = curr.parent;
    return( wr );
}

unsigned        MADRegFullName( const mad_reg_info *ri, const char *op, unsigned max, char *buff )
{
    struct full_name    name;

    name.components = NULL;
    name.ri = ri;
    name.op = op;
    name.buff = buff;
    name.max = max;
    name.len = 0;
    MADRegWalk( NULL, NULL, FindFullName, &name );
    if( max > 0 ) {
        buff[ min( name.len, max ) ] = '\0';
    }
    return( name.len );
}

static void DIGREGISTER DummyRegSpecialGet( mad_special_reg sr, const mad_registers *mr, addr_ptr *a )
{
    sr = sr;
    mr = mr;
    a->segment = 0;
    a->offset = 0;
}

void            MADRegSpecialGet( mad_special_reg sr, const mad_registers *mr, addr_ptr *a )
{
    Active->rtns->MIRegSpecialGet( sr, mr, a );
}

static void DIGREGISTER DummyRegSpecialSet( mad_special_reg sr, mad_registers *mr, const addr_ptr *a )
{
    sr = sr;
    mr = mr;
    a = a;
}

void            MADRegSpecialSet( mad_special_reg sr, mad_registers *mr, const addr_ptr *a )
{
    Active->rtns->MIRegSpecialSet( sr, mr, a );
}

static unsigned DIGREGISTER DummyRegSpecialName( mad_special_reg sr, const mad_registers *mr, mad_address_format af, unsigned max, char *buff )
{
    sr = sr;
    mr = mr;
    af = af;
    max = max;
    buff = buff;
    return( 0 );
}

unsigned        MADRegSpecialName( mad_special_reg sr, const mad_registers *mr, mad_address_format af, unsigned max, char *buff )
{
    return( Active->rtns->MIRegSpecialName( sr, mr, af, max, buff ) );
}

static const mad_reg_info *DIGREGISTER DummyRegFromContextItem( context_item ci )
{
    ci = ci;
    return( NULL );
}

const mad_reg_info *MADRegFromContextItem( context_item ci )
{
    return( Active->rtns->MIRegFromContextItem( ci ) );
}

static void DIGREGISTER DummyRegUpdateStart( mad_registers *mr, unsigned flags, unsigned bit_start, unsigned bit_size )
{
    mr = mr;
    flags = flags;
    bit_start = bit_start;
    bit_size = bit_size;
}

void            MADRegUpdateStart( mad_registers *mr, unsigned flags, unsigned bit_start, unsigned bit_size )
{
    Active->rtns->MIRegUpdateStart( mr, flags, bit_start, bit_size );
}

static void DIGREGISTER DummyRegUpdateEnd( mad_registers *mr, unsigned flags, unsigned bit_start, unsigned bit_size )
{
    mr = mr;
    flags = flags;
    bit_start = bit_start;
    bit_size = bit_size;
}

void            MADRegUpdateEnd( mad_registers *mr, unsigned flags, unsigned bit_start, unsigned bit_size )
{
    Active->rtns->MIRegUpdateEnd( mr, flags, bit_start, bit_size );
}