_CRTIMP2 short __cdecl _LExp(long double *px, long double y, short eoff)
{ /* compute y*e^(*px), (*px) finite, |y| not huge */
if (*px < -hugexp || y == 0)
{ /* certain underflow */
*px = 0;
return (0);
}
else if (hugexp < *px)
{ /* certain overflow */
*px = _LInf._L;
return (INF);
}
else
{ /* xexp won't overflow */
long double g = *px * invln2;
short xexp = g + (g < 0 ? - 0.5 : + 0.5);
g = xexp;
g = (*px - g * c1) - g * c2;
if (-_LEps._L < g && g < _LEps._L)
*px = y;
else
{ /* g*g worth computing */
const long double z = g * g;
const long double w = ((z + q[1]) * z + q[2]) * z
+ q[3];
g *= (p[0] * z + p[1]) * z + p[2];
*px = (w + g) / (w - g) * 2 * y;
--xexp;
}
return (_LDscale(px, (long)xexp + eoff));
}
}
_MRTIMP2_NCEEPURE short __CLRCALL_PURE_OR_CDECL _LExp(long double *px, long double y, short eoff)
{ /* compute y*e^(*px), (*px) finite, |y| not huge */
if (*px < -hugexp || y == 0.0L)
{ /* certain underflow */
*px = 0.0L;
return (0);
}
else if (hugexp < *px)
{ /* certain overflow */
*px = _LInf._Long_double;
return (_INFCODE);
}
else
{ /* xexp won't overflow */
long double g = *px * invln2;
short xexp = (short)(g + (g < 0 ? - 0.5L : + 0.5L));
g = xexp;
g = (*px - g * c1) - g * c2;
if (-_LEps._Long_double < g && g < _LEps._Long_double)
*px = y;
else
{ /* g*g worth computing */
#if _DLONG <= 1 /* assume IEEE 754 10 byte */
const long double z = g * g;
const long double w = ((z + q[1]) * z + q[2]) * z + q[3];
g *= (p[0] * z + p[1]) * z + p[2];
*px = (w + g) / (w - g) * 2.0L * y;
--xexp;
#else /* assume IEEE 754 16 byte */
const long double z = g * g;
const long double w = ((q[0] * z + q[1]) * z + q[2]) * z + q[3];
const long double v = (((p[0] * z + p[1]) * z + p[2])
* z + p[3]) * z + p[4];
const long double u = g * w - v;
*px = g * (g + z * (w + w + u)) / (2.0L - (g + z * u)) + g + 1.0;
*px *= y;
#endif
}
return (_LDscale(px, (long)xexp + eoff));
}
}
void _WLdtob(_WPft *px, wchar_t code)
{ /* convert long double to wide text */
wchar_t ac[MAXDIG];
wchar_t *p = ac;
long double ldval = px->v.ld;
short errx, nsig, xexp;
static const wchar_t inf[] =
{L'i', L'n', L'f', L'\0'};
static const wchar_t Inf[] =
{L'I', L'N', L'F', L'\0'};
static const wchar_t nan_str[] =
{L'n', L'a', L'n', L'\0'};
static const wchar_t Nan[] =
{L'N', L'A', L'N', L'\0'};
static const wchar_t xdigs[] =
{L'0', L'1', L'2', L'3',
L'4', L'5', L'6', L'7',
L'8', L'9', L'a', L'b',
L'c', L'd', L'e', L'f'};
static const wchar_t Xdigs[] =
{L'0', L'1', L'2', L'3',
L'4', L'5', L'6', L'7',
L'8', L'9', L'A', L'B',
L'C', L'D', L'E', L'F'};
if (code == L'a' || code == L'A')
;
else if (px->prec < 0)
px->prec = 6;
else if (px->prec == 0
&& (code == L'g' || code == L'G'))
px->prec = 1;
if ((errx = _LDunscale(&xexp, &px->v.ld)) == _NANCODE)
{ /* x == NaN */
wmemcpy(px->s, code == L'a' || code == L'e'
|| code == L'f' || code == L'g'
? nan_str : Nan, px->n1 = 3);
return;
}
else if (0 < errx)
{ /* x == INF */
wmemcpy(px->s, code == L'a' || code == L'e'
|| code == L'f' || code == L'g'
? inf : Inf, px->n1 = 3);
return;
}
if (code == L'a' || code == L'A')
{ /* put "0x" */
*px->s++ = L'0';
*px->s++ = code == L'a' ? L'x' : L'X';
px->n0 +=2;
}
if (0 == errx) /* x == 0 */
nsig = 0, xexp = 0;
else if (code == L'a' || code == L'A')
{ /* 0 < |x|, generate hex fraction, binary exponent */
const wchar_t *digits = code == L'a' ? xdigs : Xdigs;
int gen;
nsig = px->prec < 0 ? MAXDIG - NXDIG : px->prec + 1;
gen = nsig + 1;
ldval = ldval < 0 ? -px->v.ld : px->v.ld;
xexp -= 4; /* one leading nonzero hex digit */
for (*p++ = 0x0; 0 < gen && 0 < ldval; p += NXDIG)
{ /* convert NXDIG at a time */
int j;
long lo;
_LDscale(&ldval, 4 * NXDIG);
lo = (long)ldval;
if (0 < (gen -= NXDIG))
ldval -= (long double)lo;
for (p += NXDIG, j = NXDIG; 0 < lo && 0 <= --j; )
*--p = (int)(lo & 0xf), lo >>= 4;
while (0 <= --j)
*--p = 0;
}
gen = p - &ac[1];
p = &ac[1];
if (gen < nsig)
nsig = gen;
if (0 <= nsig)
{ /* round and strip trailing zeros */
const char drop = nsig < gen && 0x8 <= p[nsig] ? 0xf : 0x0;
int n;
for (n = nsig; p[--n] == drop; )
--nsig;
if (drop == 0xf)
++p[n];
if (n < 0)
--p, ++nsig, xexp += 4;
for (n = nsig; 0 <= --n; )
p[n] = digits[p[n]];
}
if (px->prec < 0)
px->prec = nsig - 1;
}
else
{ /* 0 < |x|, generate decimal fraction and exponent */
{ /* scale ldval to ~~10^(NDIG/2) */
