atoldbl.cpp File Reference

#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>

Include dependency graph for atoldbl.cpp:

Go to the source code of this file.

Namespaces
namespace	__crt_strtox

Macros
#define	_ALLOW_OLD_VALIDATE_MACROS
#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 */
#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) ))
#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))
#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 ))
#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) ))
#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)
#define	PUT_ZERO_12(p)
#define	ISZERO_12(p)
#define	PUT_INF_LD(p, sign)
#define	PUT_ZERO_LD(p)
#define	ISZERO_LD(p)
#define	INTRNMAN_LEN   3

Typedefs
typedef uint32_t *	mantissa_t

Functions
static __forceinline bool __cdecl	add_uint32_carry (uint32_t const x, uint32_t const y, uint32_t *const sum) throw ()
static __forceinline void __cdecl	add_ld12 (_LDBL12 *const x, _LDBL12 const *const y) throw ()
template<uint32_t N>
static __forceinline void __cdecl	shl_ld12 (_LDBL12 *const p) throw ()
static __forceinline void __cdecl	shr_ld12 (_LDBL12 *const p) throw ()
static __forceinline void __cdecl	multiply_ld12 (_LDBL12 *const px, _LDBL12 const *const py) throw ()
static __forceinline void __cdecl	multiply_ten_pow_ld12 (_LDBL12 *const pld12, int pow) throw ()
static __forceinline void __cdecl	multiply_two_pow_ld12 (_LDBL12 *const ld12, int const power) throw ()
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 ()
template<>
__forceinline void __cdecl	multiply_ld12_by< 16 > (_LDBL12 *const ld12) throw ()
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 ()
void __cdecl	__crt_strtox::assemble_floating_point_zero (bool const is_negative, _LDBL12 &result) throw ()
void __cdecl	__crt_strtox::assemble_floating_point_infinity (bool const is_negative, _LDBL12 &result) throw ()
void __cdecl	__crt_strtox::assemble_floating_point_qnan (bool const is_negative, _LDBL12 &result) throw ()
void __cdecl	__crt_strtox::assemble_floating_point_snan (bool const is_negative, _LDBL12 &result) throw ()
void __cdecl	__crt_strtox::assemble_floating_point_ind (_LDBL12 &result) throw ()
static SLD_STATUS __cdecl	__crt_strtox::common_convert_to_ldbl12 (floating_point_string const &immutable_data, bool const is_hexadecimal, _LDBL12 &result) throw ()
SLD_STATUS __cdecl	__crt_strtox::convert_decimal_string_to_floating_type (floating_point_string const &data, _LDBL12 &result) throw ()
SLD_STATUS __cdecl	__crt_strtox::convert_hexadecimal_string_to_floating_type (floating_point_string const &data, _LDBL12 &result) throw ()
static int __cdecl	transform_into_return_value (SLD_STATUS const status) throw ()
static __forceinline bool __cdecl	mantissa_has_zero_tail (mantissa_t const mantissa, int const nbit) throw ()
static __forceinline bool __cdecl	increment_mantissa (mantissa_t const mantissa, int const nbit) throw ()
static __forceinline bool __cdecl	round_mantissa (mantissa_t const mantissa, int const precision) throw ()
static void __cdecl	convert_ld12_to_ldouble (_LDBL12 const *const pld12, _LDOUBLE *const result) throw ()
int __cdecl	_atoldbl_l (_LDOUBLE *const result, char *const string, _locale_t const locale)
int __cdecl	_atoldbl (_LDOUBLE *const result, char *const string)

Variables
static _LDBL12 const	ld12_pow10_positive []
static _LDBL12 const	ld12_pow10_negative []

Macro Definition Documentation

_ALLOW_OLD_VALIDATE_MACROS

#define _ALLOW_OLD_VALIDATE_MACROS

Definition at line 9 of file atoldbl.cpp.

ALIGN

#define ALIGN

(

x

)

((unsigned long _UNALIGNED*)(x))

Definition at line 49 of file atoldbl.cpp.

D_BIAS

#define D_BIAS   0x3ff /* exponent bias for double */

Definition at line 36 of file atoldbl.cpp.

D_BIASM1

#define D_BIASM1   0x3fe /* D_BIAS - 1 */

Definition at line 37 of file atoldbl.cpp.

D_MAXEXP

#define D_MAXEXP   0x7ff /* maximum biased exponent */

Definition at line 38 of file atoldbl.cpp.

INTRNMAN_LEN

#define INTRNMAN_LEN   3

Definition at line 677 of file atoldbl.cpp.

ISZERO_12

#define ISZERO_12

(

p

)

Value:

    ((*UL_HI_12 (p) & 0x7fffffff) == 0 && \
      *UL_MED_12(p)               == 0 && \
      *UL_LO_12 (p)               == 0)

Definition at line 87 of file atoldbl.cpp.

ISZERO_LD

#define ISZERO_LD

(

p

)

Value:

    ((*U_EXP_LD   (p) & 0x7fff) == 0 && \
      *UL_MANHI_LD(p)           == 0 && \
      *UL_MANLO_LD(p)           == 0)

Definition at line 102 of file atoldbl.cpp.

LD_BIAS

#define LD_BIAS   0x3fff /* exponent bias for long double */

Definition at line 32 of file atoldbl.cpp.

LD_BIASM1

#define LD_BIASM1   0x3ffe /* LD_BIAS - 1 */

Definition at line 33 of file atoldbl.cpp.

LD_MAX_EXP_LEN

#define LD_MAX_EXP_LEN   4 /* maximum number of decimal exponent digits */

Definition at line 28 of file atoldbl.cpp.

LD_MAX_MAN_LEN

#define LD_MAX_MAN_LEN   24 /* maximum length of mantissa (decimal)*/

Definition at line 29 of file atoldbl.cpp.

LD_MAX_MAN_LEN1

#define LD_MAX_MAN_LEN1   25 /* MAX_MAN_LEN+1 */

Definition at line 30 of file atoldbl.cpp.

LD_MAXEXP

#define LD_MAXEXP   0x7fff /* maximum biased exponent */

Definition at line 34 of file atoldbl.cpp.

MSB_ULONG

#define MSB_ULONG   ((uint32_t) 0x80000000)

Definition at line 24 of file atoldbl.cpp.

MSB_USHORT

#define MSB_USHORT   ((uint16_t) 0x8000)

Definition at line 23 of file atoldbl.cpp.

PTR_12

#define PTR_12

(

x

)

((uint8_t*)(&(x)->ld12))

Definition at line 21 of file atoldbl.cpp.

PUT_INF_12

#define PUT_INF_12	(		p,
			sign
	)

Value:

    *UL_HI_12 (p) = (sign) ? 0xffff8000 : 0x7fff8000; \
    *UL_MED_12(p) = 0;                                \
    *UL_LO_12 (p) = 0;

Definition at line 77 of file atoldbl.cpp.

PUT_INF_LD

#define PUT_INF_LD	(		p,
			sign
	)

Value:

    *U_EXP_LD   (p) = (sign) ? 0xffff : 0x7fff; \
    *UL_MANHI_LD(p) = 0x8000;                   \
    *UL_MANLO_LD(p) = 0;

Definition at line 92 of file atoldbl.cpp.

PUT_ZERO_12

#define PUT_ZERO_12

(

p

)

Value:

    *UL_HI_12 (p) = 0; \
    *UL_MED_12(p) = 0; \
    *UL_LO_12 (p) = 0;

Definition at line 82 of file atoldbl.cpp.

PUT_ZERO_LD

#define PUT_ZERO_LD

(

p

)

Value:

    *U_EXP_LD   (p) = 0; \
    *UL_MANHI_LD(p) = 0; \
    *UL_MANLO_LD(p) = 0;

Definition at line 97 of file atoldbl.cpp.

TEN_BYTE_PART

#define TEN_BYTE_PART

(

p

)

((uint8_t *)( PTR_12(p) + 2 ))

Definition at line 65 of file atoldbl.cpp.

TMAX10

#define TMAX10   5200 /* maximum temporary decimal exponent */

Definition at line 26 of file atoldbl.cpp.

TMIN10

#define TMIN10   -5200 /* minimum temporary decimal exponent */

Definition at line 27 of file atoldbl.cpp.

U_EXP_12

#define U_EXP_12

(

p

)

((uint16_t *)(PTR_12(p) + 10))

Definition at line 51 of file atoldbl.cpp.

U_EXP_LD

#define U_EXP_LD

(

p

)

((uint16_t*)(_PTR_LD(p) + 8))

Definition at line 68 of file atoldbl.cpp.

U_SHORT4_D

#define U_SHORT4_D

(

p

)

((uint16_t*)(p) + 3)

Definition at line 73 of file atoldbl.cpp.

U_XT_12

#define U_XT_12

(

p

)

((uint16_t *)(PTR_12(p) ))

Definition at line 54 of file atoldbl.cpp.

UCHAR_12

#define UCHAR_12	(		p,
			i
	)		((uint8_t *)( PTR_12(p) + (i)))

Definition at line 62 of file atoldbl.cpp.

UL_HI_12

#define UL_HI_12

(

p

)

((uint32_t*)(PTR_12(p) + 8))

Definition at line 59 of file atoldbl.cpp.

UL_HI_D

#define UL_HI_D

(

p

)

((uint32_t*)(p) + 1)

Definition at line 74 of file atoldbl.cpp.

UL_LO_12

#define UL_LO_12

(

p

)

((uint32_t*)(PTR_12(p) ))

Definition at line 57 of file atoldbl.cpp.

UL_LO_D

#define UL_LO_D

(

p

)

((uint32_t*)(p) )

Definition at line 75 of file atoldbl.cpp.

UL_MANHI_12

#define UL_MANHI_12

(

p

)

((uint32_t _UNALIGNED*)(PTR_12(p) + 6))

Definition at line 52 of file atoldbl.cpp.

UL_MANHI_LD

#define UL_MANHI_LD

(

p

)

((uint32_t*)(_PTR_LD(p) + 4))

Definition at line 69 of file atoldbl.cpp.

UL_MANLO_12

#define UL_MANLO_12

(

p

)

((uint32_t _UNALIGNED*)(PTR_12(p) + 2))

Definition at line 53 of file atoldbl.cpp.

UL_MANLO_LD

#define UL_MANLO_LD

(

p

)

((uint32_t*)(_PTR_LD(p) ))

Definition at line 70 of file atoldbl.cpp.

UL_MED_12

#define UL_MED_12

(

p

)

((uint32_t*)(PTR_12(p) + 4))

Definition at line 58 of file atoldbl.cpp.

ULONG_12

#define ULONG_12	(		p,
			i
	)		((uint32_t*)((uint8_t*)PTR_12(p) + (i)))

Definition at line 64 of file atoldbl.cpp.

USHORT_12

#define USHORT_12	(		p,
			i
	)		((uint16_t*)((uint8_t*)PTR_12(p) + (i)))

Definition at line 63 of file atoldbl.cpp.

Typedef Documentation

mantissa_t

typedef uint32_t* mantissa_t

Definition at line 680 of file atoldbl.cpp.

Function Documentation

_atoldbl()

int __cdecl _atoldbl	(	_LDOUBLE *const	result,
		char *const	string
	)

Definition at line 830 of file atoldbl.cpp.

{
    return _atoldbl_l(result, string, nullptr);
}

_atoldbl_l()

int __cdecl _atoldbl_l	(	_LDOUBLE *const	result,
		char *const	string,
		_locale_t const	locale
	)

Definition at line 816 of file atoldbl.cpp.

{
    _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);
}

Referenced by _atoldbl().

add_ld12()

static __forceinline void __cdecl add_ld12 ( _LDBL12 *const  x, _LDBL12 const *const  y  ) throw ( )

static

Definition at line 189 of file atoldbl.cpp.

{
    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));
}

Referenced by convert_mantissa_to_ld12(), and multiply_ld12_by< 10 >().

add_uint32_carry()

static __forceinline bool __cdecl add_uint32_carry ( uint32_t const  x, uint32_t const  y, uint32_t *const  sum  ) throw ( )

static

Definition at line 179 of file atoldbl.cpp.

{
    uint32_t const r = x + y;
 
    *sum = r;
 
    return r < x || r < y; // carry
}

Referenced by add_ld12(), increment_mantissa(), and multiply_ld12().

convert_ld12_to_ldouble()

static void __cdecl convert_ld12_to_ldouble ( _LDBL12 const *const  pld12, _LDOUBLE *const  result  ) throw ( )

static

Definition at line 786 of file atoldbl.cpp.

{
    // 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;
}

Referenced by _atoldbl_l().

convert_mantissa_to_ld12()

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 ( )

static

Definition at line 495 of file atoldbl.cpp.

{
    *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;
}

increment_mantissa()

static __forceinline bool __cdecl increment_mantissa ( mantissa_t const  mantissa, int const  nbit  ) throw ( )

static

Definition at line 721 of file atoldbl.cpp.

{
    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;
}

Referenced by round_mantissa().

mantissa_has_zero_tail()

static __forceinline bool __cdecl mantissa_has_zero_tail ( mantissa_t const  mantissa, int const  nbit  ) throw ( )

static

Definition at line 685 of file atoldbl.cpp.

{
    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;
}

Referenced by round_mantissa().

multiply_ld12()

static __forceinline void __cdecl multiply_ld12 ( _LDBL12 *const  px, _LDBL12 const *const  py  ) throw ( )

static

Definition at line 241 of file atoldbl.cpp.

{
    _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;
}

Referenced by multiply_ten_pow_ld12(), and multiply_two_pow_ld12().

multiply_ld12_by()

template<uint32_t N>

static __forceinline void __cdecl multiply_ld12_by ( _LDBL12 *  ) throw ( )

static

multiply_ld12_by< 10 >()

template<>

__forceinline void __cdecl multiply_ld12_by< 10 >	(	_LDBL12 *const	ld12	)
throw	(
	)

Definition at line 477 of file atoldbl.cpp.

{
    _LDBL12 const original_ld12 = *ld12;
    shl_ld12<2>(ld12);
    add_ld12(ld12, &original_ld12);
    shl_ld12<1>(ld12);
}

multiply_ld12_by< 16 >()

template<>

__forceinline void __cdecl multiply_ld12_by< 16 >	(	_LDBL12 *const	ld12	)
throw	(
	)

Definition at line 486 of file atoldbl.cpp.

{
    shl_ld12<4>(ld12);
}

multiply_ten_pow_ld12()

static __forceinline void __cdecl multiply_ten_pow_ld12 ( _LDBL12 *const  pld12, int  pow  ) throw ( )

static

Definition at line 417 of file atoldbl.cpp.

{
    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);
    }
}

Referenced by __crt_strtox::common_convert_to_ldbl12().

multiply_two_pow_ld12()

static __forceinline void __cdecl multiply_two_pow_ld12 ( _LDBL12 *const  ld12, int const  power  ) throw ( )

static

Definition at line 460 of file atoldbl.cpp.

{
    _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);
}

Referenced by __crt_strtox::common_convert_to_ldbl12().

round_mantissa()

static __forceinline bool __cdecl round_mantissa ( mantissa_t const  mantissa, int const  precision  ) throw ( )

static

Definition at line 753 of file atoldbl.cpp.

{
    // 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;
}

Referenced by convert_ld12_to_ldouble().

shl_ld12()

template<uint32_t N>

static __forceinline void __cdecl shl_ld12 ( _LDBL12 *const  p ) throw ( )

static

Definition at line 210 of file atoldbl.cpp.

{
    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;
}

shr_ld12()

static __forceinline void __cdecl shr_ld12 ( _LDBL12 *const  p ) throw ( )

static

Definition at line 230 of file atoldbl.cpp.

{
    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;
}

Referenced by multiply_ld12().

transform_into_return_value()

static int __cdecl transform_into_return_value ( SLD_STATUS const  status ) throw ( )

static

Definition at line 666 of file atoldbl.cpp.

{
    switch (status)
    {
    case SLD_OVERFLOW:  return _OVERFLOW;
    case SLD_UNDERFLOW: return _UNDERFLOW;
    default:            return 0;
    }
}

Referenced by _atoldbl_l().

Variable Documentation

ld12_pow10_negative

_LDBL12 const ld12_pow10_negative[]

static

Definition at line 142 of file atoldbl.cpp.

Referenced by multiply_ten_pow_ld12().

ld12_pow10_positive

_LDBL12 const ld12_pow10_positive[]

static

Definition at line 109 of file atoldbl.cpp.

Referenced by multiply_ten_pow_ld12().