static char *DoMadLongConv( char *buff, size_t buff_len, unsigned long value, mad_radix radix, int size )
{
mad_radix old_radix;
mad_type_info mti;
old_radix = NewCurrRadix( radix );
MADTypeInfoForHost( MTK_INTEGER, size, &mti );
MADTypeToString( radix, &mti, &value, buff, &buff_len );
NewCurrRadix( old_radix );
return( buff + buff_len );
}
mad_status MADCLIENTRY( AddrToString )( address a, mad_type_handle th,
mad_label_kind lk, char *buff, unsigned buff_len )
{
mad_type_info mti;
addr_ptr item;
mad_type_info host;
MADTypeInfo( th, &mti );
MADTypeInfoForHost( MTK_ADDRESS, sizeof( address ), &host );
MADTypeConvert( &host, &a, &mti, &item, 0 );
MADTypeToString( 16, &mti, &item, buff, &buff_len );
return( MS_OK );
}
char *AddrTypeToString( address *a, mad_type_handle th, char *buff, size_t buff_len )
{
mad_type_info mti;
item_mach item;
mad_type_info host;
MADTypeInfo( th, &mti );
MADTypeInfoForHost( MTK_ADDRESS, sizeof( address ), &host );
AddrFix( a );
MADTypeConvert( &host, a, &mti, &item, 0 );
MADTypeToString( 16, &mti, &item, buff, &buff_len );
return( buff + buff_len );
}
void ToItemMAD( stack_entry *entry, item_mach *tmp, mad_type_info *mti )
{
unsigned bytes;
mad_type_info src;
bytes = mti->b.bits / BITS_PER_BYTE;
switch( mti->b.kind ) {
case MTK_INTEGER:
ConvertTo( entry, TK_INTEGER, TM_UNSIGNED, bytes );
MADTypeInfoForHost( MTK_INTEGER, sizeof( entry->v.uint ), &src );
break;
case MTK_ADDRESS:
if( mti->a.seg.bits == 0 ) {
ConvertTo( entry, TK_ADDRESS, TM_NEAR, bytes );
MADTypeInfoForHost( MTK_ADDRESS, sizeof( entry->v.addr.mach.offset ), &src );
} else {
ConvertTo( entry, TK_ADDRESS, TM_FAR, bytes );
MADTypeInfoForHost( MTK_ADDRESS, sizeof( entry->v.addr.mach ), &src );
}
break;
case MTK_FLOAT:
ConvertTo( entry, TK_REAL, TM_NONE, bytes );
MADTypeInfoForHost( MTK_FLOAT, sizeof( entry->v.real ), &src );
break;
case MTK_XMM:
//MAD: nyi
ToItem( entry, tmp );
return;
case MTK_CUSTOM:
//MAD: nyi
ToItem( entry, tmp );
return;
}
if( MADTypeConvert( &src, &entry->v, mti, tmp, 0 ) != MS_OK ) {
ToItem( entry, tmp );
}
}
static void SetIp( HWND hwnd, address *addr ) {
mad_type_info host;
mad_type_info mti;
void *item;
char buf[BUF_SIZE];
unsigned max;
max = BUF_SIZE - 1;
MADTypeInfoForHost( MTK_ADDRESS, sizeof( address ), &host );
MADTypeInfo( MADTypeDefault( MTK_ADDRESS, MAF_FULL, NULL, addr ), &mti );
item = alloca( ( mti.b.bits / BITS_PER_BYTE ) + 1);
MADTypeConvert( &host, addr, &mti, item, 0 );
MADTypeToString( 16, &mti, item, &max, buf );
SetDlgItemText( hwnd, INT_CS_IP, buf );
}
static void logStack( ExceptDlgInfo *info ) {
unsigned_16 *data;
int i;
int j;
address sp;
DWORD linecnt;
DWORD bytesread;
mad_type_info host;
mad_type_info mti;
void *item;
char buff[BUF_SIZE];
unsigned buff_len;
unsigned word_size;
#define MIN_SIZE sizeof( unsigned_16 )
MADRegSpecialGet( MSR_SP, info->regs, &( sp.mach ) );
MADTypeInfoForHost( MTK_ADDRESS, sizeof( address ), &host );
MADTypeInfo( MADTypeDefault( MTK_ADDRESS, MAF_FULL, NULL, &sp ), &mti );
item = alloca( BITS2BYTES( mti.b.bits ) + 1 );
#ifdef __AXP__
word_size = 8;
#else
word_size = 4;
#endif
data = alloca( word_size * 4 );
logPrintf( STR_STACK_DATA );
for( linecnt=0; linecnt < 20; linecnt ++ ) {
bytesread = MADCliReadMem( sp, word_size * 4, data );
MADTypeConvert( &host, &sp, &mti, item, 0 );
buff_len = sizeof( buff );
MADTypeToString( 16, &mti, item, buff, &buff_len );
logStrPrintf( "%s - ", buff );
for( i = 0; i < bytesread / MIN_SIZE; i += word_size / MIN_SIZE ) {
for( j = word_size / MIN_SIZE - 1; j >= 0; j-- ) {
logStrPrintf( "%04hX", data[i+j]);
}
logStrPrintf( " " );
MADAddrAdd( &sp, word_size, MAF_FULL );
}
logStrPrintf( "\n" );
}
}
static void CheckForRegisterChange( HWND hwnd )
{
RegModifyData *data;
mad_type_info mti_target;
mad_type_info mti_host;
int size;
char *s;
char *endptr;
void *test;
addr_seg seg;
InputUnion in;
data = ( RegModifyData * )GetWindowLong( hwnd, DWL_USER );
MADTypeInfo( data->curr_info->type, &mti_target );
if( data->num_possible == 1 ) {
size = SendDlgItemMessage( hwnd, REG_EDIT_FIELD, WM_GETTEXTLENGTH, 0, 0 ) + 1 ;
s = alloca( size );
GetDlgItemText( hwnd, REG_EDIT_FIELD, s, 255 );
test = alloca( mti_target.b.bits / BITS_PER_BYTE );
memset( &seg, 0, sizeof( seg ) );
errno = 0;
size = 0;
switch ( mti_target.b.kind ) {
case MTK_INTEGER:
if( !StrToU64( s, &( in.i ), ( mti_target.i.nr != MNR_UNSIGNED ) ) ) {
MessageBox( hwnd, "Unrecognized input.", "Error",MB_OK | MB_ICONEXCLAMATION ) ;
return;
}
size = sizeof( unsigned_64 );
break;
case MTK_FLOAT:
in.d = strtod( s, &endptr );
if( errno == ERANGE ) {
MessageBox( hwnd, "Value out of range.", "Error",MB_OK | MB_ICONEXCLAMATION ) ;
return;
}
if( *endptr != '\0' ) {
MessageBox( hwnd, "Unrecognized input.", "Error",MB_OK | MB_ICONEXCLAMATION ) ;
return;
}
size = sizeof( in.d );
break;
default:
EndDialog( hwnd, 0 );
break;
}
MADTypeInfoForHost( mti_target.b.kind, size, &mti_host );
MADTypeConvert( &mti_host, &in, &mti_target, test, seg );
if( memcmp( data->curr_value, test, mti_target.b.bits / BITS_PER_BYTE ) == 0 ) {
EndDialog( hwnd, 0 );
} else {
memcpy( data->curr_value, test, mti_target.b.bits / BITS_PER_BYTE );
EndDialog( hwnd, 1 );
}
} else {
int i = (int)SendDlgItemMessage( hwnd, CH_REG_COMBO_LIST, CB_GETCURSEL, 0, 0L );
if( memcmp( data->curr_value, data->m_list[i].data, mti_target.b.bits / BITS_PER_BYTE ) == 0 ) {
EndDialog( hwnd, 0 );
} else {
memcpy( data->curr_value, data->m_list[i].data, mti_target.b.bits / BITS_PER_BYTE );
EndDialog( hwnd, 1 );
}
}
}
void ToItem( stack_entry *entry, item_mach *tmp )
{
unsigned size;
mad_type_info src_type;
mad_type_info dst_type;
if( entry->info.size > sizeof( *tmp ) ) {
Error( ERR_NONE, LIT( ERR_TYPE_CONVERSION ) );
}
//NYI: use MAD routines for all conversions
size = entry->info.size;
switch( entry->info.kind ) {
case TK_BOOL:
case TK_ENUM:
case TK_CHAR:
case TK_INTEGER:
MADTypeInfo( MADTypeForDIPType( &entry->info ), &dst_type );
if( (entry->info.modifier & TM_MOD_MASK) == TM_SIGNED ) {
MADTypeInfoForHost( MTK_INTEGER, -(int)sizeof( entry->v.sint ), &src_type );
} else {
MADTypeInfoForHost( MTK_INTEGER, sizeof( entry->v.sint ), &src_type );
}
MADTypeConvert( &src_type, &entry->v.uint, &dst_type, tmp, 0 );
return;
case TK_REAL:
MADTypeInfo( MADTypeForDIPType( &entry->info ), &dst_type );
MADTypeInfoForHost( MTK_FLOAT, sizeof( entry->v.real ), &src_type );
MADTypeConvert( &src_type, &entry->v.real, &dst_type, tmp, 0 );
return;
case TK_COMPLEX:
switch( size ) {
case 8:
tmp->sc.re = LDToD( &entry->v.cmplx.re );
tmp->sc.im = LDToD( &entry->v.cmplx.im );
return;
case 16:
tmp->lc.re = LDToD( &entry->v.cmplx.re );
tmp->lc.im = LDToD( &entry->v.cmplx.im );
return;
case 20:
tmp->xc = entry->v.cmplx;
return;
}
break;
case TK_POINTER:
case TK_ADDRESS:
switch( entry->info.modifier & TM_MOD_MASK ) {
case TM_NEAR:
switch( size ) {
case 2:
tmp->so = entry->v.addr.mach.offset;
return;
case 4:
tmp->lo = entry->v.addr.mach.offset;
return;
case 8:
tmp->qo.u._32[I64LO32] = entry->v.addr.mach.offset;
tmp->qo.u._32[I64HI32] = 0;
}
break;
case TM_FAR:
case TM_HUGE:
switch( size ) {
case 4:
ConvAddr48ToAddr32( entry->v.addr.mach, tmp->sa );
return;
case 6:
tmp->la = entry->v.addr.mach;
return;
}
break;
}
break;
}
Error( ERR_NONE, LIT( ERR_TYPE_CONVERSION ) );
}
void FromItem( item_mach *tmp, stack_entry *entry )
{
unsigned size;
mad_type_info src_type;
mad_type_info dst_type;
type_info ti;
if( entry->info.size > sizeof( *tmp ) ) {
Error( ERR_NONE, LIT( ERR_TYPE_CONVERSION ) );
}
size = entry->info.size;
switch( entry->info.kind ) {
case TK_BOOL:
case TK_ENUM:
case TK_CHAR:
case TK_INTEGER:
MADTypeInfo( MADTypeForDIPType( &entry->info ), &src_type );
if( (entry->info.modifier & TM_MOD_MASK) == TM_SIGNED ) {
MADTypeInfoForHost( MTK_INTEGER, -(int)sizeof( entry->v.sint ), &dst_type );
} else {
MADTypeInfoForHost( MTK_INTEGER, sizeof( entry->v.sint ), &dst_type );
}
MADTypeConvert( &src_type, tmp, &dst_type, &entry->v.uint, 0 );
return;
case TK_REAL:
MADTypeInfo( MADTypeForDIPType( &entry->info ), &src_type );
MADTypeInfoForHost( MTK_FLOAT, sizeof( entry->v.real ), &dst_type );
MADTypeConvert( &src_type, tmp, &dst_type, &entry->v.real, 0 );
return;
case TK_COMPLEX:
ti.kind = TK_REAL;
ti.size = entry->info.size / 2;
ti.modifier = entry->info.modifier;
MADTypeInfo( MADTypeForDIPType( &ti ), &src_type );
MADTypeInfoForHost( MTK_FLOAT, sizeof( entry->v.cmplx.re ), &dst_type );
MADTypeConvert( &src_type, tmp, &dst_type, &entry->v.cmplx.re, 0 );
MADTypeConvert( &src_type, (unsigned_8 *)tmp + ti.size, &dst_type, &entry->v.cmplx.im, 0 );
return;
case TK_POINTER:
case TK_ADDRESS:
//NYI: use MAD conversion routines....
switch( entry->info.modifier & TM_MOD_MASK ) {
case TM_NEAR:
switch( size ) {
case 2:
entry->v.addr.mach.offset = tmp->so;
return;
case 8:
//NYI: 64 bit offsets
entry->info.size = 4;
case 4:
entry->v.addr.mach.offset = tmp->lo;
return;
}
break;
case TM_FAR:
case TM_HUGE:
switch( size ) {
case 4:
entry->v.addr.sect_id = 0;
entry->v.addr.indirect = FALSE;
ConvAddr32ToAddr48( tmp->sa, entry->v.addr.mach );
return;
case 6:
entry->v.addr.sect_id = 0;
entry->v.addr.indirect = FALSE;
entry->v.addr.mach = tmp->la;
return;
case sizeof( address ):
/* it's an internal address symbol */
entry->v.addr = tmp->xa;
entry->info.size = 6;
return;
}
break;
}
break;
}
Error( ERR_NONE, LIT( ERR_TYPE_CONVERSION ) );
}
