Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-07-06 16:41:22 +00:00
Code Issues Projects Releases Packages Wiki Activity
reactos/sdk/lib/ucrt/convert/atoldbl.cpp

833 lines
26 KiB
C++
Raw Blame History

//
// atoldbl.cpp
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// The _atoldbl and _atoldbl_l functions, which convert a string representation
// of a floating point number into a 10-byte _LDOUBLE object.
//
#define _ALLOW_OLD_VALIDATE_MACROS
#include <corecrt_internal.h>
#include <corecrt_internal_fltintrn.h>
#include <corecrt_internal_strtox.h>
#include <float.h>
#include <locale.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#define PTR_12(x) ((uint8_t*)(&(x)->ld12))
#define MSB_USHORT ((uint16_t) 0x8000)
#define MSB_ULONG ((uint32_t) 0x80000000)
#define TMAX10 5200 /* maximum temporary decimal exponent */
#define TMIN10 -5200 /* minimum temporary decimal exponent */
#define LD_MAX_EXP_LEN 4 /* maximum number of decimal exponent digits */
#define LD_MAX_MAN_LEN 24 /* maximum length of mantissa (decimal)*/
#define LD_MAX_MAN_LEN1 25 /* MAX_MAN_LEN+1 */
#define LD_BIAS 0x3fff /* exponent bias for long double */
#define LD_BIASM1 0x3ffe /* LD_BIAS - 1 */
#define LD_MAXEXP 0x7fff /* maximum biased exponent */
#define D_BIAS 0x3ff /* exponent bias for double */
#define D_BIASM1 0x3fe /* D_BIAS - 1 */
#define D_MAXEXP 0x7ff /* maximum biased exponent */
// Macros for manipulation of a 12-byte long double number (an ordinary 10-byte
// long double plus two extra bytes of mantissa).
// byte layout:
//
// +-----+--------+--------+-------+
// |XT(2)|MANLO(4)|MANHI(4)|EXP(2) |
// +-----+--------+--------+-------+
// |<-UL_LO->|<-UL_MED->|<-UL_HI ->|
// (4) (4) (4)
#define ALIGN(x) ((unsigned long _UNALIGNED*)(x))
#define U_EXP_12(p) ((uint16_t *)(PTR_12(p) + 10))
#define UL_MANHI_12(p) ((uint32_t _UNALIGNED*)(PTR_12(p) + 6))
#define UL_MANLO_12(p) ((uint32_t _UNALIGNED*)(PTR_12(p) + 2))
#define U_XT_12(p) ((uint16_t *)(PTR_12(p) ))
// Pointers to the four low, mid, and high order bytes of the extended mantissa
#define UL_LO_12(p) ((uint32_t*)(PTR_12(p) ))
#define UL_MED_12(p) ((uint32_t*)(PTR_12(p) + 4))
#define UL_HI_12(p) ((uint32_t*)(PTR_12(p) + 8))
// Pointers to the uint8_t, uint16_t, and uint32_t of order i (LSB = 0; MSB = 9)
#define UCHAR_12(p, i) ((uint8_t *)( PTR_12(p) + (i)))
#define USHORT_12(p, i) ((uint16_t*)((uint8_t*)PTR_12(p) + (i)))
#define ULONG_12(p, i) ((uint32_t*)((uint8_t*)PTR_12(p) + (i)))
#define TEN_BYTE_PART(p) ((uint8_t *)( PTR_12(p) + 2 ))
// Manipulation of a 10-byte long double number
#define U_EXP_LD(p) ((uint16_t*)(_PTR_LD(p) + 8))
#define UL_MANHI_LD(p) ((uint32_t*)(_PTR_LD(p) + 4))
#define UL_MANLO_LD(p) ((uint32_t*)(_PTR_LD(p) ))
// Manipulation of a 64bit IEEE double
#define U_SHORT4_D(p) ((uint16_t*)(p) + 3)
#define UL_HI_D(p) ((uint32_t*)(p) + 1)
#define UL_LO_D(p) ((uint32_t*)(p) )
#define PUT_INF_12(p, sign) \
*UL_HI_12 (p) = (sign) ? 0xffff8000 : 0x7fff8000; \
*UL_MED_12(p) = 0; \
*UL_LO_12 (p) = 0;
#define PUT_ZERO_12(p) \
*UL_HI_12 (p) = 0; \
*UL_MED_12(p) = 0; \
*UL_LO_12 (p) = 0;
#define ISZERO_12(p) \
((*UL_HI_12 (p) & 0x7fffffff) == 0 && \
*UL_MED_12(p) == 0 && \
*UL_LO_12 (p) == 0)
#define PUT_INF_LD(p, sign) \
*U_EXP_LD (p) = (sign) ? 0xffff : 0x7fff; \
*UL_MANHI_LD(p) = 0x8000; \
*UL_MANLO_LD(p) = 0;
#define PUT_ZERO_LD(p) \
*U_EXP_LD (p) = 0; \
*UL_MANHI_LD(p) = 0; \
*UL_MANLO_LD(p) = 0;
#define ISZERO_LD(p) \
((*U_EXP_LD (p) & 0x7fff) == 0 && \
*UL_MANHI_LD(p) == 0 && \
*UL_MANLO_LD(p) == 0)
static _LDBL12 const ld12_pow10_positive[] =
{
/*P0001*/ {{0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xA0,0x02,0x40}},
/*P0002*/ {{0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC8,0x05,0x40}},
/*P0003*/ {{0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFA,0x08,0x40}},
/*P0004*/ {{0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x9C,0x0C,0x40}},
/*P0005*/ {{0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x50,0xC3,0x0F,0x40}},
/*P0006*/ {{0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x24,0xF4,0x12,0x40}},
/*P0007*/ {{0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x80,0x96,0x98,0x16,0x40}},
/*P0008*/ {{0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x20,0xBC,0xBE,0x19,0x40}},
/*P0016*/ {{0x00,0x00, 0x00,0x00,0x00,0x04,0xBF,0xC9,0x1B,0x8E,0x34,0x40}},
/*P0024*/ {{0x00,0x00, 0x00,0xA1,0xED,0xCC,0xCE,0x1B,0xC2,0xD3,0x4E,0x40}},
/*P0032*/ {{0x20,0xF0, 0x9E,0xB5,0x70,0x2B,0xA8,0xAD,0xC5,0x9D,0x69,0x40}},
/*P0040*/ {{0xD0,0x5D, 0xFD,0x25,0xE5,0x1A,0x8E,0x4F,0x19,0xEB,0x83,0x40}},
/*P0048*/ {{0x71,0x96, 0xD7,0x95,0x43,0x0E,0x05,0x8D,0x29,0xAF,0x9E,0x40}},
/*P0056*/ {{0xF9,0xBF, 0xA0,0x44,0xED,0x81,0x12,0x8F,0x81,0x82,0xB9,0x40}},
/*P0064*/ {{0xBF,0x3C, 0xD5,0xA6,0xCF,0xFF,0x49,0x1F,0x78,0xC2,0xD3,0x40}},
/*P0128*/ {{0x6F,0xC6, 0xE0,0x8C,0xE9,0x80,0xC9,0x47,0xBA,0x93,0xA8,0x41}},
/*P0192*/ {{0xBC,0x85, 0x6B,0x55,0x27,0x39,0x8D,0xF7,0x70,0xE0,0x7C,0x42}},
/*P0256*/ {{0xBC,0xDD, 0x8E,0xDE,0xF9,0x9D,0xFB,0xEB,0x7E,0xAA,0x51,0x43}},
/*P0320*/ {{0xA1,0xE6, 0x76,0xE3,0xCC,0xF2,0x29,0x2F,0x84,0x81,0x26,0x44}},
/*P0384*/ {{0x28,0x10, 0x17,0xAA,0xF8,0xAE,0x10,0xE3,0xC5,0xC4,0xFA,0x44}},
/*P0448*/ {{0xEB,0xA7, 0xD4,0xF3,0xF7,0xEB,0xE1,0x4A,0x7A,0x95,0xCF,0x45}},
/*P0512*/ {{0x65,0xCC, 0xC7,0x91,0x0E,0xA6,0xAE,0xA0,0x19,0xE3,0xA3,0x46}},
/*P1024*/ {{0x0D,0x65, 0x17,0x0C,0x75,0x81,0x86,0x75,0x76,0xC9,0x48,0x4D}},
/*P1536*/ {{0x58,0x42, 0xE4,0xA7,0x93,0x39,0x3B,0x35,0xB8,0xB2,0xED,0x53}},
/*P2048*/ {{0x4D,0xA7, 0xE5,0x5D,0x3D,0xC5,0x5D,0x3B,0x8B,0x9E,0x92,0x5A}},
/*P2560*/ {{0xFF,0x5D, 0xA6,0xF0,0xA1,0x20,0xC0,0x54,0xA5,0x8C,0x37,0x61}},
/*P3072*/ {{0xD1,0xFD, 0x8B,0x5A,0x8B,0xD8,0x25,0x5D,0x89,0xF9,0xDB,0x67}},
/*P3584*/ {{0xAA,0x95, 0xF8,0xF3,0x27,0xBF,0xA2,0xC8,0x5D,0xDD,0x80,0x6E}},
/*P4096*/ {{0x4C,0xC9, 0x9B,0x97,0x20,0x8A,0x02,0x52,0x60,0xC4,0x25,0x75}}
};
static _LDBL12 const ld12_pow10_negative[] =
{
/*N0001*/ {{0xCD,0xCC, 0xCD,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xFB,0x3F}},
/*N0002*/ {{0x71,0x3D, 0x0A,0xD7,0xA3,0x70,0x3D,0x0A,0xD7,0xA3,0xF8,0x3F}},
/*N0003*/ {{0x5A,0x64, 0x3B,0xDF,0x4F,0x8D,0x97,0x6E,0x12,0x83,0xF5,0x3F}},
/*N0004*/ {{0xC3,0xD3, 0x2C,0x65,0x19,0xE2,0x58,0x17,0xB7,0xD1,0xF1,0x3F}},
/*N0005*/ {{0xD0,0x0F, 0x23,0x84,0x47,0x1B,0x47,0xAC,0xC5,0xA7,0xEE,0x3F}},
/*N0006*/ {{0x40,0xA6, 0xB6,0x69,0x6C,0xAF,0x05,0xBD,0x37,0x86,0xEB,0x3F}},
/*N0007*/ {{0x33,0x3D, 0xBC,0x42,0x7A,0xE5,0xD5,0x94,0xBF,0xD6,0xE7,0x3F}},
/*N0008*/ {{0xC2,0xFD, 0xFD,0xCE,0x61,0x84,0x11,0x77,0xCC,0xAB,0xE4,0x3F}},
/*N0016*/ {{0x2F,0x4C, 0x5B,0xE1,0x4D,0xC4,0xBE,0x94,0x95,0xE6,0xC9,0x3F}},
/*N0024*/ {{0x92,0xC4, 0x53,0x3B,0x75,0x44,0xCD,0x14,0xBE,0x9A,0xAF,0x3F}},
/*N0032*/ {{0xDE,0x67, 0xBA,0x94,0x39,0x45,0xAD,0x1E,0xB1,0xCF,0x94,0x3F}},
/*N0040*/ {{0x24,0x23, 0xC6,0xE2,0xBC,0xBA,0x3B,0x31,0x61,0x8B,0x7A,0x3F}},
/*N0048*/ {{0x61,0x55, 0x59,0xC1,0x7E,0xB1,0x53,0x7C,0x12,0xBB,0x5F,0x3F}},
/*N0056*/ {{0xD7,0xEE, 0x2F,0x8D,0x06,0xBE,0x92,0x85,0x15,0xFB,0x44,0x3F}},
/*N0064*/ {{0x24,0x3F, 0xA5,0xE9,0x39,0xA5,0x27,0xEA,0x7F,0xA8,0x2A,0x3F}},
/*N0128*/ {{0x7D,0xAC, 0xA1,0xE4,0xBC,0x64,0x7C,0x46,0xD0,0xDD,0x55,0x3E}},
/*N0192*/ {{0x63,0x7B, 0x06,0xCC,0x23,0x54,0x77,0x83,0xFF,0x91,0x81,0x3D}},
/*N0256*/ {{0x91,0xFA, 0x3A,0x19,0x7A,0x63,0x25,0x43,0x31,0xC0,0xAC,0x3C}},
/*N0320*/ {{0x21,0x89, 0xD1,0x38,0x82,0x47,0x97,0xB8,0x00,0xFD,0xD7,0x3B}},
/*N0384*/ {{0xDC,0x88, 0x58,0x08,0x1B,0xB1,0xE8,0xE3,0x86,0xA6,0x03,0x3B}},
/*N0448*/ {{0xC6,0x84, 0x45,0x42,0x07,0xB6,0x99,0x75,0x37,0xDB,0x2E,0x3A}},
/*N0512*/ {{0x33,0x71, 0x1C,0xD2,0x23,0xDB,0x32,0xEE,0x49,0x90,0x5A,0x39}},
/*N1024*/ {{0xA6,0x87, 0xBE,0xC0,0x57,0xDA,0xA5,0x82,0xA6,0xA2,0xB5,0x32}},
/*N1536*/ {{0xE2,0x68, 0xB2,0x11,0xA7,0x52,0x9F,0x44,0x59,0xB7,0x10,0x2C}},
/*N2048*/ {{0x25,0x49, 0xE4,0x2D,0x36,0x34,0x4F,0x53,0xAE,0xCE,0x6B,0x25}},
/*N2560*/ {{0x8F,0x59, 0x04,0xA4,0xC0,0xDE,0xC2,0x7D,0xFB,0xE8,0xC6,0x1E}},
/*N3072*/ {{0x9E,0xE7, 0x88,0x5A,0x57,0x91,0x3C,0xBF,0x50,0x83,0x22,0x18}},
/*N3584*/ {{0x4E,0x4B, 0x65,0x62,0xFD,0x83,0x8F,0xAF,0x06,0x94,0x7D,0x11}},
/*N4096*/ {{0xE4,0x2D, 0xDE,0x9F,0xCE,0xD2,0xC8,0x04,0xDD,0xA6,0xD8,0x0A}}
};
// Adds x and y, storing the result in *sum. Returns true if overflow occurred;
// false otherwise.
static __forceinline bool __cdecl add_uint32_carry(uint32_t const x, uint32_t const y, uint32_t* const sum) throw()
{
uint32_t const r = x + y;
*sum = r;
return r < x || r < y; // carry
}
// Adds *x and *y as 12-byte integers, storing the result in *x. Overflow is ignored.
static __forceinline void __cdecl add_ld12(_LDBL12* const x, _LDBL12 const* const y) throw()
{
if (add_uint32_carry(*UL_LO_12(x), *UL_LO_12(y), UL_LO_12(x)))
{
if (add_uint32_carry(*UL_MED_12(x), 1, UL_MED_12(x)))
{
++*UL_HI_12(x);
}
}
if (add_uint32_carry(*UL_MED_12(x), *UL_MED_12(y), UL_MED_12(x)))
{
++*UL_HI_12(x);
}
// Ignore next carry -- assume no overflow will occur
add_uint32_carry(*UL_HI_12(x), *UL_HI_12(y), UL_HI_12(x));
}
// Shifts *p N bits to the left. The number is shifted as a 12-byte integer.
template <uint32_t N>
static __forceinline void __cdecl shl_ld12(_LDBL12* const p) throw()
{
uint32_t const total_bits{sizeof(uint32_t) * CHAR_BIT};
uint32_t const msb_bits{N};
uint32_t const lsb_bits{total_bits - N};
static_assert(msb_bits <= total_bits, "shift too large");
uint32_t const lsb_mask{(1 << (lsb_bits - 1)) - 1};
uint32_t const msb_mask{static_cast<uint32_t>(-1) ^ lsb_mask};
uint32_t const lo_carry {(*UL_LO_12 (p) & msb_mask) >> lsb_bits};
uint32_t const med_carry{(*UL_MED_12(p) & msb_mask) >> lsb_bits};
*UL_LO_12 (p) = (*UL_LO_12 (p) << msb_bits);
*UL_MED_12(p) = (*UL_MED_12(p) << msb_bits) | lo_carry;
*UL_HI_12 (p) = (*UL_HI_12 (p) << msb_bits) | med_carry;
}
// Shifts *p one bit to the right. The number is shifted as a 12-byte integer.
static __forceinline void __cdecl shr_ld12(_LDBL12* const p) throw()
{
uint32_t const c2 = *UL_HI_12 (p) & 0x1 ? MSB_ULONG : 0;
uint32_t const c1 = *UL_MED_12(p) & 0x1 ? MSB_ULONG : 0;
*UL_HI_12 (p) >>= 1;
*UL_MED_12(p) = *UL_MED_12(p) >> 1 | c2;
*UL_LO_12 (p) = *UL_LO_12 (p) >> 1 | c1;
}
// Multiplies *px and *py, storing the result in *px.
static __forceinline void __cdecl multiply_ld12(_LDBL12* const px, _LDBL12 const* const py) throw()
{
_LDBL12 tempman; // This is actually a 12-byte mantissa, not a 12-byte long double
*UL_LO_12 (&tempman) = 0;
*UL_MED_12(&tempman) = 0;
*UL_HI_12 (&tempman) = 0;
uint16_t expx = *U_EXP_12(px);
uint16_t expy = *U_EXP_12(py);
uint16_t const sign = (expx ^ expy) & static_cast<uint16_t>(0x8000);
expx &= 0x7fff;
expy &= 0x7fff;
uint16_t expsum = expx + expy;
if (expx >= LD_MAXEXP ||
expy >= LD_MAXEXP ||
expsum > LD_MAXEXP + LD_BIASM1)
{
// Overflow to infinity
PUT_INF_12(px, sign);
return;
}
if (expsum <= LD_BIASM1 - 63)
{
// Underflow to zero
PUT_ZERO_12(px);
return;
}
if (expx == 0)
{
// If this is a denormal temp real then the mantissa was shifted right
// once to set bit 63 to zero.
++expsum; // Correct for this
if (ISZERO_12(px))
{
// Put positive sign:
*U_EXP_12(px) = 0;
return;
}
}
if (expy == 0)
{
++expsum; // Because arg2 is denormal
if (ISZERO_12(py))
{
PUT_ZERO_12(px);
return;
}
}
int roffs = 0;
for (int i = 0; i < 5; ++i)
{
int poffs = i << 1;
int qoffs = 8;
for (int j = 5 - i; j > 0; --j)
{
bool carry = false;
uint16_t* const p = USHORT_12(px, poffs);
uint16_t* const q = USHORT_12(py, qoffs);
uint32_t* const r = ULONG_12(&tempman, roffs);
uint32_t const prod = static_cast<uint32_t>(*p) * static_cast<uint32_t>(*q);
#if defined _M_X64 || defined _M_ARM
// handle misalignment problems
if (i & 0x1) // i is odd
{
uint32_t sum = 0;
carry = add_uint32_carry(*ALIGN(r), prod, &sum);
*ALIGN(r) = sum;
}
else // i is even
{
carry = add_uint32_carry(*r, prod, r);
}
#else
carry = add_uint32_carry(*r, prod, r);
#endif
if (carry)
{
// roffs should be less than 8 in this case
++*USHORT_12(&tempman, roffs + 4);
}
poffs += 2;
qoffs -= 2;
}
roffs += 2;
}
expsum -= LD_BIASM1;
// Normalize
while (static_cast<int16_t>(expsum) > 0 && (*UL_HI_12(&tempman) & MSB_ULONG) == 0)
{
shl_ld12<1>(&tempman);
expsum--;
}
if (static_cast<int16_t>(expsum) <= 0)
{
bool sticky = false;
expsum--;
while (static_cast<int16_t>(expsum) < 0)
{
if (*U_XT_12(&tempman) & 0x1)
sticky = true;
shr_ld12(&tempman);
expsum++;
}
if (sticky)
{
*U_XT_12(&tempman) |= 0x1;
}
}
if (*U_XT_12(&tempman) > 0x8000 || (*UL_LO_12(&tempman) & 0x1ffff) == 0x18000)
{
// Round up:
if (*UL_MANLO_12(&tempman) == UINT32_MAX)
{
*UL_MANLO_12(&tempman) = 0;
if (*UL_MANHI_12(&tempman) == UINT32_MAX)
{
*UL_MANHI_12(&tempman) = 0;
if (*U_EXP_12(&tempman) == UINT16_MAX)
{
// 12-byte mantissa overflow:
*U_EXP_12(&tempman) = MSB_USHORT;
++expsum;
}
else
{
++*U_EXP_12(&tempman);
}
}
else
{
++*UL_MANHI_12(&tempman);
}
}
else
{
++*UL_MANLO_12(&tempman);
}
}
// Check for exponent overflow:
if (expsum >= 0x7fff)
{
PUT_INF_12(px, sign);
return;
}
// Put result in px:
*U_XT_12 (px) = *USHORT_12(&tempman, 2);
*UL_MANLO_12(px) = *UL_MED_12(&tempman);
*UL_MANHI_12(px) = *UL_HI_12 (&tempman);
*U_EXP_12 (px) = expsum | sign;
}
// Multiplies *pld12 by 10^pow.
static __forceinline void __cdecl multiply_ten_pow_ld12(_LDBL12* const pld12, int pow) throw()
{
if (pow == 0)
return;
_LDBL12 const* pow_10p = ld12_pow10_positive - 8;
if (pow < 0)
{
pow = -pow;
pow_10p = ld12_pow10_negative-8;
}
while (pow != 0)
{
pow_10p += 7;
int const last3 = pow & 0x7; // The three least significant bits of pow
pow >>= 3;
if (last3 == 0)
continue;
_LDBL12 const* py = pow_10p + last3;
_LDBL12 unround;
// Do an exact 12byte multiplication:
if (*U_XT_12(py) >= 0x8000)
{
// Copy number:
unround = *py;
// Unround adjacent byte:
--*UL_MANLO_12(&unround);
// Point to new operand:
py = &unround;
}
multiply_ld12(pld12, py);
}
}
// Multiplies *ld12 by 2^power.
static __forceinline void __cdecl multiply_two_pow_ld12(_LDBL12* const ld12, int const power) throw()
{
_LDBL12 multiplicand{};
*U_XT_12 (&multiplicand) = 0;
*UL_MANLO_12(&multiplicand) = 0;
*UL_MANHI_12(&multiplicand) = (1u << (sizeof(uint32_t) * CHAR_BIT - 1));
*U_EXP_12 (&multiplicand) = static_cast<uint16_t>(power + LD_BIAS);
multiply_ld12(ld12, &multiplicand);
}
// These multiply a 12-byte integer stored in an _LDBL12 by N. N must be 10 or 16.
template <uint32_t N>
static __forceinline void __cdecl multiply_ld12_by(_LDBL12*) throw();
template <>
__forceinline void __cdecl multiply_ld12_by<10>(_LDBL12* const ld12) throw()
{
_LDBL12 const original_ld12 = *ld12;
shl_ld12<2>(ld12);
add_ld12(ld12, &original_ld12);
shl_ld12<1>(ld12);
}
template <>
__forceinline void __cdecl multiply_ld12_by<16>(_LDBL12* const ld12) throw()
{
shl_ld12<4>(ld12);
}
// Converts a mantissa into an _LDBL12. The mantissa to be converted must be
// represented as an array of BCD digits, one per byte, read from the byte range
// [mantissa, mantissa + mantissa_count).
template <uint32_t Base>
static __forceinline void __cdecl convert_mantissa_to_ld12(
uint8_t const* const mantissa,
size_t const mantissa_count,
_LDBL12* const ld12
) throw()
{
*UL_LO_12 (ld12) = 0;
*UL_MED_12(ld12) = 0;
*UL_HI_12 (ld12) = 0;
uint8_t const* const mantissa_last = mantissa + mantissa_count;
for (uint8_t const* it = mantissa; it != mantissa_last; ++it)
{
multiply_ld12_by<Base>(ld12);
// Add the new digit into the mantissa:
_LDBL12 digit_ld12{};
*UL_LO_12 (&digit_ld12) = *it;
*UL_MED_12(&digit_ld12) = 0;
*UL_HI_12 (&digit_ld12) = 0;
add_ld12(ld12, &digit_ld12);
}
uint16_t expn = LD_BIASM1 + 80;
// Normalize mantissa. First shift word-by-word:
while (*UL_HI_12(ld12) == 0)
{
*UL_HI_12 (ld12) = *UL_MED_12(ld12) >> 16;
*UL_MED_12(ld12) = *UL_MED_12(ld12) << 16 | *UL_LO_12(ld12) >> 16;
*UL_LO_12 (ld12) <<= 16;
expn -= 16;
}
while ((*UL_HI_12(ld12) & MSB_USHORT) == 0)
{
shl_ld12<1>(ld12);
--expn;
}
*U_EXP_12(ld12) = expn;
}
namespace __crt_strtox {
void __cdecl assemble_floating_point_zero(bool const is_negative, _LDBL12& result) throw()
{
uint16_t const sign_bit{static_cast<uint16_t>(is_negative ? MSB_USHORT : 0x0000)};
// Zero is all zero bits with an optional sign bit:
*U_XT_12 (&result) = 0;
*UL_MANLO_12(&result) = 0;
*UL_MANHI_12(&result) = 0;
*U_EXP_12 (&result) = sign_bit;
}
void __cdecl assemble_floating_point_infinity(bool const is_negative, _LDBL12& result) throw()
{
uint16_t const sign_bit{static_cast<uint16_t>(is_negative ? MSB_USHORT : 0x0000)};
// Infinity has an all-zero mantissa and an all-one exponent
*U_XT_12 (&result) = 0;
*UL_MANLO_12(&result) = 0;
*UL_MANHI_12(&result) = 0;
*U_EXP_12 (&result) = static_cast<uint16_t>(LD_MAXEXP) | sign_bit;
}
void __cdecl assemble_floating_point_qnan(bool const is_negative, _LDBL12& result) throw()
{
uint16_t const sign_bit{static_cast<uint16_t>(is_negative ? MSB_USHORT : 0x0000)};
*U_XT_12 (&result) = 0xffff;
*UL_MANLO_12(&result) = 0xffffffff;
*UL_MANHI_12(&result) = 0xffffffff;
*U_EXP_12 (&result) = static_cast<uint16_t>(LD_MAXEXP) | sign_bit;
}
void __cdecl assemble_floating_point_snan(bool const is_negative, _LDBL12& result) throw()
{
uint16_t const sign_bit{static_cast<uint16_t>(is_negative ? MSB_USHORT : 0x0000)};
*U_XT_12 (&result) = 0xffff;
*UL_MANLO_12(&result) = 0xffffffff;
*UL_MANHI_12(&result) = 0xbfffffff;
*U_EXP_12 (&result) = static_cast<uint16_t>(LD_MAXEXP) | sign_bit;
}
void __cdecl assemble_floating_point_ind(_LDBL12& result) throw()
{
uint16_t const sign_bit{static_cast<uint16_t>(MSB_USHORT)};
*U_XT_12 (&result) = 0x0000;
*UL_MANLO_12(&result) = 0x00000000;
*UL_MANHI_12(&result) = 0xc0000000;
*U_EXP_12 (&result) = static_cast<uint16_t>(LD_MAXEXP) | sign_bit;
}
static SLD_STATUS __cdecl common_convert_to_ldbl12(
floating_point_string const& immutable_data,
bool const is_hexadecimal,
_LDBL12 & result
) throw()
{
floating_point_string data = immutable_data;
// Cap the number of digits to LD_MAX_MAN_LEN, and round the last digit:
if (data._mantissa_count > LD_MAX_MAN_LEN)
{
if (data._mantissa[LD_MAX_MAN_LEN] >= (is_hexadecimal ? 8 : 5))
{
++data._mantissa[LD_MAX_MAN_LEN - 1];
}
data._mantissa_count = LD_MAX_MAN_LEN;
}
// The input exponent is an adjustment from the left (so 12.3456 is represented
// as a mantiss a of 123456 with an exponent of 2), but the legacy functions
// used here expect an adjustment from the right (so 12.3456 is represented
// with an exponent of -4).
int const exponent_adjustment_multiplier = is_hexadecimal ? 4 : 1;
data._exponent -= data._mantissa_count * exponent_adjustment_multiplier;
if (is_hexadecimal)
{
convert_mantissa_to_ld12<16>(data._mantissa, data._mantissa_count, &result);
multiply_two_pow_ld12(&result, data._exponent);
}
else
{
convert_mantissa_to_ld12<10>(data._mantissa, data._mantissa_count, &result);
multiply_ten_pow_ld12(&result, data._exponent);
}
if (data._is_negative)
{
*U_EXP_12(&result) |= 0x8000;
}
// If the combination of the mantissa and the exponent produced an infinity,
// we've overflowed the range of the _LDBL12.
if ((*U_EXP_12(&result) & LD_MAXEXP) == LD_MAXEXP)
{
return SLD_OVERFLOW;
}
return SLD_OK;
}
SLD_STATUS __cdecl convert_decimal_string_to_floating_type(
floating_point_string const& data,
_LDBL12 & result
) throw()
{
return common_convert_to_ldbl12(data, false, result);
}
SLD_STATUS __cdecl convert_hexadecimal_string_to_floating_type(
floating_point_string const& data,
_LDBL12 & result
) throw()
{
return common_convert_to_ldbl12(data, true, result);
}
} // namespace __crt_strtox
using namespace __crt_strtox;
static int __cdecl transform_into_return_value(SLD_STATUS const status) throw()
{
switch (status)
{
case SLD_OVERFLOW: return _OVERFLOW;
case SLD_UNDERFLOW: return _UNDERFLOW;
default: return 0;
}
}
// The internal mantissa length in ints
#define INTRNMAN_LEN 3
// Internal mantissaa representation for string conversion routines
typedef uint32_t* mantissa_t;
// Tests whether a mantissa ends in nbit zeroes. Returns true if all mantissa
// bits after (and including) nbit are zero; returns false otherwise.
static __forceinline bool __cdecl mantissa_has_zero_tail(mantissa_t const mantissa, int const nbit) throw()
{
int nl = nbit / 32;
int const nb = 31 - nbit % 32;
//
// |<---- tail to be checked --->
//
// -- ------------------------ ----
// |... | | ... |
// -- ------------------------ ----
// ^ ^ ^
// | | |<----nb----->
// man nl nbit
//
uint32_t const bitmask = ~(UINT32_MAX << nb);
if (mantissa[nl] & bitmask)
return false;
++nl;
for (; nl < INTRNMAN_LEN; ++nl)
{
if (mantissa[nl])
return false;
}
return true;
}
// Increments a mantissa. The nbit argument specifies the end of the part to
// be incremented. Returns true if overflow occurs; false otherwise.
static __forceinline bool __cdecl increment_mantissa(mantissa_t const mantissa, int const nbit) throw()
{
int nl = nbit / 32;
int const nb = 31 - nbit % 32;
//
// |<--- part to be incremented -->|
//
// ---------------------------------
// |... | | ... |
// ---------------------------------
// ^ ^ ^
// | | |<--nb-->
// man nl nbit
//
uint32_t const one = static_cast<uint32_t>(1) << nb;
bool carry = add_uint32_carry(mantissa[nl], one, &mantissa[nl]);
--nl;
for (; nl >= 0 && carry; --nl)
{
carry = add_uint32_carry(mantissa[nl], 1, &mantissa[nl]);
}
return carry;
}
// Rounds a mantissa to the given precision. Returns true if overflow occurs;
// returns false otherwise.
static __forceinline bool __cdecl round_mantissa(mantissa_t const mantissa, int const precision) throw()
{
// The order of the n'th bit is n-1, since the first bit is bit 0
// therefore decrement precision to get the order of the last bit
// to be kept
int const nbit = precision - 1;
int const rndbit = nbit + 1;
int const nl = rndbit / 32;
int const nb = 31 - rndbit % 32;
// Get value of round bit
uint32_t const rndmask = static_cast<uint32_t>(1) << nb;
bool retval = false;
if ((mantissa[nl] & rndmask) && !mantissa_has_zero_tail(mantissa, rndbit))
{
// round up
retval = increment_mantissa(mantissa, nbit);
}
// Fill rest of mantissa with zeroes
mantissa[nl] &= UINT32_MAX << nb;
for (int i = nl + 1; i < INTRNMAN_LEN; ++i)
{
mantissa[i] = 0;
}
return retval;
}
static void __cdecl convert_ld12_to_ldouble(
_LDBL12 const* const pld12,
_LDOUBLE* const result
) throw()
{
// This implementation is based on the fact that the _LDBL12 format is
// identical to the long double and has 2 extra bytes of mantissa
uint16_t exponent = *U_EXP_12(pld12) & static_cast<uint16_t>(0x7fff);
uint16_t const sign = *U_EXP_12(pld12) & static_cast<uint16_t>(0x8000);
uint32_t mantissa[] =
{
*UL_MANHI_12(pld12),
*UL_MANLO_12(pld12),
uint32_t ((*U_XT_12(pld12)) << 16)
};
if (round_mantissa(mantissa, 64))
{
// The MSB of the mantissa is explicit and should be 1
// since we had a carry, the mantissa is now 0.
mantissa[0] = MSB_ULONG;
++exponent;
}
*UL_MANHI_LD(result) = mantissa[0];
*UL_MANLO_LD(result) = mantissa[1];
*U_EXP_LD (result) = sign | exponent;
}
extern "C" int __cdecl _atoldbl_l(_LDOUBLE* const result, char* const string, _locale_t const locale)
{
_LocaleUpdate locale_update(locale);
_LDBL12 intermediate_result{};
SLD_STATUS const conversion_status = parse_floating_point(
locale_update.GetLocaleT(),
make_c_string_character_source(string, nullptr),
&intermediate_result);
convert_ld12_to_ldouble(&intermediate_result, result);
return transform_into_return_value(conversion_status);
}
extern "C" int __cdecl _atoldbl(_LDOUBLE* const result, char* const string)
{
return _atoldbl_l(result, string, nullptr);
}
Reference in a new issue View git blame Copy permalink