xlocnum

// xlocnum internal header (from <locale>)

#pragma once

#ifndef _XLOCNUM_

#define _XLOCNUM_

#ifndef RC_INVOKED

#include <climits>

#include <cmath>

#include <cstdio>

#include <cstdlib> #include <streambuf>

#pragma pack(push,_CRT_PACKING)

#pragma pack(push,

)

#pragma warning(push,_STL_WARNING_LEVEL)

#pragma warning(push,

)

#pragma warning(disable: _STL_DISABLED_WARNINGS)

#pragma warning(disable:

4455

4494

4619

4643

4702

4984

4988

)

_STL_DISABLE_CLANG_WARNINGS

#pragma push_macro("new")

#undef new

// TEXT-TO-NUMERIC CONVERSION FUNCTIONS

#if !defined(MRTDLL) && !defined(_M_CEE_PURE)

_EXTERN_C #endif /* !defined(MRTDLL) etc. */

extern

"C"

{

extern _CRTIMP2_PURE float __CLRCALL_PURE_OR_CDECL _Stofx(const char *,

extern

float

__cdecl

_Stofx

(

const

char

_Out_opt_ _Deref_post_opt_valid_ char **,

char

**,

long

int

*);

extern _CRTIMP2_PURE double __CLRCALL_PURE_OR_CDECL _Stodx(const char *,

extern

double

__cdecl

_Stodx

(

const

char

_Out_opt_ _Deref_post_opt_valid_ char **,

char

**,

long

int

*);

extern _CRTIMP2_PURE long double __CLRCALL_PURE_OR_CDECL _Stoldx(const char *,

extern

long

double

__cdecl

_Stoldx

(

const

char

_Out_opt_ _Deref_post_opt_valid_ char **,

char

**,

long

int

*);

extern _CRTIMP2_PURE long __CLRCALL_PURE_OR_CDECL _Stolx(const char *,

extern

long

__cdecl

_Stolx

(

const

char

_Out_opt_ _Deref_post_opt_valid_ char **,

char

**,

int

*);

extern _CRTIMP2_PURE unsigned long __CLRCALL_PURE_OR_CDECL _Stoulx(const char *,

extern

unsigned

long

__cdecl

_Stoulx

(

const

char

_Out_opt_ _Deref_post_opt_valid_ char **,

char

**,

int

*);

extern _CRTIMP2_PURE long long __CLRCALL_PURE_OR_CDECL _Stollx(const char *,

extern

long

__cdecl

_Stollx

(

const

char

_Out_opt_ _Deref_post_opt_valid_ char **,

char

**,

int

*);

extern _CRTIMP2_PURE unsigned long long __CLRCALL_PURE_OR_CDECL _Stoullx(const char *,

extern

unsigned

long

__cdecl

_Stoullx

(

const

char

_Out_opt_ _Deref_post_opt_valid_ char **,

char

**,

int

*);

#if !defined(MRTDLL) && !defined(_M_CEE_PURE)

_END_EXTERN_C #endif /* !defined(MRTDLL) etc. */

}

_STD_BEGIN

namespace

std

{

// FUNCTION _Stodx_v2

inline

double

_Stodx_v2

(

const

char

_Str

char

_Endptr

int

_Pten

int

_Perr

) {

// convert string to double

int& _Errno_ref = errno; // Nonzero cost, pay it once

int

_Errno_ref

= (*

_errno

());

// Nonzero cost, pay it once

const

int

_Orig

_Errno_ref

;

_Errno_ref

;

double _Val = _CSTD strtod(_Str, _Endptr);

double

_Val

= ::

strtod

(

_Str

_Endptr

);

_Perr

_Errno_ref

;

_Errno_ref

_Orig

;

(

_Pten

)

_Val *= _CSTD pow(10.0, static_cast<double>(_Pten));

_Val

*= ::

pow

(

10.0

static_cast

double

_Pten

));

return

(

_Val

); }

// FUNCTION _Stofx_v2

inline

float

_Stofx_v2

(

const

char

_Str

char

_Endptr

int

_Pten

int

_Perr

) {

// convert string to float

int& _Errno_ref = errno; // Nonzero cost, pay it once

int

_Errno_ref

= (*

_errno

());

// Nonzero cost, pay it once

const

int

_Orig

_Errno_ref

;

_Errno_ref

;

float _Val = _CSTD strtof(_Str, _Endptr);

float

_Val

= ::

strtof

(

_Str

_Endptr

);

_Perr

_Errno_ref

;

_Errno_ref

_Orig

;

(

_Pten

)

_Val *= _CSTD powf(10.0f, static_cast<float>(_Pten));

_Val

*= ::

powf

(

10.0f

static_cast

float

_Pten

));

return

(

_Val

); }

// FUNCTION TEMPLATE _Find_elem

template

class

_Elem

size_t

_Base_size

inline

size_t

_Find_elem

(

const

_Elem

_Base

)[

_Base_size

const

_Elem

_Ch

) {

// lookup _Ch in array storing NUL-terminated string _Base

// pre: _Base contains no nulls except for _Base[_Base_size - 1]

return

(

static_cast

size_t

_Find_unchecked

(

_Base

+ (

_Base_size

_Ch

) -

_Base

)); }

inline

wchar_t

_Maklocwcs

(

const

wchar_t

_Ptr

) {

// copy NTWCS to allocated storage

const size_t _Count = _CSTD wcslen(_Ptr) + 1;

const

size_t

_Count

= ::

wcslen

(

_Ptr

) +

;

wchar_t

_Ptrdest

= (

wchar_t

_calloc_dbg

(

_Count

sizeof

(

wchar_t

_CRT_BLOCK, __FILE__, __LINE__);

"c:\\program files (x86)\\microsoft visual studio\\2017\\professional\\vc\\tools\\msvc\\14.16.27023\\include\\xlocnum"

101

);

_Ptrdest

)

_Xbad_alloc

();

_CSTD wmemcpy(_Ptrdest, _Ptr, _Count);

wmemcpy

(

_Ptrdest

_Ptr

_Count

);

return

(

_Ptrdest

); }

// CLASS TEMPLATE numpunct

template

class

_Elem

class

numpunct

public

locale

facet

{

// facet for defining numeric punctuation text

public

typedef

basic_string

_Elem

char_traits

_Elem

allocator

_Elem

> >

string_type

;

typedef

_Elem

char_type

;

__PURE_APPDOMAIN_GLOBAL _CRTIMP2_PURE_IMPORT static locale::id id; // unique facet id

__declspec

(dllimport)

static

locale

;

// unique facet id

_Elem

decimal_point

()

const

{

// return decimal point

return

(

do_decimal_point

()); }

_Elem

thousands_sep

()

const

{

// return thousands separator

return

(

do_thousands_sep

()); }

string

grouping

()

const

{

// return grouping string

return

(

do_grouping

()); }

string_type

falsename

()

const

{

// return name for false

return

(

do_falsename

()); }

string_type

truename

()

const

{

// return name for true

return

(

do_truename

()); }

explicit

numpunct

(

size_t

_Refs

) :

locale

facet

(

_Refs

) {

// construct from current locale

_BEGIN_LOCINFO(_Lobj)

{

_Locinfo

_Lobj

;

_Init

(

_Lobj

);

(

_Kseparator

)

_Kseparator

// NB: differs from "C" locale

_Maklocchr

(

','

static_cast

_Elem

*>(

nullptr

_Lobj

_Getcvt

());

_END_LOCINFO()

}

numpunct

(

const

_Locinfo

_Lobj

size_t

_Refs

bool

_Isdef

false

) :

locale

facet

(

_Refs

) {

// construct from specified locale

_Init

(

_Lobj

_Isdef

); }

static

size_t

(

const

locale

facet

** =

nullptr

const

locale

* =

nullptr

) {

// return locale category mask and construct standard facet

(

_Ppf

nullptr

&& *

_Ppf

nullptr

) *

_Ppf

new

numpunct

_Elem

_Locinfo

(

_Ploc

c_str

()),

true

);

return (_X_NUMERIC);

return

(

);

}

protected

virtual __CLR_OR_THIS_CALL ~numpunct() noexcept

virtual

numpunct

()

noexcept

{

// destroy the object

_Tidy

(); }

numpunct

(

const

char

_Locname

size_t

_Refs

bool

_Isdef

false

) :

locale

facet

(

_Refs

) {

// construct from specified locale

_BEGIN_LOCINFO(_Lobj(_Locname))

{

_Locinfo

_Lobj

(

_Locname

);

_Init

(

_Lobj

_Isdef

);

_END_LOCINFO()

}

template

class

_Elem2

void

_Getvals

(

_Elem2

const

lconv

_Ptr

_Locinfo

_Cvtvec

_Cvt

) {

// get values

_Dp

_Maklocchr

(

_Ptr

decimal_point

[

static_cast

_Elem2

*>(

nullptr

_Cvt

);

_Kseparator

_Maklocchr

(

_Ptr

thousands_sep

[

static_cast

_Elem2

*>(

nullptr

_Cvt

); }

void

_Getvals

(

wchar_t

const

lconv

_Ptr

_Locinfo

_Cvtvec

) {

// get values

_Dp

= (

_Elem

)

_Ptr

_W_decimal_point

[

];

_Kseparator

= (

_Elem

)

_Ptr

_W_thousands_sep

[

]; }

void

_Init

(

const

_Locinfo

_Lobj

bool

_Isdef

false

) {

// initialize from _Lobj

const

lconv

_Ptr

_Lobj

_Getlconv

();

_Locinfo

_Cvtvec

_Cvt

_Lobj

_Getcvt

();

// conversion information

_Grouping

nullptr

;

_Falsename

nullptr

;

_Truename

nullptr

;

_TRY_BEGIN

try

{

_Grouping

_Maklocstr

(

_Isdef

_Ptr

grouping

static_cast

char

*>(

nullptr

_Lobj

_Getcvt

());

_Falsename

_Maklocstr

(

_Lobj

_Getfalse

(),

static_cast

_Elem

*>(

nullptr

_Cvt

);

_Truename

_Maklocstr

(

_Lobj

_Gettrue

(),

static_cast

_Elem

*>(

nullptr

_Cvt

);

_CATCH_ALL

}

catch

(...) {

_Tidy

();

_RERAISE;

throw

;

_CATCH_END

}

(

_Isdef

) {

// apply defaults for required facets

// _Grouping = _Maklocstr("", static_cast<char *>(nullptr), _Cvt);

_Dp

_Maklocchr

(

'.'

static_cast

_Elem

*>(

nullptr

_Cvt

);

_Kseparator

_Maklocchr

(

','

static_cast

_Elem

*>(

nullptr

_Cvt

); }

else

_Getvals

((

_Elem

)

_Ptr

_Cvt

); }

virtual _Elem __CLR_OR_THIS_CALL do_decimal_point() const

virtual

_Elem

do_decimal_point

()

const

{

// return decimal point

return

(

_Dp

); }

virtual _Elem __CLR_OR_THIS_CALL do_thousands_sep() const

virtual

_Elem

do_thousands_sep

()

const

{

// return thousands separator

return

(

_Kseparator

); }

virtual string __CLR_OR_THIS_CALL do_grouping() const

virtual

string

do_grouping

()

const

{

// return grouping string

return

(

string

(

_Grouping

)); }

virtual string_type __CLR_OR_THIS_CALL do_falsename() const

virtual

string_type

do_falsename

()

const

{

// return name for false

return

(

string_type

(

_Falsename

)); }

virtual string_type __CLR_OR_THIS_CALL do_truename() const

virtual

string_type

do_truename

()

const

{

// return name for true

return

(

string_type

(

_Truename

)); }

private

void

_Tidy

() {

// free all storage

_CSTD free((void *)_Grouping);

free

((

void

_Grouping

);

_CSTD free((void *)_Falsename);

free

((

void

_Falsename

);

_CSTD free((void *)_Truename);

free

((

void

_Truename

);

}

const

char

_Grouping

;

// grouping string, "" for "C" locale

_Elem

_Dp

;

// decimal point, '.' for "C" locale

_Elem

_Kseparator

;

// thousands separator, '\0' for "C" locale

const

_Elem

_Falsename

;

// name for false, "false" for "C" locale

const

_Elem

_Truename

;

// name for true, "true" for "C" locale

};

// CLASS TEMPLATE numpunct_byname

template

class

_Elem

class

numpunct_byname

public

numpunct

_Elem

> {

// numpunct for named locale

public

explicit

numpunct_byname

(

const

char

_Locname

size_t

_Refs

) :

numpunct

_Elem

_Locname

_Refs

) {

// construct for named locale

}

explicit

numpunct_byname

(

const

string

_Str

size_t

_Refs

) :

numpunct

_Elem

_Str

c_str

(),

_Refs

) {

// construct for named locale

}

protected

virtual __CLR_OR_THIS_CALL ~numpunct_byname() noexcept

virtual

numpunct_byname

()

noexcept

{

// destroy the object

} };

// STATIC numpunct::id OBJECT

#if !(defined _CRTBLD && defined MSVC_SUPPLEMENTAL_2) // TRANSITION, VSO#578955

#ifdef __clang__

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wdllimport-static-field-def"

#endif /* __clang__ */

template

class

_Elem

__PURE_APPDOMAIN_GLOBAL locale::id numpunct<_Elem>::id;

locale

numpunct

_Elem

>::

;

#ifdef __clang__

#pragma clang diagnostic pop

#endif /* __clang__ */ #endif /* !(defined _CRTBLD && defined MSVC_SUPPLEMENTAL_2) */

// CLASS TEMPLATE num_get

template

class

_Elem

class

_InIt

istreambuf_iterator

_Elem

char_traits

_Elem

> > >

class

num_get

public

locale

facet

{

// facet for converting text to encoded numbers

public

static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet **_Ppf = nullptr,

static

size_t

__cdecl

(

const

locale

facet

** =

nullptr

const

locale

* =

nullptr

) {

// return locale category mask and construct standard facet

(

_Ppf

nullptr

&& *

_Ppf

nullptr

) *

_Ppf

new

num_get

_Elem

_InIt

_Locinfo

(

_Ploc

c_str

()));

return (_X_NUMERIC);

return

(

);

}

__PURE_APPDOMAIN_GLOBAL static locale::id id; // unique facet id

static

locale

;

// unique facet id

protected

virtual __CLR_OR_THIS_CALL ~num_get() noexcept

virtual

num_get

()

noexcept

{

// destroy the object

}

void

_Init

(

const

_Locinfo

&) {

// initialize from _Locinfo object

}

public

explicit __CLR_OR_THIS_CALL num_get(size_t _Refs = 0)

explicit

num_get

(

size_t

_Refs

)

locale

facet

(

_Refs

) {

// construct from current locale

_BEGIN_LOCINFO(_Lobj)

{

_Locinfo

_Lobj

;

_Init

(

_Lobj

);

_END_LOCINFO()

}

__CLR_OR_THIS_CALL num_get(const _Locinfo& _Lobj, size_t _Refs = 0)

num_get

(

const

_Locinfo

_Lobj

size_t

_Refs

)

locale

facet

(

_Refs

) {

// construct from specified locale

_Init

(

_Lobj

); }

typedef

_Elem

char_type

;

typedef

_InIt

iter_type

;

_InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last,

_InIt

get

(

_InIt

_First

_InIt

_Last

ios_base

_Iosbase

ios_base

iostate

_State

bool

_Val

)

const

{

// get bool from [_First, _Last) into _Val

return

(

do_get

(

_First

_Last

_Iosbase

_State

_Val

)); }

_InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last,

_InIt

get

(

_InIt

_First

_InIt

_Last

ios_base

_Iosbase

ios_base

iostate

_State

unsigned

short

_Val

)

const

{

// get unsigned short from [_First, _Last) into _Val

return

(

do_get

(

_First

_Last

_Iosbase

_State

_Val

)); }

_InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last,

_InIt

get

(

_InIt

_First

_InIt

_Last

ios_base

_Iosbase

ios_base

iostate

_State

unsigned

int

_Val

)

const

{

// get unsigned int from [_First, _Last) into _Val

return

(

do_get

(

_First

_Last

_Iosbase

_State

_Val

)); }

_InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last,

_InIt

get

(

_InIt

_First

_InIt

_Last

ios_base

_Iosbase

ios_base

iostate

_State

long

_Val

)

const

{

// get long from [_First, _Last) into _Val

return

(

do_get

(

_First

_Last

_Iosbase

_State

_Val

)); }

_InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last,

_InIt

get

(

_InIt

_First

_InIt

_Last

ios_base

_Iosbase

ios_base

iostate

_State

unsigned

long

_Val

)

const

{

// get unsigned long from [_First, _Last) into _Val

return

(

do_get

(

_First

_Last

_Iosbase

_State

_Val

)); }

_InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last,

_InIt

get

(

_InIt

_First

_InIt

_Last

ios_base

_Iosbase

ios_base

iostate

_State

long

_Val

)

const

{

// get long long from [_First, _Last) into _Val

return

(

do_get

(

_First

_Last

_Iosbase

_State

_Val

)); }

_InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last,

_InIt

get

(

_InIt

_First

_InIt

_Last

ios_base

_Iosbase

ios_base

iostate

_State

unsigned

long

_Val

)

const

{

// get unsigned long long from [_First, _Last) into _Val

return

(

do_get

(

_First

_Last

_Iosbase

_State

_Val

)); }

_InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last,

_InIt

get

(

_InIt

_First

_InIt

_Last

ios_base

_Iosbase

ios_base

iostate

_State

float

_Val

)

const

{

// get float from [_First, _Last) into _Val

return

(

do_get

(

_First

_Last

_Iosbase

_State

_Val

)); }

_InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last,

_InIt

get

(

_InIt

_First

_InIt

_Last

ios_base

_Iosbase

ios_base

iostate

_State

double

_Val

)

const

{

// get double from [_First, _Last) into _Val

return

(

do_get

(

_First

_Last

_Iosbase

_State

_Val

)); }

_InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last,

_InIt

get

(

_InIt

_First

_InIt

_Last

ios_base

_Iosbase

ios_base

iostate

_State

long

double

_Val

)

const

{

// get long double from [_First, _Last) into _Val

return

(

do_get

(

_First

_Last

_Iosbase

_State

_Val

)); }

_InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last,

_InIt

get

(

_InIt

_First

_InIt

_Last

ios_base

_Iosbase

ios_base

iostate

_State

void

_Val

)

const

{

// get void pointer from [_First, _Last) into _Val

return

(

do_get

(

_First

_Last

_Iosbase

_State

_Val

)); }

protected

virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last,

virtual

_InIt

do_get

(

_InIt

_First

_InIt

_Last

ios_base

_Iosbase

ios_base

iostate

_State

bool

_Val

)

const

{

// get bool from [_First, _Last) into _Val

_Adl_verify_range

(

_First

_Last

);

(

_Iosbase

flags

() &

ios_base

boolalpha

) {

// get false name or true name

const auto& _Punct_fac = _STD use_facet<numpunct<_Elem>>(_Iosbase.getloc());

const

auto

_Punct_fac

= ::

std

use_facet

numpunct

_Elem

>>(

_Iosbase

getloc

());

basic_string

_Elem

_Str

(

static_cast

size_t

_Elem

{});

_Str

_Punct_fac

falsename

();

_Str

push_back

(

_Elem

{});

_Str

_Punct_fac

truename

();

// construct "\0false\0true"

switch

(

_Getloctxt

(

_First

_Last

_Str

c_str

())) {

case

_Val

false

;

break

;

case

_Val

true

;

break

;

default

_Val

false

;

_State

ios_base

failbit

;

break

; } }

else

{

// get long value

char _Ac[_MAX_INT_DIG];

char

_Ac

[

];

const

int

_Base

_Getifld

(

_Ac

_First

_Last

_Iosbase

flags

(),

_Iosbase

getloc

());

// gather field

(

_Ac

[

]

'\0'

) {

// Handle N4727 [facet.num.get.virtuals]/3.6:

// "zero, if the conversion function does not convert the entire field."

// We should still do numeric conversion with bad digit separators, instead of

// setting 0, but we can't distinguish that from _Getifld's interface, and _Getifld's

// interface can't be changed as it is an exported function. Fixing that when ABI

// allows is tracked by VSO#591516.

_Val

false

;

_State

ios_base

failbit

; }

else

{

char

_Ep

;

int

_Errno

;

const long _Ans = _CSTD _Stolx(_Ac, &_Ep, _Base, &_Errno); // convert

const

long

_Ans

= ::

_Stolx

(

_Ac

, &

_Ep

_Base

, &

_Errno

);

// convert

(

_Ep

_Ac

_Errno

) {

_Val

true

;

_State

ios_base

failbit

; }

else

{

_Val

_Ans

;

(

_Ans

) {

_State

ios_base

failbit

; } } } }

(

_First

_Last

) {

_State

ios_base

eofbit

; }

return

(

_First

); }

virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last,

virtual

_InIt

do_get

(

_InIt

_First

_InIt

_Last

ios_base

_Iosbase

ios_base

iostate

_State

unsigned

short

_Val

)

const

{

// get unsigned short from [_First, _Last) into _Val

_Adl_verify_range

(

_First

_Last

);

char _Ac[_MAX_INT_DIG];

char

_Ac

[

];

const

int

_Base

_Getifld

(

_Ac

_First

_Last

_Iosbase

flags

(),

_Iosbase

getloc

());

// gather field

(

_Ac

[

]

'\0'

) {

// ditto "fails to convert the entire field" / VSO#591516

_State

ios_base

failbit

;

_Val

; }

else

{

const

bool

_Minus

_Ac

[

]

'-'

;

const

char

_Digits

_Ac

;

// C11 7.22.1.4/5: the sequence of characters starting with the first digit

// is interpreted as an integer constant according to the rules of 6.4.4.1

(

_Minus

) {

// skip over minus to start with the first digit

_Digits

; }

char

_Ep

;

int

_Errno

;

const unsigned long _Tmp = _CSTD _Stoulx(_Digits, &_Ep, _Base, &_Errno); // convert

const

unsigned

long

_Tmp

= ::

_Stoulx

(

_Digits

, &

_Ep

_Base

, &

_Errno

);

// convert

_Val

static_cast

unsigned

short

_Tmp

);

if (_Ep == _Digits || _Errno != 0 || _Tmp > USHRT_MAX)

(

_Ep

_Digits

_Errno

_Tmp

0xffff

)

{

_State

ios_base

failbit

;

_Val = USHRT_MAX;

_Val

0xffff

;

}

else

(

_Minus

) {

// C11 7.22.1.4/5: If the subject sequence begins with a minus sign,

// the value resulting from the conversion is negated (in the return type).

_Val

static_cast

unsigned

short

_Val

); } }

(

_First

_Last

) {

_State

ios_base

eofbit

; }

return

(

_First

); }

virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last,

virtual

_InIt

do_get

(

_InIt

_First

_InIt

_Last

ios_base

_Iosbase

ios_base

iostate

_State

unsigned

int

_Val

)

const

{

// get unsigned int from [_First, _Last) into _Val

static_assert

(

sizeof

(

unsigned

int

)

sizeof

(

unsigned

long

"Bad overflow assumptions due to sizeof(unsigned int) != sizeof(unsigned long)"

);

unsigned

long

_Tmp

;

_First

num_get

do_get

(

_First

_Last

_Iosbase

_State

_Tmp

);

// avoid virtual call for perf

_Val

_Tmp

;

return

(

_First

); }

virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last,

virtual

_InIt

do_get

(

_InIt

_First

_InIt

_Last

ios_base

_Iosbase

ios_base

iostate

_State

long

_Val

)

const

{

// get long from [_First, _Last) into _Val

_Adl_verify_range

(

_First

_Last

);

char _Ac[_MAX_INT_DIG];

char

_Ac

[

];

const

int

_Base

_Getifld

(

_Ac

_First

_Last

_Iosbase

flags

(),

_Iosbase

getloc

());

// gather field

(

_Ac

[

]

'\0'

) {

// ditto "fails to convert the entire field" / VSO#591516

_State

ios_base

failbit

;

_Val

; }

else

{

char

_Ep

;

int

_Errno

;

_Val = _CSTD _Stolx(_Ac, &_Ep, _Base, &_Errno); // convert

_Val

= ::

_Stolx

(

_Ac

, &

_Ep

_Base

, &

_Errno

);

// convert

(

_Ep

_Ac

_Errno

) {

_State

ios_base

failbit

; } }

(

_First

_Last

) {

_State

ios_base

eofbit

; }

return

(

_First

); }

virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last,

virtual

_InIt

do_get

(

_InIt

_First

_InIt

_Last

ios_base

_Iosbase

ios_base

iostate

_State

unsigned

long

_Val

)

const

{

// get unsigned long from [_First, _Last) into _Val

_Adl_verify_range

(

_First

_Last

);

char _Ac[_MAX_INT_DIG];

char

_Ac

[

];

const

int

_Base

_Getifld

(

_Ac

_First

_Last

_Iosbase

flags

(),

_Iosbase

getloc

());

// gather field

(

_Ac

[

]

'\0'

) {

// ditto "fails to convert the entire field" / VSO#591516

_State

ios_base

failbit

;

_Val

; }

else

{

char

_Ep

;

int

_Errno

;

_Val = _CSTD _Stoulx(_Ac, &_Ep, _Base, &_Errno); // convert

_Val

= ::

_Stoulx

(

_Ac

, &

_Ep

_Base

, &

_Errno

);

// convert

(

_Ep

_Ac

_Errno

) {

_State

ios_base

failbit

; } }

(

_First

_Last

) {

_State

ios_base

eofbit

; }

return

(

_First

); }

virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last,

virtual

_InIt

do_get

(

_InIt

_First

_InIt

_Last

ios_base

_Iosbase

ios_base

iostate

_State

long

_Val

)

const

{

// get long long from [_First, _Last) into _Val

_Adl_verify_range

(

_First

_Last

);

char _Ac[_MAX_INT_DIG];

char

_Ac

[

];

const

int

_Base

_Getifld

(

_Ac

_First

_Last

_Iosbase

flags

(),

_Iosbase

getloc

());

(

_Ac

[

]

'\0'

) {

// ditto "fails to convert the entire field" / VSO#591516

_State

ios_base

failbit

;

_Val

; }

else

{

char

_Ep

;

int

_Errno

;

_Val = _CSTD _Stollx(_Ac, &_Ep, _Base, &_Errno); // convert

_Val

= ::

_Stollx

(

_Ac

, &

_Ep

_Base

, &

_Errno

);

// convert

(

_Ep

_Ac

_Errno

) {

_State

ios_base

failbit

; } }

(

_First

_Last

) {

_State

ios_base

eofbit

; }

return

(

_First

); }

virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last,

virtual

_InIt

do_get

(

_InIt

_First

_InIt

_Last

ios_base

_Iosbase

ios_base

iostate

_State

unsigned

long

_Val

)

const

{

// get unsigned long long from [_First, _Last) into _Val

_Adl_verify_range

(

_First

_Last

);

char _Ac[_MAX_INT_DIG];

char

_Ac

[

];

const

int

_Base

_Getifld

(

_Ac

_First

_Last

_Iosbase

flags

(),

_Iosbase

getloc

());

(

_Ac

[

]

'\0'

) {

// ditto "fails to convert the entire field" / VSO#591516

_State

ios_base

failbit

;

_Val

; }

else

{

int

_Errno

;

char

_Ep

;

_Val = _CSTD _Stoullx(_Ac, &_Ep, _Base, &_Errno); // convert

_Val

= ::

_Stoullx

(

_Ac

, &

_Ep

_Base

, &

_Errno

);

// convert

(

_Ep

_Ac

_Errno

) {

_State

ios_base

failbit

; } }

(

_First

_Last

) {

_State

ios_base

eofbit

; }

return

(

_First

); }

// Sentinel value used by num_get::do_get() to enable correct "V2" behavior in _Getffld() and _Getffldx()

#define _ENABLE_V2_BEHAVIOR 1000000000

// Size of char buffer used by num_get::do_get() for float/double/long double

#define _FLOATING_BUFFER_SIZE (_MAX_EXP_DIG + _MAX_SIG_DIG_V2 + 16)

virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last,

virtual

_InIt

do_get

(

_InIt

_First

_InIt

_Last

ios_base

_Iosbase

ios_base

iostate

_State

float

_Val

)

const

{

// get float from [_First, _Last) into _Val

_Adl_verify_range

(

_First

_Last

);

char _Ac[_FLOATING_BUFFER_SIZE];

char

_Ac

[(

768

)];

int _Hexexp = _ENABLE_V2_BEHAVIOR;

int

_Hexexp

1000000000

;

const

int

_Base

_Getffld

(

_Ac

_First

_Last

_Iosbase

, &

_Hexexp

);

// gather field

(

_Ac

[

]

'\0'

) {

// ditto "fails to convert the entire field" / VSO#591516

_State

ios_base

failbit

;

_Val

0.0f

; }

else

{

int

_Errno

;

char

_Ep

;

_Val

_Stofx_v2

(

_Ac

, &

_Ep

_Base

, &

_Errno

);

// convert

(

_Ep

_Ac

_Errno

) {

_State

ios_base

failbit

;

_Val

0.0f

; }

else if (_Hexexp != _ENABLE_V2_BEHAVIOR && _Hexexp != 0)

else

(

_Hexexp

1000000000

_Hexexp

)

{

_Val = _CSTD ldexpf(_Val, 4 * _Hexexp);

_Val

= ::

ldexpf

(

_Val

_Hexexp

);

} }

(

_First

_Last

) {

_State

ios_base

eofbit

; }

return

(

_First

); }

virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last,

virtual

_InIt

do_get

(

_InIt

_First

_InIt

_Last

ios_base

_Iosbase

ios_base

iostate

_State

double

_Val

)

const

{

// get double from [_First, _Last) into _Val

_Adl_verify_range

(

_First

_Last

);

char _Ac[_FLOATING_BUFFER_SIZE];

char

_Ac

[(

768

)];

int _Hexexp = _ENABLE_V2_BEHAVIOR;

int

_Hexexp

1000000000

;

const

int

_Base

_Getffld

(

_Ac

_First

_Last

_Iosbase

, &

_Hexexp

);

// gather field

(

_Ac

[

]

'\0'

) {

// ditto "fails to convert the entire field" / VSO#591516

_State

ios_base

failbit

;

_Val

0.0

; }

else

{

int

_Errno

;

char

_Ep

;

_Val

_Stodx_v2

(

_Ac

, &

_Ep

_Base

, &

_Errno

);

// convert

(

_Ep

_Ac

_Errno

) {

_State

ios_base

failbit

;

_Val

0.0

; }

else if (_Hexexp != _ENABLE_V2_BEHAVIOR && _Hexexp != 0)

else

(

_Hexexp

1000000000

_Hexexp

)

{

_Val = _CSTD ldexp(_Val, 4 * _Hexexp);

_Val

= ::

ldexp

(

_Val

_Hexexp

);

} }

(

_First

_Last

) {

_State

ios_base

eofbit

; }

return

(

_First

); }

#undef _FLOATING_BUFFER_SIZE

virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last,

virtual

_InIt

do_get

(

_InIt

_First

_InIt

_Last

ios_base

_Iosbase

ios_base

iostate

_State

long

double

_Val

)

const

{

// get long double from [_First, _Last) into _Val

static_assert

(

sizeof

(

double

)

sizeof

(

long

double

"Bad assumption: sizeof(double) == sizeof(long double)."

);

double

_Result

;

_First

num_get

do_get

(

_First

_Last

_Iosbase

_State

_Result

);

// avoid virtual call for perf

_Val

_Result

;

return

(

_First

); }

virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last,

virtual

_InIt

do_get

(

_InIt

_First

_InIt

_Last

ios_base

_Iosbase

ios_base

iostate

_State

void

_Val

)

const

{

// get void pointer from [_First, _Last) into _Val

_Adl_verify_range

(

_First

_Last

);

char _Ac[_MAX_INT_DIG];

char

_Ac

[

];

const

int

_Base

_Getifld

(

_Ac

_First

_Last

ios_base

hex

_Iosbase

getloc

());

// gather field

(

_Ac

[

]

'\0'

) {

// ditto "fails to convert the entire field" / VSO#591516

_State

ios_base

failbit

;

_Val

nullptr

; }

else

{

int

_Errno

;

char

_Ep

;

#ifdef _WIN64

_Val = reinterpret_cast<void *>(_CSTD _Stoullx(_Ac, &_Ep, _Base, &_Errno));

#else /* ^^^ _WIN64 ^^^ // vvv !_WIN64 vvv */

_Val = reinterpret_cast<void *>(_CSTD _Stoulx(_Ac, &_Ep, _Base, &_Errno)); #endif /* _WIN64 */

_Val

reinterpret_cast

void

*>(::

_Stoulx

(

_Ac

, &

_Ep

_Base

, &

_Errno

));

(

_Ep

_Ac

_Errno

) {

_State

ios_base

failbit

;

_Val

nullptr

; } }

(

_First

_Last

) {

_State

ios_base

eofbit

; }

return

(

_First

); }

private

int __CLRCALL_OR_CDECL _Getifld(char *_Ac,

int

__cdecl

_Getifld

(

char

_Ac

_InIt

_First

_InIt

_Last

ios_base

fmtflags

_Basefield

const

locale

_Loc

)

const

{

// get integer field from [_First, _Last) into _Ac

const auto& _Punct_fac = _STD use_facet<numpunct<_Elem>>(_Loc);

const

auto

_Punct_fac

= ::

std

use_facet

numpunct

_Elem

>>(

_Loc

);

const

string

_Grouping

_Punct_fac

grouping

();

const

_Elem

_Kseparator

_Grouping

size

()

? (

_Elem

)

_Punct_fac

thousands_sep

();

constexpr

int

_Numget_signoff

;

constexpr

int

_Numget_xoff

;

static

constexpr

char

_Src

[] = {

"0123456789ABCDEFabcdef-+Xx"

};

_Elem

_Atoms

[

sizeof

(

_Src

)];

const ctype<_Elem>& _Ctype_fac = _STD use_facet<ctype<_Elem>>(_Loc);

const

ctype

_Elem

_Ctype_fac

= ::

std

use_facet

ctype

_Elem

>>(

_Loc

);

_Ctype_fac

widen

_Src

[

], &

_Src

[

sizeof

(

_Src

)],

_Atoms

);

char

_Ptr

_Ac

;

(

_First

_Last

) {

_First

_Atoms

[

_Numget_signoff

]) {

// gather plus sign

_Ptr

++ =

'+'

; ++

_First

; }

else

_First

_Atoms

[

_Numget_signoff

]) {

// gather minus sign

_Ptr

++ =

'-'

; ++

_First

; } }

_Basefield

ios_base

basefield

;

int

_Base

_Basefield

ios_base

oct

_Basefield

ios_base

hex

_Basefield

ios_base

_Fmtzero

;

bool

_Seendigit

false

;

// seen a digit in input

bool

_Nonzero

false

;

// seen a nonzero digit in input

(

_First

_Last

&& *

_First

_Atoms

[

]) {

// leading zero, look for 0x, 0X

_Seendigit

true

; ++

_First

;

(

_First

_Last

&& (*

_First

_Atoms

[

_Numget_xoff

] || *

_First

_Atoms

[

_Numget_xoff

]) && (

_Base

)) {

_Base

;

_Seendigit

false

; ++

_First

; }

else

(

_Base

) {

_Base

; } }

const

auto

_Dlen

static_cast

size_t

_Base

);

string

_Groups

((

size_t

)

, (

char

)

_Seendigit

);

size_t

_Group

;

for (char *const _Pe = &_Ac[_MAX_INT_DIG - 1];

for

(

char

const

_Pe

= &

_Ac

[

];

_First

_Last

; ++

_First

) {

// look for digits and separators

size_t

_Idx

_Find_elem

(

_Atoms

, *

_First

);

(

_Idx

_Dlen

) {

// got a digit, characterize it and add to group size

_Ptr

_Src

[

_Idx

];

((

_Nonzero

|| *

_Ptr

'0'

) &&

_Ptr

_Pe

) { ++

_Ptr

;

_Nonzero

true

; }

_Seendigit

true

;

if (_Groups[_Group] != CHAR_MAX)

(

_Groups

[

_Group

]

127

)

_Groups

[

_Group

]; }

else

(

_Groups

[

_Group

]

'\0'

_Kseparator

== (

_Elem

)

|| *

_First

_Kseparator

)

break

;

// not a group separator, done

else

{

// add a new group to _Groups string

_Groups

push_back

(

'\0'

); ++

_Group

; } }

(

_Group

) {

(

'\0'

_Groups

[

_Group

]) { ++

_Group

;

// add trailing group to group count

}

else

{

_Seendigit

false

;

// trailing separator, fail

} }

for

(

const

char

_Pg

= &

_Grouping

[

];

_Seendigit

_Group

; )

if (*_Pg == CHAR_MAX)

_Pg

127

)

break

;

// end of grouping constraints to check

else

((

_Group

&& *

_Pg

_Groups

[

_Group

]) || (

_Group

&& *

_Pg

_Groups

[

_Group

]))

_Seendigit

false

;

// bad group size, fail

else

(

'\0'

_Pg

[

]) ++

_Pg

;

// group size okay, advance to next test

(

_Seendigit

&& !

_Nonzero

) *

_Ptr

++ =

'0'

;

// zero field, replace stripped zero(s)

else

_Seendigit

)

_Ptr

_Ac

;

// roll back pointer to indicate failure

_Ptr

'\0'

;

return

(

_Base

); }

int __CLRCALL_OR_CDECL _Getffld(char *_Ac,

int

__cdecl

_Getffld

(

char

_Ac

_InIt

_First

_InIt

_Last

ios_base

_Iosbase

int

_Phexexp

)

const

{

// get floating-point field from [_First, _Last) into _Ac

((

_Iosbase

flags

() &

ios_base

floatfield

) ==

ios_base

hexfloat

)

return

(

_Getffldx

(

_Ac

_First

_Last

_Iosbase

_Phexexp

));

// hex format

const auto& _Punct_fac = _STD use_facet<numpunct<_Elem>>(_Iosbase.getloc());

const

auto

_Punct_fac

= ::

std

use_facet

numpunct

_Elem

>>(

_Iosbase

getloc

());

const

string

_Grouping

_Punct_fac

grouping

();

char

_Ptr

_Ac

;

bool

_Bad

false

;

bool

_Sticky

false

;

constexpr

int

_Numget_signoff

;

constexpr

int

_Numget_eoff

;

static

constexpr

char

_Src

[] = {

"0123456789-+Ee"

};

_Elem

_Atoms

[

sizeof

(

_Src

)];

const ctype<_Elem>& _Ctype_fac = _STD use_facet<ctype<_Elem>>(_Iosbase.getloc());

const

ctype

_Elem

_Ctype_fac

= ::

std

use_facet

ctype

_Elem

>>(

_Iosbase

getloc

());

_Ctype_fac

widen

_Src

[

], &

_Src

[

sizeof

(

_Src

)],

_Atoms

);

(

_First

_Last

) {

_First

_Atoms

[

_Numget_signoff

]) {

// gather plus sign

_Ptr

++ =

'+'

; ++

_First

; }

else

_First

_Atoms

[

_Numget_signoff

]) {

// gather minus sign

_Ptr

++ =

'-'

; ++

_First

; } }

char

_Leading

_Ptr

;

// remember backstop

_Ptr

++ =

'0'

;

// backstop carries from sticky bit

bool

_Seendigit

false

;

// seen a digit in input

int

_Significant

;

// number of significant digits

int

_Pten

;

// power of 10 multiplier

size_t

_Idx

;

const int _Max_sig_dig = (*_Phexexp == _ENABLE_V2_BEHAVIOR ? _MAX_SIG_DIG_V2 : _MAX_SIG_DIG_V1);

const

int

_Max_sig_dig

= (*

_Phexexp

1000000000

768

);

const

char

_Pg

= &

_Grouping

[

];

if (*_Pg == CHAR_MAX || *_Pg <= '\0')

_Pg

127

|| *

_Pg

'\0'

)

{

for

(;

_First

_Last

&& (

_Idx

_Find_elem

(

_Atoms

, *

_First

)) <

;

_Seendigit

true

, (

void

)++

_First

) {

(

_Max_sig_dig

_Significant

) {

// enough digits, scale by 10 and update _Sticky

_Pten

;

(

_Idx

) {

_Sticky

true

; } }

else

(

_Idx

_Significant

) {

// save a significant digit

_Ptr

++ =

_Src

[

_Idx

]; ++

_Significant

; } } }

else

{

// grouping specified, gather digits and group sizes

const

_Elem

_Kseparator

_Grouping

size

()

? (

_Elem

)

_Punct_fac

thousands_sep

();

string

_Groups

((

size_t

)

'\0'

);

size_t

_Group

;

for

(;

_First

_Last

; ++

_First

) {

((

_Idx

_Find_elem

(

_Atoms

, *

_First

))

) {

// got a digit, add to group size

_Seendigit

true

;

(

_Max_sig_dig

_Significant

) {

// enough digits, scale by 10 and update _Sticky

_Pten

;

(

_Idx

) {

_Sticky

true

; } }

else

(

_Idx

_Significant

) {

// save a significant digit

_Ptr

++ =

_Src

[

_Idx

]; ++

_Significant

; }

if (_Groups[_Group] != CHAR_MAX)

(

_Groups

[

_Group

]

127

)

{ ++

_Groups

[

_Group

]; } }

else

(

_Groups

[

_Group

]

'\0'

_Kseparator

== (

_Elem

)

|| *

_First

_Kseparator

) {

break

;

// not a group separator, done

}

else

{

// add a new group to _Groups string

_Groups

push_back

(

'\0'

); ++

_Group

; } }

(

_Group

) {

(

'\0'

_Groups

[

_Group

]) { ++

_Group

;

// add trailing group to group count

}

else

{

_Bad

true

;

// trailing separator, fail

} }

while

_Bad

_Group

) {

if (*_Pg == CHAR_MAX)

_Pg

127

)

{

break

;

// end of grouping constraints to check

}

((

_Group

&& *

_Pg

_Groups

[

_Group

]) || (

_Group

&& *

_Pg

_Groups

[

_Group

])) {

_Bad

true

;

// bad group size, fail

}

else

(

'\0'

_Pg

[

]) { ++

_Pg

;

// group size okay, advance to next test

} } }

(

_First

_Last

&& *

_First

_Punct_fac

decimal_point

()) {

// add .

_Ptr

++ =

localeconv

()->

decimal_point

[

]; ++

_First

; }

if (*_Phexexp != _ENABLE_V2_BEHAVIOR && _Significant == 0)

_Phexexp

1000000000

_Significant

)

{

// 0000. so far

for

(;

_First

_Last

&& *

_First

_Atoms

[

];

_Seendigit

true

, (

void

)++

_First

) --

_Pten

;

// just count leading fraction zeros

(

_Pten

) {

// put one back

_Ptr

++ =

'0'

; ++

_Pten

; } }

for

(;

_First

_Last

&& (

_Idx

_Find_elem

(

_Atoms

, *

_First

)) <

;

_Seendigit

true

, (

void

)++

_First

)

(

_Significant

_Max_sig_dig

) {

// save a significant fraction digit

_Ptr

++ =

_Src

[

_Idx

]; ++

_Significant

; }

else

(

_Idx

)

_Sticky

true

;

// just update _Sticky

(

_Sticky

) {

// increment ls digit in memory of those lost

char

_Px

_Ptr

;

while

(--

_Px

_Leading

) {

// add in carry

_Px

localeconv

()->

decimal_point

[

]) {

// non decimal point

_Px

'9'

) {

// carry stops here

++*

_Px

;

break

; } *

_Px

'0'

;

// propagate carry

} }

(

_Px

_Leading

) {

// change "999..." to "1000..." and scale _Pten

_Px

'1'

; ++

_Pten

; } }

(

_Seendigit

_First

_Last

&& (*

_First

_Atoms

[

_Numget_eoff

] || *

_First

_Atoms

[

_Numget_eoff

])) {

// 'e' or 'E', collect exponent

_Ptr

++ =

'e'

; ++

_First

;

_Seendigit

false

;

_Significant

;

(

_First

_Last

) {

_First

_Atoms

[

_Numget_signoff

]) {

// gather plus sign

_Ptr

++ =

'+'

; ++

_First

; }

else

_First

_Atoms

[

_Numget_signoff

]) {

// gather minus sign

_Ptr

++ =

'-'

; ++

_First

; } }

for

(;

_First

_Last

&& *

_First

_Atoms

[

]; ++

_First

) {

// strip leading zeros

_Seendigit

true

; }

(

_Seendigit

) *

_Ptr

++ =

'0'

;

// put one back

for

(;

_First

_Last

&& (

_Idx

_Find_elem

(

_Atoms

, *

_First

)) <

;

_Seendigit

true

, (

void

)++

_First

)

if (_Significant < _MAX_EXP_DIG)

(

_Significant

)

{

// save a significant exponent digit

_Ptr

++ =

_Src

[

_Idx

]; ++

_Significant

; } }

(

_Bad

|| !

_Seendigit

)

_Ptr

_Ac

;

// roll back pointer to indicate failure

_Ptr

'\0'

;

return

(

_Pten

); }

int __CLRCALL_OR_CDECL _Getffldx(char *_Ac,

int

__cdecl

_Getffldx

(

char

_Ac

_InIt

_First

_InIt

_Last

ios_base

_Iosbase

int

_Phexexp

)

const

{

// get hex floating-point field from [_First, _Last) into _Ac

const auto& _Punct_fac = _STD use_facet<numpunct<_Elem>>(_Iosbase.getloc());

const

auto

_Punct_fac

= ::

std

use_facet

numpunct

_Elem

>>(

_Iosbase

getloc

());

const

string

_Grouping

_Punct_fac

grouping

();

constexpr

int

_Numget_signoff

;

constexpr

int

_Numget_xoff

;

constexpr

int

_Numget_poff

;

static

constexpr

char

_Src

[] = {

"0123456789ABCDEFabcdef-+XxPp"

};

_Elem

_Atoms

[

sizeof

(

_Src

)];

const ctype<_Elem>& _Ctype_fac = _STD use_facet<ctype<_Elem>>(_Iosbase.getloc());

const

ctype

_Elem

_Ctype_fac

= ::

std

use_facet

ctype

_Elem

>>(

_Iosbase

getloc

());

_Ctype_fac

widen

_Src

[

], &

_Src

[

sizeof

(

_Src

)],

_Atoms

);

char

_Ptr

_Ac

;

bool

_Bad

false

;

size_t

_Idx

;

(

_First

_Last

) {

_First

_Atoms

[

_Numget_signoff

]) {

// gather plus sign

_Ptr

++ =

'+'

; ++

_First

; }

else

_First

_Atoms

[

_Numget_signoff

]) {

// gather minus sign

_Ptr

++ =

'-'

; ++

_First

; } } *

_Ptr

++ =

'0'

; *

_Ptr

++ =

'x'

;

bool

_Seendigit

false

;

// seen a digit in input

int

_Significant

;

// number of significant digits

int

_Phex

;

// power of 10 multiplier

(

_First

_Last

&& *

_First

_Atoms

[

]) {

(++

_First

_Last

&& (*

_First

_Atoms

[

_Numget_xoff

] || *

_First

_Atoms

[

_Numget_xoff

])) { ++

_First

;

// discard any 0x or 0X

}

else

{

_Seendigit

true

;

// '0' not followed by 'x' or 'X'

} }

const int _Max_sig_dig = (*_Phexexp == _ENABLE_V2_BEHAVIOR ? _MAX_SIG_DIG_V2 : _MAX_SIG_DIG_V1);

const

int

_Max_sig_dig

= (*

_Phexexp

1000000000

768

);

const

char

_Pg

= &

_Grouping

[

];

if (*_Pg == CHAR_MAX || *_Pg <= '\0')

_Pg

127

|| *

_Pg

'\0'

)

{

for

(;

_First

_Last

&& (

_Idx

_Find_elem

(

_Atoms

, *

_First

)) <

_Numget_signoff

;

_Seendigit

true

, (

void

)++

_First

) {

(

_Max_sig_dig

_Significant

) { ++

_Phex

;

// just scale by 10

}

else

(

_Idx

_Significant

) {

// save a significant digit

_Ptr

++ =

_Src

[

_Idx

]; ++

_Significant

; } } }

else

{

// grouping specified, gather digits and group sizes

const

_Elem

_Kseparator

_Grouping

size

()

? (

_Elem

)

_Punct_fac

thousands_sep

();

string

_Groups

((

size_t

)

'\0'

);

size_t

_Group

;

for

(;

_First

_Last

; ++

_First

) {

((

_Idx

_Find_elem

(

_Atoms

, *

_First

))

_Numget_signoff

) {

// got a digit, add to group size

_Seendigit

true

;

(

_Max_sig_dig

_Significant

) { ++

_Phex

;

// just scale by 10

}

else

(

_Idx

_Significant

) {

// save a significant digit

_Ptr

++ =

_Src

[

_Idx

]; ++

_Significant

; }

if (_Groups[_Group] != CHAR_MAX)

(

_Groups

[

_Group

]

127

)

{ ++

_Groups

[

_Group

]; } }

else

(

_Groups

[

_Group

]

'\0'

_Kseparator

== (

_Elem

)

|| *

_First

_Kseparator

) {

break

;

// not a group separator, done

}

else

{

// add a new group to _Groups string

_Groups

push_back

(

'\0'

); ++

_Group

; } }

(

_Group

) {

(

'\0'

_Groups

[

_Group

]) { ++

_Group

;

// add trailing group to group count

}

else

{

_Bad

true

;

// trailing separator, fail

} }

while

_Bad

_Group

) {

if (*_Pg == CHAR_MAX)

_Pg

127

)

{

break

;

// end of grouping constraints to check

}

((

_Group

&& *

_Pg

_Groups

[

_Group

]) || (

_Group

&& *

_Pg

_Groups

[

_Group

])) {

_Bad

true

;

// bad group size, fail

}

else

(

'\0'

_Pg

[

]) { ++

_Pg

;

// group size okay, advance to next test

} } }

(

_Seendigit

_Significant

) *

_Ptr

++ =

'0'

;

// save at least one leading digit

(

_First

_Last

&& *

_First

_Punct_fac

decimal_point

()) {

// add .

_Ptr

++ =

localeconv

()->

decimal_point

[

]; ++

_First

; }

(

_Significant

) {

// 0000. so far

for

(;

_First

_Last

&& *

_First

_Atoms

[

];

_Seendigit

true

, (

void

)++

_First

) --

_Phex

;

// just count leading fraction zeros

(

_Phex

) {

// put one back

_Ptr

++ =

'0'

; ++

_Phex

; } }

for

(;

_First

_Last

&& (

_Idx

_Find_elem

(

_Atoms

, *

_First

)) <

_Numget_signoff

;

_Seendigit

true

, (

void

)++

_First

)

(

_Significant

_Max_sig_dig

) {

// save a significant fraction digit

_Ptr

++ =

_Src

[

_Idx

]; ++

_Significant

; }

(

_Seendigit

_First

_Last

&& (*

_First

_Atoms

[

_Numget_poff

] || *

_First

_Atoms

[

_Numget_poff

])) {

// 'p' or 'P', collect exponent

_Ptr

++ =

'p'

; ++

_First

;

_Seendigit

false

;

_Significant

;

(

_First

_Last

) {

_First

_Atoms

[

_Numget_signoff

]) {

// gather plus sign

_Ptr

++ =

'+'

; ++

_First

; }

else

_First

_Atoms

[

_Numget_signoff

]) {

// gather minus sign

_Ptr

++ =

'-'

; ++

_First

; } }

for

(;

_First

_Last

&& *

_First

_Atoms

[

]; ++

_First

) {

// strip leading zeros

_Seendigit

true

; }

(

_Seendigit

) *

_Ptr

++ =

'0'

;

// put one back

for

(;

_First

_Last

&& (

_Idx

_Find_elem

(

_Atoms

, *

_First

)) <

_Numget_signoff

;

_Seendigit

true

, (

void

)++

_First

)

if (_Significant < _MAX_EXP_DIG)

(

_Significant

)

{

// save a significant exponent digit

_Ptr

++ =

_Src

[

_Idx

]; ++

_Significant

; } }

(

_Bad

|| !

_Seendigit

)

_Ptr

_Ac

;

// roll back pointer to indicate failure

_Ptr

'\0'

; *

_Phexexp

_Phex

;

// power of 16 multiplier

return

(

);

// power of 10 multiplier

}

#undef _ENABLE_V2_BEHAVIOR

};

// STATIC num_get::id OBJECT

#ifdef __clang__

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wdllimport-static-field-def"

#endif /* __clang__ */

template

class

_Elem

class

_InIt

__PURE_APPDOMAIN_GLOBAL locale::id num_get<_Elem, _InIt>::id;

locale

num_get

_Elem

_InIt

>::

;

#ifdef __clang__

#pragma clang diagnostic pop

#endif /* __clang__ */

// CLASS TEMPLATE num_put

template

class

_Elem

class

_OutIt

ostreambuf_iterator

_Elem

char_traits

_Elem

> > >

class

num_put

public

locale

facet

{

// facet for converting encoded numbers to text

public

static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet **_Ppf = nullptr,

static

size_t

__cdecl

(

const

locale

facet

** =

nullptr

const

locale

* =

nullptr

) {

// return locale category mask and construct standard facet

(

_Ppf

nullptr

&& *

_Ppf

nullptr

) *

_Ppf

new

num_put

_Elem

_OutIt

_Locinfo

(

_Ploc

c_str

()));

return (_X_NUMERIC);

return

(

);

}

__PURE_APPDOMAIN_GLOBAL static locale::id id; // unique facet id

static

locale

;

// unique facet id

protected

virtual __CLR_OR_THIS_CALL ~num_put() noexcept

virtual

num_put

()

noexcept

{

// destroy the object

}

void __CLR_OR_THIS_CALL _Init(const _Locinfo&)

void

_Init

(

const

_Locinfo

{

// initialize from _Locinfo object

}

public

explicit __CLR_OR_THIS_CALL num_put(size_t _Refs = 0)

explicit

num_put

(

size_t

_Refs

)

locale

facet

(

_Refs

) {

// construct from current locale

_BEGIN_LOCINFO(_Lobj)

{

_Locinfo

_Lobj

;

_Init

(

_Lobj

);

_END_LOCINFO()

}

__CLR_OR_THIS_CALL num_put(const _Locinfo& _Lobj, size_t _Refs = 0)

num_put

(

const

_Locinfo

_Lobj

size_t

_Refs

)

locale

facet

(

_Refs

) {

// construct from specified locale

_Init

(

_Lobj

); }

typedef

_Elem

char_type

;

typedef

_OutIt

iter_type

;

_OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest,

_OutIt

put

(

_OutIt

_Dest

ios_base

_Iosbase

_Elem

_Fill

bool

_Val

)

const

{

// put formatted bool to _Dest

return

(

do_put

(

_Dest

_Iosbase

_Fill

_Val

)); }

_OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest,

_OutIt

put

(

_OutIt

_Dest

ios_base

_Iosbase

_Elem

_Fill

long

_Val

)

const

{

// put formatted long to _Dest

return

(

do_put

(

_Dest

_Iosbase

_Fill

_Val

)); }

_OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest,

_OutIt

put

(

_OutIt

_Dest

ios_base

_Iosbase

_Elem

_Fill

unsigned

long

_Val

)

const

{

// put formatted unsigned long to _Dest

return

(

do_put

(

_Dest

_Iosbase

_Fill

_Val

)); }

_OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest,

_OutIt

put

(

_OutIt

_Dest

ios_base

_Iosbase

_Elem

_Fill

long

_Val

)

const

{

// put formatted long long to _Dest

return

(

do_put

(

_Dest

_Iosbase

_Fill

_Val

)); }

_OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest,

_OutIt

put

(

_OutIt

_Dest

ios_base

_Iosbase

_Elem

_Fill

unsigned

long

_Val

)

const

{

// put formatted unsigned long long to _Dest

return

(

do_put

(

_Dest

_Iosbase

_Fill

_Val

)); }

_OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest,

_OutIt

put

(

_OutIt

_Dest

ios_base

_Iosbase

_Elem

_Fill

double

_Val

)

const

{

// put formatted double to _Dest

return

(

do_put

(

_Dest

_Iosbase

_Fill

_Val

)); }

_OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest,

_OutIt

put

(

_OutIt

_Dest

ios_base

_Iosbase

_Elem

_Fill

long

double

_Val

)

const

{

// put formatted long double to _Dest

return

(

do_put

(

_Dest

_Iosbase

_Fill

_Val

)); }

_OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest,

_OutIt

put

(

_OutIt

_Dest

ios_base

_Iosbase

_Elem

_Fill

const

void

_Val

)

const

{

// put formatted void pointer to _Dest

return

(

do_put

(

_Dest

_Iosbase

_Fill

_Val

)); }

protected

virtual _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest,

virtual

_OutIt

do_put

(

_OutIt

_Dest

ios_base

_Iosbase

_Elem

_Fill

bool

_Val

)

const

{

// put formatted bool to _Dest

(!(

_Iosbase

flags

() &

ios_base

boolalpha

))

return

(

do_put

(

_Dest

_Iosbase

_Fill

, (

long

)

_Val

));

else

{

// put "false" or "true"

const auto& _Punct_fac = _STD use_facet<numpunct<_Elem>>(_Iosbase.getloc());

const

auto

_Punct_fac

= ::

std

use_facet

numpunct

_Elem

>>(

_Iosbase

getloc

());

basic_string

_Elem

_Str

;

(

_Val

)

_Str

assign

(

_Punct_fac

truename

());

else

_Str

assign

(

_Punct_fac

falsename

());

size_t

_Fillcount

_Iosbase

width

() <=

|| (

size_t

)

_Iosbase

width

() <=

_Str

size

() ?

: (

size_t

)

_Iosbase

width

() -

_Str

size

();

((

_Iosbase

flags

() &

ios_base

adjustfield

) !=

ios_base

left

) {

// put leading fill

_Dest

_Rep

(

_Dest

_Fill

_Fillcount

);

_Fillcount

; }

_Dest

_Put

(

_Dest

_Str

c_str

(),

_Str

size

());

// put field

_Iosbase

width

(

);

return

(

_Rep

(

_Dest

_Fill

_Fillcount

));

// put trailing fill

} }

virtual _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest,

virtual

_OutIt

do_put

(

_OutIt

_Dest

ios_base

_Iosbase

_Elem

_Fill

long

_Val

)

const

{

// put formatted long to _Dest

char _Buf[2 * _MAX_INT_DIG], _Fmt[6];

char

_Buf

[

_Fmt

[

];

return

(

_Iput

(

_Dest

_Iosbase

_Fill

_Buf

static_cast<size_t>(_CSTD sprintf_s(_Buf, sizeof (_Buf), _Ifmt(_Fmt, "ld",

static_cast

size_t

>(::

sprintf_s

(

_Buf

sizeof

(

_Buf

_Ifmt

(

_Fmt

"ld"

_Iosbase

flags

()),

_Val

)))); }

virtual _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest,

virtual

_OutIt

do_put

(

_OutIt

_Dest

ios_base

_Iosbase

_Elem

_Fill

unsigned

long

_Val

)

const

{

// put formatted unsigned long to _Dest

char _Buf[2 * _MAX_INT_DIG], _Fmt[6];

char

_Buf

[

_Fmt

[

];

return

(

_Iput

(

_Dest

_Iosbase

_Fill

_Buf

static_cast<size_t>(_CSTD sprintf_s(_Buf, sizeof (_Buf), _Ifmt(_Fmt, "lu",

static_cast

size_t

>(::

sprintf_s

(

_Buf

sizeof

(

_Buf

_Ifmt

(

_Fmt

"lu"

_Iosbase

flags

()),

_Val

)))); }

virtual _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest,

virtual

_OutIt

do_put

(

_OutIt

_Dest

ios_base

_Iosbase

_Elem

_Fill

long

_Val

)

const

{

// put formatted long long to _Dest

char _Buf[2 * _MAX_INT_DIG], _Fmt[8];

char

_Buf

[

_Fmt

[

];

return

(

_Iput

(

_Dest

_Iosbase

_Fill

_Buf

static_cast<size_t>(_CSTD sprintf_s(_Buf, sizeof (_Buf), _Ifmt(_Fmt, "Ld",

static_cast

size_t

>(::

sprintf_s

(

_Buf

sizeof

(

_Buf

_Ifmt

(

_Fmt

"Ld"

_Iosbase

flags

()),

_Val

)))); }

virtual _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest,

virtual

_OutIt

do_put

(

_OutIt

_Dest

ios_base

_Iosbase

_Elem

_Fill

unsigned

long

_Val

)

const

{

// put formatted unsigned long long to _Dest

char _Buf[2 * _MAX_INT_DIG], _Fmt[8];

char

_Buf

[

_Fmt

[

];

return

(

_Iput

(

_Dest

_Iosbase

_Fill

_Buf

static_cast<size_t>(_CSTD sprintf_s(_Buf, sizeof (_Buf), _Ifmt(_Fmt, "Lu",

static_cast

size_t

>(::

sprintf_s

(

_Buf

sizeof

(

_Buf

_Ifmt

(

_Fmt

"Lu"

_Iosbase

flags

()),

_Val

)))); }

virtual _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest,

virtual

_OutIt

do_put

(

_OutIt

_Dest

ios_base

_Iosbase

_Elem

_Fill

double

_Val

)

const

{

// put formatted double to _Dest

string

_Buf

;

char

_Fmt

[

];

bool

_Isfixed

= (

_Iosbase

flags

() &

ios_base

floatfield

) ==

ios_base

fixed

;

streamsize

_Precision

_Iosbase

precision

() <=

&& !

_Isfixed

_Iosbase

precision

();

// desired precision

size_t

_Bufsize

= (

size_t

)

_Precision

;

if (_Isfixed && 1e10 < _CSTD fabs(_Val))

(

_Isfixed

1e10

fabs

(

_Val

))

{

// f or F format

int

_Ptwo

;

(void)_CSTD frexp(_Val, &_Ptwo);

(

void

)::

frexp

(

_Val

, &

_Ptwo

);

_Bufsize += _CSTD abs(_Ptwo) * 30103L / 100000L;

_Bufsize

+= ::

abs

(

_Ptwo

) *

30103L

100000L

;

}

_Buf

resize

(

_Bufsize

);

// add fudge factor

const auto _Ngen = static_cast<size_t>(_CSTD sprintf_s((char *)_Buf.c_str(), _Buf.size(),

const

auto

_Ngen

static_cast

size_t

>(::

sprintf_s

((

char

_Buf

c_str

(),

_Buf

size

(),

_Ffmt

(

_Fmt

_Iosbase

flags

()), (

int

)

_Precision

_Val

));

return

(

_Fput

(

_Dest

_Iosbase

_Fill

_Buf

c_str

(),

_Ngen

)); }

virtual _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest,

virtual

_OutIt

do_put

(

_OutIt

_Dest

ios_base

_Iosbase

_Elem

_Fill

long

double

_Val

)

const

{

// put formatted long double to _Dest

string

_Buf

;

char

_Fmt

[

];

bool

_Isfixed

= (

_Iosbase

flags

() &

ios_base

floatfield

) ==

ios_base

fixed

;

streamsize

_Precision

_Iosbase

precision

() <=

&& !

_Isfixed

_Iosbase

precision

();

// desired precision

size_t

_Bufsize

= (

size_t

)

_Precision

;

if (_Isfixed && 1e10 < _CSTD fabsl(_Val))

(

_Isfixed

1e10

fabsl

(

_Val

))

{

// f or F format

int

_Ptwo

;

(void)_CSTD frexpl(_Val, &_Ptwo);

(

void

)::

frexpl

(

_Val

, &

_Ptwo

);

_Bufsize += _CSTD abs(_Ptwo) * 30103L / 100000L;

_Bufsize

+= ::

abs

(

_Ptwo

) *

30103L

100000L

;

}

_Buf

resize

(

_Bufsize

);

// add fudge factor

const auto _Ngen = static_cast<size_t>(_CSTD sprintf_s((char *)_Buf.c_str(), _Buf.size(),

const

auto

_Ngen

static_cast

size_t

>(::

sprintf_s

((

char

_Buf

c_str

(),

_Buf

size

(),

_Ffmt

(

_Fmt

'L'

_Iosbase

flags

()), (

int

)

_Precision

_Val

));

return

(

_Fput

(

_Dest

_Iosbase

_Fill

_Buf

c_str

(),

_Ngen

)); }

virtual _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest,

virtual

_OutIt

do_put

(

_OutIt

_Dest

ios_base

_Iosbase

_Elem

_Fill

const

void

_Val

)

const

{

// put formatted void pointer to _Dest

char _Buf[2 * _MAX_INT_DIG];

char

_Buf

[

];

return

(

_Iput

(

_Dest

_Iosbase

_Fill

_Buf

static_cast<size_t>(_CSTD sprintf_s(_Buf, sizeof (_Buf), "%p", _Val))));

static_cast

size_t

>(::

sprintf_s

(

_Buf

sizeof

(

_Buf

"%p"

_Val

))));

}

private

char *__CLRCALL_OR_CDECL _Ffmt(char *_Fmt,

char

__cdecl

_Ffmt

(

char

_Fmt

char

_Spec

ios_base

fmtflags

_Flags

)

const

{

// generate sprintf format for floating-point

char

_Ptr

_Fmt

; *

_Ptr

++ =

'%'

;

(

_Flags

ios_base

showpos

) *

_Ptr

++ =

'+'

;

(

_Flags

ios_base

showpoint

) *

_Ptr

++ =

'#'

; *

_Ptr

++ =

'.'

; *

_Ptr

++ =

'*'

;

// for precision argument

(

_Spec

'\0'

) *

_Ptr

++ =

_Spec

;

// 'L' qualifier for long double only

ios_base

fmtflags

_Ffl

_Flags

ios_base

floatfield

;

(

_Flags

ios_base

uppercase

) *

_Ptr

++ =

_Ffl

ios_base

fixed

'f'

_Ffl

ios_base

hexfloat

'A'

// added with TR1

_Ffl

ios_base

scientific

'E'

'G'

;

// specifier

else

_Ptr

++ =

_Ffl

ios_base

fixed

'f'

_Ffl

ios_base

hexfloat

'a'

// added with TR1

_Ffl

ios_base

scientific

'e'

'g'

;

// specifier

_Ptr

'\0'

;

return

(

_Fmt

); }

_OutIt __CLRCALL_OR_CDECL _Fput(_OutIt _Dest,

_OutIt

__cdecl

_Fput

(

_OutIt

_Dest

ios_base

_Iosbase

_Elem

_Fill

const

char

_Buf

size_t

_Count

)

const

{

// put formatted floating-point to _Dest

auto

_Prefix

static_cast

size_t

_Count

&& (*

_Buf

'+'

|| *

_Buf

'-'

));

const

char

_Exps

;

((

_Iosbase

flags

() &

ios_base

floatfield

) !=

ios_base

hexfloat

)

_Exps

"eE"

;

else

{

// correct for hexadecimal floating-point

_Exps

"pP"

;

(

_Prefix

_Count

_Buf

[

_Prefix

]

'0'

&& (

_Buf

[

_Prefix

]

'x'

_Buf

[

_Prefix

]

'X'

))

_Prefix

; }

const

size_t

_Eoff

_CSTD strcspn(&_Buf[0], _Exps); // find exponent

strcspn

_Buf

[

_Exps

);

// find exponent

char

_Dp

[

] = {

"."

};

_Dp[0] = _CSTD localeconv()->decimal_point[0];

_Dp

[

] = ::

localeconv

()->

decimal_point

[

];

const

size_t

_Poff

_CSTD strcspn(&_Buf[0], &_Dp[0]); // find decimal point

strcspn

_Buf

[

], &

_Dp

[

]);

// find decimal point

const ctype<_Elem>& _Ctype_fac = _STD use_facet<ctype<_Elem>>(_Iosbase.getloc());

const

ctype

_Elem

_Ctype_fac

= ::

std

use_facet

ctype

_Elem

>>(

_Iosbase

getloc

());

basic_string

_Elem

_Groupstring

(

_Count

_Elem

(

));

// reserve space

_Ctype_fac

widen

_Buf

[

], &

_Buf

[

_Count

], &

_Groupstring

[

]);

const auto& _Punct_fac = _STD use_facet<numpunct<_Elem>>(_Iosbase.getloc());

const

auto

_Punct_fac

= ::

std

use_facet

numpunct

_Elem

>>(

_Iosbase

getloc

());

const

string

_Grouping

_Punct_fac

grouping

();

const

_Elem

_Kseparator

_Punct_fac

thousands_sep

();

(

_Poff

_Count

)

_Groupstring

[

_Poff

] =

_Punct_fac

decimal_point

();

size_t

_Off

_Poff

_Count

_Eoff

_Poff

;

const

char

_Pg

= &

_Grouping

[

];

while (*_Pg != CHAR_MAX && '\0' < *_Pg

while

_Pg

127

'\0'

_Pg

&& (

size_t

_Pg

_Off

_Prefix

) {

// add thousands separator

_Groupstring

insert

(

_Off

-= *

_Pg

, (

size_t

)

_Kseparator

);

(

'\0'

_Pg

[

]) ++

_Pg

;

// not last group, advance

}

_Count

_Groupstring

size

();

size_t

_Fillcount

_Iosbase

width

() <=

|| (

size_t

)

_Iosbase

width

() <=

_Count

: (

size_t

)

_Iosbase

width

() -

_Count

;

ios_base

fmtflags

_Adjustfield

_Iosbase

flags

() &

ios_base

adjustfield

;

(

_Adjustfield

ios_base

left

_Adjustfield

ios_base

internal

) {

// put leading fill

_Dest

_Rep

(

_Dest

_Fill

_Fillcount

);

_Fillcount

;

_Dest

_Put

(

_Dest

, &

_Groupstring

[

_Prefix

); }

else

(

_Adjustfield

ios_base

internal

) {

// put internal fill

_Dest

_Put

(

_Dest

, &

_Groupstring

[

_Prefix

);

_Dest

_Rep

(

_Dest

_Fill

_Fillcount

);

_Fillcount

; }

else

_Dest

_Put

(

_Dest

, &

_Groupstring

[

_Prefix

);

_Dest

_Put

(

_Dest

, &

_Groupstring

[

_Prefix

_Count

_Prefix

);

_Iosbase

width

(

);

return

(

_Rep

(

_Dest

_Fill

_Fillcount

));

// put trailing fill

}

char *__CLRCALL_OR_CDECL _Ifmt(char *_Fmt,

char

__cdecl

_Ifmt

(

char

_Fmt

const

char

_Spec

ios_base

fmtflags

_Flags

)

const

{

// generate sprintf format for integer

char

_Ptr

_Fmt

; *

_Ptr

++ =

'%'

;

(

_Flags

ios_base

showpos

) *

_Ptr

++ =

'+'

;

(

_Flags

ios_base

showbase

) *

_Ptr

++ =

'#'

;

(

_Spec

[

]

'L'

) *

_Ptr

++ =

_Spec

[

];

// qualifier

else

{

/* change L to I64 */

_Ptr

++ =

'I'

; *

_Ptr

++ =

'6'

; *

_Ptr

++ =

'4'

; }

ios_base

fmtflags

_Basefield

_Flags

ios_base

basefield

; *

_Ptr

++ =

_Basefield

ios_base

oct

'o'

_Basefield

ios_base

hex

_Spec

[

]

// 'd' or 'u'

_Flags

ios_base

uppercase

'X'

'x'

; *

_Ptr

'\0'

;

return

(

_Fmt

); }

_OutIt __CLRCALL_OR_CDECL _Iput(_OutIt _Dest,

_OutIt

__cdecl

_Iput

(

_OutIt

_Dest

ios_base

_Iosbase

_Elem

_Fill

char

_Buf

size_t

_Count

)

const

{

// put formatted integer to _Dest

auto

_Prefix

static_cast

size_t

_Count

&& (*

_Buf

'+'

|| *

_Buf

'-'

));

((

_Iosbase

flags

() &

ios_base

basefield

) ==

ios_base

hex

_Prefix

_Count

_Buf

[

_Prefix

] ==

'0'

&& (

_Buf

[

_Prefix

]

'x'

_Buf

[

_Prefix

]

'X'

)) {

_Prefix

; }

const ctype<_Elem>& _Ctype_fac = _STD use_facet<ctype<_Elem>>(_Iosbase.getloc());

const

ctype

_Elem

_Ctype_fac

= ::

std

use_facet

ctype

_Elem

>>(

_Iosbase

getloc

());

basic_string

_Elem

_Groupstring

(

_Count

_Elem

(

));

// reserve space

_Ctype_fac

widen

_Buf

[

], &

_Buf

[

_Count

], &

_Groupstring

[

]);

const auto& _Punct_fac = _STD use_facet<numpunct<_Elem>>(_Iosbase.getloc());

const

auto

_Punct_fac

= ::

std

use_facet

numpunct

_Elem

>>(

_Iosbase

getloc

());

const

string

_Grouping

_Punct_fac

grouping

();

const

char

_Pg

= &

_Grouping

[

];

if (*_Pg != CHAR_MAX && '\0' < *_Pg)

_Pg

127

'\0'

_Pg

)

{

// grouping specified, add thousands separators

const

_Elem

_Kseparator

_Punct_fac

thousands_sep

();

while (*_Pg != CHAR_MAX && '\0' < *_Pg

while

_Pg

127

'\0'

_Pg

&& (

size_t

_Pg

_Count

_Prefix

) {

// insert thousands separator

_Count

-= *

_Pg

;

_Groupstring

insert

(

_Count

_Kseparator

);

(

'\0'

_Pg

[

]) ++

_Pg

;

// not last group, advance

} }

_Count

_Groupstring

size

();

size_t

_Fillcount

_Iosbase

width

() <=

|| (

size_t

)

_Iosbase

width

() <=

_Count

: (

size_t

)

_Iosbase

width

() -

_Count

;

ios_base

fmtflags

_Adjustfield

_Iosbase

flags

() &

ios_base

adjustfield

;

(

_Adjustfield

ios_base

left

_Adjustfield

ios_base

internal

) {

// put leading fill

_Dest

_Rep

(

_Dest

_Fill

_Fillcount

);

_Fillcount

;

_Dest

_Put

(

_Dest

, &

_Groupstring

[

_Prefix

); }

else

(

_Adjustfield

ios_base

internal

) {

// put internal fill

_Dest

_Put

(

_Dest

, &

_Groupstring

[

_Prefix

);

_Dest

_Rep

(

_Dest

_Fill

_Fillcount

);

_Fillcount

; }

else

_Dest

_Put

(

_Dest

, &

_Groupstring

[

_Prefix

);

_Dest

_Put

(

_Dest

, &

_Groupstring

[

_Prefix

_Count

_Prefix

);

_Iosbase

width

(

);

return

(

_Rep

(

_Dest

_Fill

_Fillcount

));

// put trailing fill

}

_OutIt __CLRCALL_OR_CDECL _Put(_OutIt _Dest,

_OutIt

__cdecl

_Put

(

_OutIt

_Dest

const

_Elem

_Ptr

size_t

_Count

)

const

{

// put [_Ptr, _Ptr + _Count) to _Dest

for

(;

_Count

; --

_Count

, (

void

)++

_Dest

, ++

_Ptr

) *

_Dest

= *

_Ptr

;

return

(

_Dest

); }

_OutIt __CLRCALL_OR_CDECL _Rep(_OutIt _Dest,

_OutIt

__cdecl

_Rep

(

_OutIt

_Dest

_Elem

_Ch

size_t

_Count

)

const

{

// put _Count * _Ch to _Dest

for

(;

_Count

; --

_Count

, (

void

)++

_Dest

) *

_Dest

_Ch

;

return

(

_Dest

); } };

// STATIC num_put::id OBJECT

#ifdef __clang__

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wdllimport-static-field-def"

#endif /* __clang__ */

template

class

_Elem

class

_OutIt

__PURE_APPDOMAIN_GLOBAL locale::id num_put<_Elem, _OutIt>::id;

locale

num_put

_Elem

_OutIt

>::

;

#if defined(_DLL_CPPLIB)

#if !defined(_CRTBLD) || defined(__FORCE_INSTANCE)

template __PURE_APPDOMAIN_GLOBAL locale::id numpunct<char>::id;

template

locale

numpunct

char

>::id;

template class _CRTIMP2_PURE_IMPORT num_get<char,

template

class

__declspec

(dllimport)

num_get

char

istreambuf_iterator

char

char_traits

char

> > >;

template class _CRTIMP2_PURE_IMPORT num_put<char,

template

class

__declspec

(dllimport)

num_put

char

ostreambuf_iterator

char

char_traits

char

> > >;

template __PURE_APPDOMAIN_GLOBAL locale::id numpunct<wchar_t>::id;

template

locale

numpunct

wchar_t

>::id;

template class _CRTIMP2_PURE_IMPORT num_get<wchar_t,

template

class

__declspec

(dllimport)

num_get

wchar_t

istreambuf_iterator

wchar_t

char_traits

wchar_t

> > >;

template class _CRTIMP2_PURE_IMPORT num_put<wchar_t,

template

class

__declspec

(dllimport)

num_put

wchar_t

ostreambuf_iterator

wchar_t

char_traits

wchar_t

> > >;

#endif /* !defined(_CRTBLD) || defined(__FORCE_INSTANCE) */

#ifdef __FORCE_INSTANCE

template __PURE_APPDOMAIN_GLOBAL locale::id numpunct<unsigned short>::id;

template class _CRTIMP2_PURE_IMPORT num_get<unsigned short,

istreambuf_iterator<unsigned short, char_traits<unsigned short> > >;

template class _CRTIMP2_PURE_IMPORT num_put<unsigned short,

ostreambuf_iterator<unsigned short, char_traits<unsigned short> > >;

#endif /* __FORCE_INSTANCE */ #endif /* defined(_DLL_CPPLIB) */

#ifdef __clang__

#pragma clang diagnostic pop

#endif /* __clang__ */

_STD_END

}

#pragma pop_macro("new")

_STL_RESTORE_CLANG_WARNINGS

#pragma warning(pop)

#pragma pack(pop) #endif /* RC_INVOKED */ #endif /* _XLOCNUM_ */

#pragma pack(pop)