87 lines
2.3 KiB
C
87 lines
2.3 KiB
C
#include <ieee.h>
|
|
#define E IEEE_E
|
|
#define M IEEE_M
|
|
#define EXONE IEEE_EXONE
|
|
|
|
// one of the many possible NaNs,
|
|
// the one produced by the base converter
|
|
const fpvalue_t ieee_nan = {{ 0, 0, 0, 0, 0xc000, 0xffff }};
|
|
|
|
fpvalue_error_t idaapi realcvt(void *m, fpvalue_t *e, uint16 swt)
|
|
{
|
|
eNI x;
|
|
long exp;
|
|
uint16 r, msk, *p = (uint16 *)m;
|
|
|
|
switch ( swt )
|
|
{
|
|
case 1: // in float
|
|
case 0: // in trunc. float
|
|
case 3: // in double
|
|
ecleaz(x);
|
|
x[0] = ((r = *p) & 0x8000) ? 0xffff : 0; /* fill in our sign */
|
|
r &= (0377 << 7);
|
|
if ( r == 0 )
|
|
{
|
|
if ( x[0] ) // negative and zero exponent = Undefined -> transformed to NaN
|
|
{
|
|
memcpy(e, &ieee_nan, sizeof(fpvalue_t));
|
|
break;
|
|
}
|
|
// complain on dirty zero
|
|
for ( msk = 0x7fff, r = swt + 1; r; r--, msk = 0xffff )
|
|
if ( *p++ & msk )
|
|
return REAL_ERROR_BADDATA; // signed zero accepted
|
|
}
|
|
else
|
|
{
|
|
x[E] = (r >> 7) + (EXONE - 0201); /* DEC exponent offset */
|
|
x[M] = (*p++ & 0177) | 0200; /* now do the high order mantissa */
|
|
if ( swt )
|
|
memcpy(&x[M+1], p, swt*sizeof(uint16));
|
|
eshift(x, -8); /* shift our mantissa down 8 bits */
|
|
}
|
|
emovo(x, e); // convert to IEEE format
|
|
break;
|
|
|
|
case 011: // out float
|
|
case 010: // out trunc. float
|
|
case 013: // out double
|
|
emovi(*e, x);
|
|
r = swt & 3;
|
|
if ( !x[E] )
|
|
goto clear;
|
|
if ( x[E] == E_SPECIAL_EXP )
|
|
{
|
|
// all of NaN, +/-Inf transformed to "Undefined value"
|
|
x[0] = 0xffff;
|
|
x[E] = 0;
|
|
goto clear;
|
|
}
|
|
exp = (long )x[E] - (EXONE - 0201);
|
|
if ( !emdnorm(x, 0, 0, exp, 56) || x[E] >= 0377 )
|
|
return REAL_ERROR_RANGE; // overfloat
|
|
if ( !x[E] )
|
|
{
|
|
clear:
|
|
memset(p, 0, (r + 1)*sizeof(uint16));
|
|
if ( x[0] )
|
|
*p = 0x8000; // signed zero accepted
|
|
}
|
|
else
|
|
{
|
|
*p = (x[0] ? 0100000 : 0) | (x[E] << 7); /* sign & exp */
|
|
eshift(x, 8);
|
|
*p++ |= (x[M] & 0177);
|
|
if ( r != 0 )
|
|
memcpy(p, &x[M+1], r*sizeof(uint16));
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return REAL_ERROR_FORMAT;
|
|
}
|
|
|
|
return REAL_ERROR_OK;
|
|
}
|