1 : // xlocnum internal header (from <locale>)
2 : #pragma once
3 : #ifndef _XLOCNUM_
4 : #define _XLOCNUM_
5 : #ifndef RC_INVOKED
6 : #include <climits>
7 : #include <cstdio>
8 : #include <cstdlib>
9 : #include <streambuf>
10 :
11 : #ifdef _MSC_VER
12 : #pragma pack(push,_CRT_PACKING)
13 : #pragma warning(push,3)
14 : #endif /* _MSC_VER */
15 :
16 : // TEXT-TO-NUMERIC CONVERSION FUNCTIONS
17 : _C_STD_BEGIN
18 : #if defined(__cplusplus) && !defined(MRTDLL) && !defined(_M_CEE_PURE)
19 : _C_LIB_DECL
20 : #endif
21 : extern _CRTIMP2_PURE float __CLRCALL_PURE_OR_CDECL _Stofx(const char *,_Out_opt_ _Deref_post_opt_valid_ char **,
22 : long, int *);
23 : extern _CRTIMP2_PURE double __CLRCALL_PURE_OR_CDECL _Stodx(const char *,_Out_opt_ _Deref_post_opt_valid_ char **,
24 : long, int *);
25 : extern _CRTIMP2_PURE long double __CLRCALL_PURE_OR_CDECL _Stoldx(const char *,_Out_opt_ _Deref_post_opt_valid_ char **,
26 : long, int *);
27 : extern _CRTIMP2_PURE long __CLRCALL_PURE_OR_CDECL _Stolx(const char *,_Out_opt_ _Deref_post_opt_valid_ char **, int,
28 : int *);
29 : extern _CRTIMP2_PURE unsigned long __CLRCALL_PURE_OR_CDECL _Stoulx(const char *,_Out_opt_ _Deref_post_opt_valid_ char **,
30 : int, int *);
31 :
32 : #ifdef _LONGLONG
33 :
34 : extern _CRTIMP2_PURE _LONGLONG __CLRCALL_PURE_OR_CDECL _Stollx(const char *,_Out_opt_ _Deref_post_opt_valid_ char **,
35 : int, int *);
36 : extern _CRTIMP2_PURE _ULONGLONG __CLRCALL_PURE_OR_CDECL _Stoullx(const char *,_Out_opt_ _Deref_post_opt_valid_ char **,
37 : int, int *);
38 : #endif /* _LONGLONG */
39 :
40 : #if defined(__cplusplus) && !defined(MRTDLL) && !defined(_M_CEE_PURE)
41 : _END_C_LIB_DECL
42 : #endif
43 : _C_STD_END
44 :
45 : #ifdef _LONGLONG
46 : #define _STOLL(buf, ptr, base, perr) _Stollx(buf, ptr, base, perr)
47 : #define _STOULL(buf, ptr, base, perr) _Stoullx(buf, ptr, base, perr)
48 : #endif /* _LONGLONG */
49 :
50 : _STD_BEGIN
51 :
52 : #define _VIRTUAL virtual
53 :
54 : #pragma warning(push)
55 : #pragma warning(disable:4275)
56 : // TEMPLATE CLASS numpunct
57 : template<class _Elem>
58 : class numpunct
59 : : public locale::facet
60 : { // facet for defining numeric punctuation text
61 : public:
62 : typedef basic_string<_Elem, char_traits<_Elem>, allocator<_Elem> >
63 : string_type;
64 : typedef _Elem char_type;
65 :
66 : __PURE_APPDOMAIN_GLOBAL static locale::id id; // unique facet id
67 :
68 : _Elem __CLR_OR_THIS_CALL decimal_point() const
69 0 : { // return decimal point
70 0 : return (do_decimal_point());
71 0 : }
72 :
73 : _Elem __CLR_OR_THIS_CALL thousands_sep() const
74 9 : { // return thousands separator
75 9 : return (do_thousands_sep());
76 9 : }
77 :
78 : string __CLR_OR_THIS_CALL grouping() const
79 9 : { // return grouping string
80 9 : return (do_grouping());
81 9 : }
82 :
83 : string_type __CLR_OR_THIS_CALL falsename() const
84 0 : { // return name for false
85 0 : return (do_falsename());
86 0 : }
87 :
88 : string_type __CLR_OR_THIS_CALL truename() const
89 0 : { // return name for true
90 0 : return (do_truename());
91 0 : }
92 :
93 : explicit __CLR_OR_THIS_CALL numpunct(size_t _Refs = 0)
94 : : locale::facet(_Refs)
95 : { // construct from current locale
96 : _BEGIN_LOCINFO(_Lobj)
97 : _Init(_Lobj);
98 : if (_Kseparator == 0)
99 : _Kseparator = // NB: differs from "C" locale
100 : _MAKLOCCHR(_Elem, ',', _Lobj._Getcvt());
101 : _END_LOCINFO()
102 : }
103 :
104 : __CLR_OR_THIS_CALL numpunct(const _Locinfo& _Lobj, size_t _Refs = 0, bool _Isdef = false)
105 : : locale::facet(_Refs)
106 9 : { // construct from specified locale
107 9 : _Init(_Lobj, _Isdef);
108 9 : }
109 :
110 : static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet **_Ppf = 0,
111 : const locale *_Ploc = 0)
112 9 : { // return locale category mask and construct standard facet
113 9 : if (_Ppf != 0 && *_Ppf == 0)
114 : *_Ppf = _NEW_CRT numpunct<_Elem>(
115 9 : _Locinfo(_Ploc->name()), 0, true);
116 9 : return (_X_NUMERIC);
117 9 : }
118 :
119 : _PROTECTED:
120 : _VIRTUAL __CLR_OR_THIS_CALL ~numpunct()
121 9 : { // destroy the object
122 9 : _Tidy();
123 9 : }
124 :
125 : protected:
126 : __CLR_OR_THIS_CALL numpunct(const char *_Locname, size_t _Refs = 0, bool _Isdef = false)
127 : : locale::facet(_Refs)
128 : { // construct from specified locale
129 : _BEGIN_LOCINFO(_Lobj(_Locname))
130 : _Init(_Lobj, _Isdef);
131 : _END_LOCINFO()
132 : }
133 :
134 : void __CLR_OR_THIS_CALL _Init(const _Locinfo& _Lobj, bool _Isdef = false)
135 9 : { // initialize from _Lobj
136 9 : const lconv *_Ptr = _Lobj._Getlconv();
137 :
138 9 : _Grouping = 0;
139 9 : _Falsename = 0;
140 9 : _Truename = 0;
141 :
142 9 : _TRY_BEGIN
143 9 : _Grouping = _MAKLOCSTR(char, _Ptr->grouping, _Lobj._Getcvt());
144 9 : _Falsename = _MAKLOCSTR(_Elem, _Lobj._Getfalse(), _Lobj._Getcvt());
145 9 : _Truename = _MAKLOCSTR(_Elem, _Lobj._Gettrue(), _Lobj._Getcvt());
146 : _CATCH_ALL
147 0 : _Tidy();
148 0 : _RERAISE;
149 0 : _CATCH_END
150 :
151 9 : _Dp = _MAKLOCCHR(_Elem, _Ptr->decimal_point[0], _Lobj._Getcvt());
152 : _Kseparator =
153 9 : _MAKLOCCHR(_Elem, _Ptr->thousands_sep[0], _Lobj._Getcvt());
154 :
155 9 : if (_Isdef)
156 : { // apply defaults for required facets
157 9 : _Grouping = _MAKLOCSTR(char, "", _Lobj._Getcvt());
158 9 : _Dp = _MAKLOCCHR(_Elem, '.', _Lobj._Getcvt());
159 9 : _Kseparator = _MAKLOCCHR(_Elem, ',', _Lobj._Getcvt());
160 : }
161 9 : }
162 :
163 : _VIRTUAL _Elem __CLR_OR_THIS_CALL do_decimal_point() const
164 0 : { // return decimal point
165 0 : return (_Dp);
166 0 : }
167 :
168 : _VIRTUAL _Elem __CLR_OR_THIS_CALL do_thousands_sep() const
169 9 : { // return thousands separator
170 9 : return (_Kseparator);
171 9 : }
172 :
173 : _VIRTUAL string __CLR_OR_THIS_CALL do_grouping() const
174 9 : { // return grouping string
175 9 : return (string(_Grouping));
176 9 : }
177 :
178 : _VIRTUAL string_type __CLR_OR_THIS_CALL do_falsename() const
179 0 : { // return name for false
180 0 : return (string_type(_Falsename));
181 0 : }
182 :
183 : _VIRTUAL string_type __CLR_OR_THIS_CALL do_truename() const
184 0 : { // return name for true
185 0 : return (string_type(_Truename));
186 0 : }
187 :
188 : private:
189 : void __CLR_OR_THIS_CALL _Tidy()
190 9 : { // free all storage
191 9 : _DELETE_CRT_VEC((void *)_Grouping);
192 9 : _DELETE_CRT_VEC((void *)_Falsename);
193 9 : _DELETE_CRT_VEC((void *)_Truename);
194 9 : }
195 :
196 : const char *_Grouping; // grouping string, "" for "C" locale
197 : _Elem _Dp; // decimal point, '.' for "C" locale
198 : _Elem _Kseparator; // thousands separator, '\0' for "C" locale
199 : const _Elem *_Falsename; // name for false, "false" for "C" locale
200 : const _Elem *_Truename; // name for true, "true" for "C" locale
201 : };
202 :
203 : // TEMPLATE CLASS numpunct_byname
204 : template<class _Elem>
205 : class numpunct_byname
206 : : public numpunct<_Elem>
207 : { // numpunct for named locale
208 : public:
209 : explicit __CLR_OR_THIS_CALL numpunct_byname(const char *_Locname, size_t _Refs = 0)
210 : : numpunct<_Elem>(_Locname, _Refs)
211 : { // construct for named locale
212 : }
213 :
214 : _PROTECTED:
215 : _VIRTUAL __CLR_OR_THIS_CALL ~numpunct_byname()
216 : { // destroy the object
217 : }
218 : };
219 :
220 : // STATIC numpunct::id OBJECT
221 : template<class _Elem>
222 : __PURE_APPDOMAIN_GLOBAL locale::id numpunct<_Elem>::id;
223 :
224 : // TEMPLATE CLASS num_get
225 : template<class _Elem,
226 : class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem> > >
227 : class num_get
228 : : public locale::facet
229 : { // facet for converting text to encoded numbers
230 : public:
231 : typedef numpunct<_Elem> _Mypunct;
232 : typedef basic_string<_Elem, char_traits<_Elem>, allocator<_Elem> >
233 : _Mystr;
234 :
235 : static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet **_Ppf = 0,
236 : const locale *_Ploc = 0)
237 : { // return locale category mask and construct standard facet
238 : if (_Ppf != 0 && *_Ppf == 0)
239 : *_Ppf = _NEW_CRT num_get<_Elem, _InIt>(
240 : _Locinfo(_Ploc->name()));
241 : return (_X_NUMERIC);
242 : }
243 :
244 : __PURE_APPDOMAIN_GLOBAL static locale::id id; // unique facet id
245 :
246 : _PROTECTED:
247 : _VIRTUAL __CLR_OR_THIS_CALL ~num_get()
248 : { // destroy the object
249 : }
250 :
251 : protected:
252 : void _Init(const _Locinfo& _Lobj)
253 : { // initialize from _Locinfo object
254 : _Cvt = _Lobj._Getcvt();
255 : }
256 :
257 : _Locinfo::_Cvtvec _Cvt; // conversion information
258 :
259 : public:
260 : explicit __CLR_OR_THIS_CALL num_get(size_t _Refs = 0)
261 : : locale::facet(_Refs)
262 : { // construct from current locale
263 : _BEGIN_LOCINFO(_Lobj)
264 : _Init(_Lobj);
265 : _END_LOCINFO()
266 : }
267 :
268 : __CLR_OR_THIS_CALL num_get(const _Locinfo& _Lobj, size_t _Refs = 0)
269 : : locale::facet(_Refs)
270 : { // construct from specified locale
271 : _Init(_Lobj);
272 : }
273 :
274 : typedef _Elem char_type;
275 : typedef _InIt iter_type;
276 :
277 : _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last,
278 : ios_base& _Iosbase, ios_base::iostate& _State,
279 : _Bool& _Val) const
280 : { // get bool from [_First, _Last) into _Val
281 : return (do_get(_First, _Last, _Iosbase, _State, _Val));
282 : }
283 :
284 : _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last,
285 : ios_base& _Iosbase, ios_base::iostate& _State,
286 : unsigned short& _Val) const
287 : { // get unsigned short from [_First, _Last) into _Val
288 : return (do_get(_First, _Last, _Iosbase, _State, _Val));
289 : }
290 :
291 : _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last,
292 : ios_base& _Iosbase, ios_base::iostate& _State,
293 : unsigned int& _Val) const
294 : { // get unsigned int from [_First, _Last) into _Val
295 : return (do_get(_First, _Last, _Iosbase, _State, _Val));
296 : }
297 :
298 : _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last,
299 : ios_base& _Iosbase, ios_base::iostate& _State,
300 : long& _Val) const
301 : { // get long from [_First, _Last) into _Val
302 : return (do_get(_First, _Last, _Iosbase, _State, _Val));
303 : }
304 :
305 : _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last,
306 : ios_base& _Iosbase, ios_base::iostate& _State,
307 : unsigned long& _Val) const
308 : { // get unsigned long from [_First, _Last) into _Val
309 : return (do_get(_First, _Last, _Iosbase, _State, _Val));
310 : }
311 :
312 : #ifdef _LONGLONG
313 : _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last,
314 : ios_base& _Iosbase, ios_base::iostate& _State,
315 : _LONGLONG& _Val) const
316 : { // get long long from [_First, _Last) into _Val
317 : return (do_get(_First, _Last, _Iosbase, _State, _Val));
318 : }
319 :
320 : _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last,
321 : ios_base& _Iosbase, ios_base::iostate& _State,
322 : _ULONGLONG& _Val) const
323 : { // get unsigned long long from [_First, _Last) into _Val
324 : return (do_get(_First, _Last, _Iosbase, _State, _Val));
325 : }
326 : #endif /* _LONGLONG */
327 :
328 : _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last,
329 : ios_base& _Iosbase, ios_base::iostate& _State,
330 : float& _Val) const
331 : { // get float from [_First, _Last) into _Val
332 : return (do_get(_First, _Last, _Iosbase, _State, _Val));
333 : }
334 :
335 : _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last,
336 : ios_base& _Iosbase, ios_base::iostate& _State,
337 : double& _Val) const
338 : { // get double from [_First, _Last) into _Val
339 : return (do_get(_First, _Last, _Iosbase, _State, _Val));
340 : }
341 :
342 : _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last,
343 : ios_base& _Iosbase, ios_base::iostate& _State,
344 : long double& _Val) const
345 : { // get long double from [_First, _Last) into _Val
346 : return (do_get(_First, _Last, _Iosbase, _State, _Val));
347 : }
348 :
349 : _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last,
350 : ios_base& _Iosbase, ios_base::iostate& _State,
351 : void *& _Val) const
352 : { // get void pointer from [_First, _Last) into _Val
353 : return (do_get(_First, _Last, _Iosbase, _State, _Val));
354 : }
355 :
356 : protected:
357 : _VIRTUAL _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last,
358 : ios_base& _Iosbase, ios_base::iostate& _State,
359 : _Bool& _Val) const
360 : { // get bool from [_First, _Last) into _Val
361 : _DEBUG_RANGE(_First, _Last);
362 : int _Ans = -1; // negative answer indicates failure
363 :
364 : if (_Iosbase.flags() & ios_base::boolalpha)
365 : { // get false name or true name
366 : typedef typename _Mystr::size_type _Mystrsize;
367 : const _Mypunct& _Punct_fac = _USE(_Iosbase.getloc(), _Mypunct);
368 : _Mystr _Str((_Mystrsize)1, (char_type)0);
369 : _Str += _Punct_fac.falsename();
370 : _Str += (char_type)0;
371 : _Str += _Punct_fac.truename(); // construct "\0false\0true"
372 : _Ans = _Getloctxt(_First, _Last, (size_t)2, _Str.c_str());
373 : }
374 : else
375 : { // get zero or nonzero integer
376 : char _Ac[_MAX_INT_DIG], *_Ep;
377 : int _Errno = 0;
378 : const unsigned long _Ulo = ::_Stoulx(_Ac, &_Ep,
379 : _Getifld(_Ac, _First, _Last, _Iosbase.flags(),
380 : _Iosbase.getloc()), &_Errno);
381 : if (_Ep != _Ac && _Errno == 0 && _Ulo <= 1)
382 : _Ans = _Ulo;
383 : }
384 :
385 : if (_First == _Last)
386 : _State |= ios_base::eofbit;
387 : if (_Ans < 0)
388 : _State |= ios_base::failbit;
389 : else
390 : _Val = _Ans != 0; // deliver value
391 : return (_First);
392 : }
393 :
394 : _VIRTUAL _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last,
395 : ios_base& _Iosbase, ios_base::iostate& _State,
396 : unsigned short& _Val) const
397 : { // get unsigned short from [_First, _Last) into _Val
398 : _DEBUG_RANGE(_First, _Last);
399 : char _Ac[_MAX_INT_DIG], *_Ep;
400 : int _Errno = 0;
401 : int _Base = _Getifld(_Ac, _First, _Last, _Iosbase.flags(),
402 : _Iosbase.getloc()); // gather field into _Ac
403 : char *_Ptr = _Ac[0] == '-' ? _Ac + 1 : _Ac; // point past any sign
404 : const unsigned long _Ans =
405 : ::_Stoulx(_Ptr, &_Ep, _Base, &_Errno); // convert
406 :
407 : if (_First == _Last)
408 : _State |= ios_base::eofbit;
409 : if (_Ep == _Ptr || _Errno != 0 || USHRT_MAX < _Ans)
410 : _State |= ios_base::failbit;
411 : else
412 : _Val = (unsigned short)(_Ac[0] == '-'
413 : ? 0 -_Ans : _Ans); // deliver value
414 : return (_First);
415 : }
416 :
417 : _VIRTUAL _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last,
418 : ios_base& _Iosbase, ios_base::iostate& _State,
419 : unsigned int& _Val) const
420 : { // get unsigned int from [_First, _Last) into _Val
421 : _DEBUG_RANGE(_First, _Last);
422 : char _Ac[_MAX_INT_DIG], *_Ep;
423 : int _Errno = 0;
424 : int _Base = _Getifld(_Ac, _First, _Last, _Iosbase.flags(),
425 : _Iosbase.getloc()); // gather field into _Ac
426 : char *_Ptr = _Ac[0] == '-' ? _Ac + 1 : _Ac; // point past any sign
427 : const unsigned long _Ans =
428 : ::_Stoulx(_Ptr, &_Ep, _Base, &_Errno); // convert
429 :
430 : if (_First == _Last)
431 : _State |= ios_base::eofbit;
432 : if (_Ep == _Ptr || _Errno != 0 || UINT_MAX < _Ans)
433 : _State |= ios_base::failbit;
434 : else
435 : _Val = _Ac[0] == '-' ? 0 -_Ans : _Ans; // deliver value
436 : return (_First);
437 : }
438 :
439 : _VIRTUAL _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last,
440 : ios_base& _Iosbase, ios_base::iostate& _State,
441 : long& _Val) const
442 : { // get long from [_First, _Last) into _Val
443 : _DEBUG_RANGE(_First, _Last);
444 : char _Ac[_MAX_INT_DIG], *_Ep;
445 : int _Errno = 0;
446 : const long _Ans = ::_Stolx(_Ac, &_Ep,
447 : _Getifld(_Ac, _First, _Last, _Iosbase.flags(),
448 : _Iosbase.getloc()), &_Errno); // gather field, convert
449 :
450 : if (_First == _Last)
451 : _State |= ios_base::eofbit;
452 : if (_Ep == _Ac || _Errno != 0)
453 : _State |= ios_base::failbit;
454 : else
455 : _Val = _Ans; // deliver value
456 : return (_First);
457 : }
458 :
459 : _VIRTUAL _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last,
460 : ios_base& _Iosbase, ios_base::iostate& _State,
461 : unsigned long& _Val) const
462 : { // get unsigned long from [_First, _Last) into _Val
463 : _DEBUG_RANGE(_First, _Last);
464 : char _Ac[_MAX_INT_DIG], *_Ep;
465 : int _Errno = 0;
466 : const unsigned long _Ans = ::_Stoulx(_Ac, &_Ep,
467 : _Getifld(_Ac, _First, _Last, _Iosbase.flags(),
468 : _Iosbase.getloc()), &_Errno); // gather field, convert
469 :
470 : if (_First == _Last)
471 : _State |= ios_base::eofbit;
472 : if (_Ep == _Ac || _Errno != 0)
473 : _State |= ios_base::failbit;
474 : else
475 : _Val = _Ans; // deliver value
476 : return (_First);
477 : }
478 :
479 : #ifdef _LONGLONG
480 : _VIRTUAL _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last,
481 : ios_base& _Iosbase, ios_base::iostate& _State,
482 : _LONGLONG& _Val) const
483 : { // get long long from [_First, _Last) into _Val
484 : _DEBUG_RANGE(_First, _Last);
485 : char _Ac[_MAX_INT_DIG], *_Ep;
486 : int _Errno = 0;
487 : const _LONGLONG _Ans = ::_STOLL(_Ac, &_Ep,
488 : _Getifld(_Ac, _First, _Last, _Iosbase.flags(),
489 : _Iosbase.getloc()), &_Errno); // gather field, convert
490 :
491 : if (_First == _Last)
492 : _State |= ios_base::eofbit;
493 : if (_Ep == _Ac || _Errno != 0)
494 : _State |= ios_base::failbit;
495 : else
496 : _Val = _Ans; // deliver value
497 : return (_First);
498 : }
499 :
500 : _VIRTUAL _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last,
501 : ios_base& _Iosbase, ios_base::iostate& _State,
502 : _ULONGLONG& _Val) const
503 : { // get unsigned long long from [_First, _Last) into _Val
504 : _DEBUG_RANGE(_First, _Last);
505 : char _Ac[_MAX_INT_DIG], *_Ep;
506 : int _Errno = 0;
507 : const _ULONGLONG _Ans = ::_STOULL(_Ac, &_Ep,
508 : _Getifld(_Ac, _First, _Last, _Iosbase.flags(),
509 : _Iosbase.getloc()), &_Errno); // gather field, convert
510 :
511 : if (_First == _Last)
512 : _State |= ios_base::eofbit;
513 : if (_Ep == _Ac || _Errno != 0)
514 : _State |= ios_base::failbit;
515 : else
516 : _Val = _Ans; // deliver value
517 : return (_First);
518 : }
519 : #endif /* _LONGLONG */
520 :
521 : _VIRTUAL _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last,
522 : ios_base& _Iosbase, ios_base::iostate& _State,
523 : float& _Val) const
524 : { // get float from [_First, _Last) into _Val
525 : _DEBUG_RANGE(_First, _Last);
526 : char _Ac[_MAX_EXP_DIG + _MAX_SIG_DIG + 16], *_Ep;
527 : int _Errno = 0;
528 : const float _Ans = ::_Stofx(_Ac, &_Ep,
529 : _Getffld(_Ac, _First, _Last,
530 : _Iosbase.getloc()), &_Errno); // gather field, convert
531 :
532 : if (_First == _Last)
533 : _State |= ios_base::eofbit;
534 : if (_Ep == _Ac || _Errno != 0)
535 : _State |= ios_base::failbit;
536 : else
537 : _Val = _Ans; // deliver value
538 : return (_First);
539 : }
540 :
541 : _VIRTUAL _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last,
542 : ios_base& _Iosbase, ios_base::iostate& _State,
543 : double& _Val) const
544 : { // get double from [_First, _Last) into _Val
545 : _DEBUG_RANGE(_First, _Last);
546 : char _Ac[_MAX_EXP_DIG + _MAX_SIG_DIG + 16], *_Ep;
547 : int _Errno = 0;
548 : const double _Ans = ::_Stodx(_Ac, &_Ep,
549 : _Getffld(_Ac, _First, _Last,
550 : _Iosbase.getloc()), &_Errno); // gather field, convert
551 :
552 : if (_First == _Last)
553 : _State |= ios_base::eofbit;
554 : if (_Ep == _Ac || _Errno != 0)
555 : _State |= ios_base::failbit;
556 : else
557 : _Val = _Ans; // deliver value
558 : return (_First);
559 : }
560 :
561 : _VIRTUAL _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last,
562 : ios_base& _Iosbase, ios_base::iostate& _State,
563 : long double& _Val) const
564 : { // get long double from [_First, _Last) into _Val
565 : _DEBUG_RANGE(_First, _Last);
566 : char _Ac[_MAX_EXP_DIG + _MAX_SIG_DIG + 16], *_Ep;
567 : int _Errno = 0;
568 : const long double _Ans = ::_Stoldx(_Ac, &_Ep,
569 : _Getffld(_Ac, _First, _Last,
570 : _Iosbase.getloc()), &_Errno); // gather field, convert
571 :
572 : if (_First == _Last)
573 : _State |= ios_base::eofbit;
574 : if (_Ep == _Ac || _Errno != 0)
575 : _State |= ios_base::failbit;
576 : else
577 : _Val = _Ans; // deliver value
578 : return (_First);
579 : }
580 :
581 : _VIRTUAL _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last,
582 : ios_base& _Iosbase, ios_base::iostate& _State,
583 : void *& _Val) const
584 : { // get void pointer from [_First, _Last) into _Val
585 : _DEBUG_RANGE(_First, _Last);
586 : char _Ac[_MAX_INT_DIG], *_Ep;
587 : int _Errno = 0;
588 :
589 : #ifdef _LONGLONG
590 : int _Base = _Getifld(_Ac, _First, _Last, ios_base::hex,
591 : _Iosbase.getloc()); // gather field
592 : const _ULONGLONG _Ans =
593 : (sizeof (void *) == sizeof (unsigned long))
594 : ? (_ULONGLONG)::_Stoulx(_Ac, &_Ep, _Base, &_Errno)
595 : : ::_STOULL(_Ac, &_Ep, _Base, &_Errno);
596 :
597 : #else /* _LONGLONG */
598 : const unsigned long _Ans = ::_Stoulx(_Ac, &_Ep,
599 : _Getifld(_Ac, _First, _Last, ios_base::hex,
600 : _Iosbase.getloc()), &_Errno); // gather field, convert
601 : #endif /* _LONGLONG */
602 :
603 : if (_First == _Last)
604 : _State |= ios_base::eofbit;
605 : if (_Ep == _Ac || _Errno != 0)
606 : _State |= ios_base::failbit;
607 : else
608 : _Val = (void *)((char *)0 + _Ans); // deliver value
609 : return (_First);
610 : }
611 :
612 : private:
613 : int __CLRCALL_OR_CDECL _Getifld(_Pre_notnull_ _Post_z_ char *_Ac,
614 : _InIt& _First, _InIt& _Last, ios_base::fmtflags _Basefield,
615 : const locale& _Loc) const
616 : { // get integer field from [_First, _Last) into _Ac
617 : const _Mypunct& _Punct_fac = _USE(_Loc, _Mypunct);
618 : const string _Grouping = _Punct_fac.grouping();
619 : const _Elem _Kseparator = _Grouping.size() == 0
620 : ? (_Elem)0 : _Punct_fac.thousands_sep();
621 : const _Elem _E0 = _MAKLOCCHR(_Elem, '0', _Cvt);
622 : char *_Ptr = _Ac;
623 :
624 : if (_First == _Last)
625 : ; // empty field
626 : else if (*_First == _MAKLOCCHR(_Elem, '+', _Cvt))
627 : *_Ptr++ = '+', ++_First; // gather plus sign
628 : else if (*_First == _MAKLOCCHR(_Elem, '-', _Cvt))
629 : *_Ptr++ = '-', ++_First; // gather minus sign
630 :
631 : _Basefield &= ios_base::basefield;
632 : int _Base = _Basefield == ios_base::oct ? 8
633 : : _Basefield == ios_base::hex ? 16
634 : : _Basefield == ios_base::_Fmtzero ? 0 : 10;
635 :
636 : bool _Seendigit = false; // seen a digit in input
637 : bool _Nonzero = false; // seen a nonzero digit in input
638 :
639 : if (_First != _Last && *_First == _E0)
640 : { // leading zero, look for 0x, 0X
641 : _Seendigit = true, ++_First;
642 : if (_First != _Last && (*_First == _MAKLOCCHR(_Elem, 'x', _Cvt)
643 : || *_First == _MAKLOCCHR(_Elem, 'X', _Cvt))
644 : && (_Base == 0 || _Base == 16))
645 : _Base = 16, _Seendigit = false, ++_First;
646 : else if (_Base == 0)
647 : _Base = 8;
648 : }
649 :
650 : int _Dlen = _Base == 0 || _Base == 10 ? 10
651 : : _Base == 8 ? 8 : 16 + 6;
652 : string _Groups((size_t)1, (char)_Seendigit);
653 : size_t _Group = 0;
654 :
655 : for (char *const _Pe = &_Ac[_MAX_INT_DIG - 1];
656 : _First != _Last; ++_First)
657 : if (::memchr((const char *)"0123456789abcdefABCDEF",
658 : *_Ptr = _MAKLOCBYTE(_Elem, *_First, _Cvt), _Dlen) != 0)
659 : { // got a digit, characterize it and add to group size
660 : if ((_Nonzero || *_Ptr != '0') && _Ptr < _Pe)
661 : ++_Ptr, _Nonzero = true;
662 : _Seendigit = true;
663 : if (_Groups[_Group] != CHAR_MAX)
664 : ++_Groups[_Group];
665 : }
666 : else if (_Groups[_Group] == '\0'
667 : || _Kseparator == (_Elem)0
668 : || *_First != _Kseparator)
669 : break; // not a group separator, done
670 : else
671 : { // add a new group to _Groups string
672 : _Groups.append((string::size_type)1, '\0');
673 : ++_Group;
674 : }
675 :
676 : if (_Group == 0)
677 : ; // no thousands separators seen
678 : else if ('\0' < _Groups[_Group])
679 : ++_Group; // add trailing group to group count
680 : else
681 : _Seendigit = false; // trailing separator, fail
682 :
683 : for (const char *_Pg = _Grouping.c_str(); _Seendigit && 0 < _Group; )
684 : if (*_Pg == CHAR_MAX)
685 : break; // end of grouping constraints to check
686 : else if (0 < --_Group && *_Pg != _Groups[_Group]
687 : || 0 == _Group && *_Pg < _Groups[_Group])
688 : _Seendigit = false; // bad group size, fail
689 : else if ('\0' < _Pg[1])
690 : ++_Pg; // group size okay, advance to next test
691 :
692 : if (_Seendigit && !_Nonzero)
693 : *_Ptr++ = '0'; // zero field, replace stripped zero(s)
694 : else if (!_Seendigit)
695 : _Ptr = _Ac; // roll back pointer to indicate failure
696 : *_Ptr = '\0';
697 : return (_Base);
698 : }
699 :
700 : int __CLRCALL_OR_CDECL _Getffld(_Pre_notnull_ _Post_z_ char *_Ac,
701 : _InIt& _First, _InIt &_Last, const locale& _Loc) const
702 : { // get floating-point field from [_First, _Last) into _Ac
703 : const _Mypunct& _Punct_fac = _USE(_Loc, _Mypunct);
704 : const string _Grouping = _Punct_fac.grouping();
705 : const _Elem _E0 = _MAKLOCCHR(_Elem, '0', _Cvt);
706 : char *_Ptr = _Ac;
707 : bool _Bad = false;
708 :
709 : if (_First == _Last)
710 : ; // empty field
711 : else if (*_First == _MAKLOCCHR(_Elem, '+', _Cvt))
712 : *_Ptr++ = '+', ++_First; // gather plus sign
713 : else if (*_First == _MAKLOCCHR(_Elem, '-', _Cvt))
714 : *_Ptr++ = '-', ++_First; // gather minus sign
715 :
716 : bool _Seendigit = false; // seen a digit in input
717 : int _Significant = 0; // number of significant digits
718 : int _Pten = 0; // power of 10 multiplier
719 :
720 : if (*_Grouping.c_str() == CHAR_MAX || *_Grouping.c_str() <= '\0')
721 : for (; _First != _Last
722 : && _E0 <= *_First && *_First <= _E0 + 9;
723 : _Seendigit = true, ++_First)
724 : if (_MAX_SIG_DIG <= _Significant)
725 : ++_Pten; // just scale by 10
726 : else if (*_First == _E0 && _Significant == 0)
727 : ; // drop leading zeros
728 : else
729 : { // save a significant digit
730 : *_Ptr++ = (char)((*_First - _E0) + '0');
731 : ++_Significant;
732 : }
733 : else
734 : { // grouping specified, gather digits and group sizes
735 : const _Elem _Kseparator = _Punct_fac.thousands_sep();
736 :
737 : string _Groups((size_t)1, '\0');
738 : size_t _Group = 0;
739 :
740 : for (; _First != _Last; ++_First)
741 : if (_E0 <= *_First && *_First <= _E0 + 9)
742 : { // got a digit, add to group size
743 : _Seendigit = true;
744 : if (_MAX_SIG_DIG <= _Significant)
745 : ++_Pten; // just scale by 10
746 : else if (*_First == _E0 && _Significant == 0)
747 : ; // drop leading zeros
748 : else
749 : { // save a significant digit
750 : *_Ptr++ = (char)((*_First - _E0) + '0');
751 : ++_Significant;
752 : }
753 : if (_Groups[_Group] != CHAR_MAX)
754 : ++_Groups[_Group];
755 : }
756 : else if (_Groups[_Group] == '\0'
757 : || _Kseparator == (_Elem)0
758 : || *_First != _Kseparator)
759 : break; // not a group separator, done
760 : else
761 : { // add a new group to _Groups string
762 : _Groups.append((size_t)1, '\0');
763 : ++_Group;
764 : }
765 : if (_Group == 0)
766 : ; // no thousands separators seen
767 : else if ('\0' < _Groups[_Group])
768 : ++_Group; // add trailing group to group count
769 : else
770 : _Bad = true; // trailing separator, fail
771 :
772 : for (const char *_Pg = _Grouping.c_str();
773 : !_Bad && 0 < _Group; )
774 : if (*_Pg == CHAR_MAX)
775 : break; // end of grouping constraints to check
776 : else if (0 < --_Group && *_Pg != _Groups[_Group]
777 : || 0 == _Group && *_Pg < _Groups[_Group])
778 : _Bad = true; // bad group size, fail
779 : else if ('\0' < _Pg[1])
780 : ++_Pg; // group size okay, advance to next test
781 : }
782 :
783 : if (_Seendigit && _Significant == 0)
784 : *_Ptr++ = '0'; // save at least one leading digit
785 :
786 : if (_First != _Last && *_First == _Punct_fac.decimal_point())
787 : *_Ptr++ = localeconv()->decimal_point[0], ++_First; // add .
788 :
789 : if (_Significant == 0)
790 : { // 0000. so far
791 : for (; _First != _Last && *_First == _E0;
792 : _Seendigit = true, ++_First)
793 : --_Pten; // just count leading fraction zeros
794 : if (_Pten < 0)
795 : *_Ptr++ = '0', ++_Pten; // put one back
796 : }
797 :
798 : for (; _First != _Last
799 : && _E0 <= *_First && *_First <= _E0 + 9;
800 : _Seendigit = true, ++_First)
801 : if (_Significant < _MAX_SIG_DIG)
802 : { // save a significant fraction digit
803 : *_Ptr++ = (char)((*_First - _E0) + '0');
804 : ++_Significant;
805 : }
806 :
807 : if (_Seendigit && _First != _Last
808 : && (*_First == _MAKLOCCHR(_Elem, 'e', _Cvt)
809 : || *_First == _MAKLOCCHR(_Elem, 'E', _Cvt)))
810 : { // 'e' or 'E', collect exponent
811 : *_Ptr++ = 'e', ++_First;
812 : _Seendigit = false, _Significant = 0;
813 :
814 : if (_First == _Last)
815 : ; // 'e' or 'E' is last element
816 : else if (*_First == _MAKLOCCHR(_Elem, '+', _Cvt))
817 : *_Ptr++ = '+', ++_First; // gather plus sign
818 : else if (*_First == _MAKLOCCHR(_Elem, '-', _Cvt))
819 : *_Ptr++ = '-', ++_First; // gather minus sign
820 : for (; _First != _Last && *_First == _E0; )
821 : _Seendigit = true, ++_First; // strip leading zeros
822 : if (_Seendigit)
823 : *_Ptr++ = '0'; // put one back
824 : for (; _First != _Last
825 : && _E0 <= *_First && *_First <= _E0 + 9;
826 : _Seendigit = true, ++_First)
827 : if (_Significant < _MAX_EXP_DIG)
828 : { // save a significant exponent digit
829 : *_Ptr++ = (char)((*_First - _E0) + '0');
830 : ++_Significant;
831 : }
832 : }
833 :
834 : if (_Bad || !_Seendigit)
835 : _Ptr = _Ac; // roll back pointer to indicate failure
836 : *_Ptr = '\0';
837 : return (_Pten);
838 : }
839 :
840 :
841 : int _Hexdig(const _Elem _Dig, const _Elem _E0,
842 : const _Elem _Al, const _Elem _Au) const
843 : { // convert hex digit
844 : if (_E0 <= _Dig && _Dig <= _E0 + 9)
845 : return (_Dig - _E0); // assume 0-9 contiguous (C Standard)
846 : else if (_Al <= _Dig && _Dig <= _Al + 5)
847 : return (_Dig - _Al + 10); // assume a-f contiguous
848 : else if (_Au <= _Dig && _Dig <= _Au + 5)
849 : return (_Dig - _Au + 10); // assume A-F contiguous
850 : else
851 : return (-1);
852 : }
853 :
854 : int __cdecl _Getffldx(char *_Ac,
855 : _InIt& _First, _InIt &_Last,
856 : ios_base& _Iosbase, int *_Phexexp) const
857 : { // get hex floating-point field from [_First, _Last) into _Ac
858 : const _Mypunct& _Punct_fac = _USE(_Iosbase.getloc(), _Mypunct);
859 : const string _Grouping = _Punct_fac.grouping();
860 : const _Elem _E0 = _MAKLOCCHR(_Elem, '0', _Cvt);
861 : const _Elem _Al = _MAKLOCCHR(_Elem, 'a', _Cvt);
862 : const _Elem _Au = _MAKLOCCHR(_Elem, 'A', _Cvt);
863 : char *_Ptr = _Ac;
864 : bool _Bad = false;
865 : int _Dig;
866 :
867 : if (_First == _Last)
868 : ; // empty field
869 : else if (*_First == _MAKLOCCHR(_Elem, '+', _Cvt))
870 : *_Ptr++ = '+', ++_First; // gather plus sign
871 : else if (*_First == _MAKLOCCHR(_Elem, '-', _Cvt))
872 : *_Ptr++ = '-', ++_First; // gather minus sign
873 :
874 : *_Ptr++ = '0';
875 : *_Ptr++ = 'x';
876 :
877 : bool _Seendigit = false; // seen a digit in input
878 : int _Significant = 0; // number of significant digits
879 : int _Phex = 0; // power of 10 multiplier
880 :
881 : if (_First == _Last || *_First != _E0)
882 : ;
883 : else if (++_First != _Last
884 : && (*_First == _MAKLOCCHR(_Elem, 'x', _Cvt)
885 : || *_First == _MAKLOCCHR(_Elem, 'X', _Cvt)))
886 : ++_First; // discard any 0x or 0X
887 : else
888 : _Seendigit = true; // '0' not followed by 'x' or 'X'
889 :
890 : if (*_Grouping.c_str() == CHAR_MAX || *_Grouping.c_str() <= '\0')
891 : for (; _First != _Last
892 : && 0 <= (_Dig = _Hexdig(*_First, _E0, _Al, _Au));
893 : _Seendigit = true, ++_First)
894 : if (_MAX_SIG_DIG <= _Significant)
895 : ++_Phex; // just scale by 10
896 : else if (*_First == _E0 && _Significant == 0)
897 : ; // drop leading zeros
898 : else
899 : { // save a significant digit
900 : *_Ptr++ = "0123456789abcdef"[_Dig];
901 : ++_Significant;
902 : }
903 : else
904 : { // grouping specified, gather digits and group sizes
905 : const _Elem _Kseparator = _Grouping.size() == 0
906 : ? (_Elem)0 : _Punct_fac.thousands_sep();
907 : string _Groups((size_t)1, '\0');
908 : size_t _Group = 0;
909 :
910 : for (; _First != _Last; ++_First)
911 : if (0 <= (_Dig = _Hexdig(*_First, _E0, _Al, _Au)))
912 : { // got a digit, add to group size
913 : _Seendigit = true;
914 : if (_MAX_SIG_DIG <= _Significant)
915 : ++_Phex; // just scale by 10
916 : else if (*_First == _E0 && _Significant == 0)
917 : ; // drop leading zeros
918 : else
919 : { // save a significant digit
920 : *_Ptr++ = "0123456789abcdef"[_Dig];
921 : ++_Significant;
922 : }
923 : if (_Groups[_Group] != CHAR_MAX)
924 : ++_Groups[_Group];
925 : }
926 : else if (_Groups[_Group] == '\0'
927 : || _Kseparator == (_Elem)0
928 : || *_First != _Kseparator)
929 : break; // not a group separator, done
930 : else
931 : { // add a new group to _Groups string
932 : _Groups.append((size_t)1, '\0');
933 : ++_Group;
934 : }
935 : if (_Group == 0)
936 : ; // no thousands separators seen
937 : else if ('\0' < _Groups[_Group])
938 : ++_Group; // add trailing group to group count
939 : else
940 : _Bad = true; // trailing separator, fail
941 :
942 : for (const char *_Pg = _Grouping.c_str();
943 : !_Bad && 0 < _Group; )
944 : if (*_Pg == CHAR_MAX)
945 : break; // end of grouping constraints to check
946 : else if (0 < --_Group && *_Pg != _Groups[_Group]
947 : || 0 == _Group && *_Pg < _Groups[_Group])
948 : _Bad = true; // bad group size, fail
949 : else if ('\0' < _Pg[1])
950 : ++_Pg; // group size okay, advance to next test
951 : }
952 :
953 : if (_Seendigit && _Significant == 0)
954 : *_Ptr++ = '0'; // save at least one leading digit
955 :
956 : if (_First != _Last && *_First == _Punct_fac.decimal_point())
957 : *_Ptr++ = localeconv()->decimal_point[0], ++_First; // add .
958 :
959 : if (_Significant == 0)
960 : { // 0000. so far
961 : for (; _First != _Last && *_First == _E0;
962 : _Seendigit = true, ++_First)
963 : --_Phex; // just count leading fraction zeros
964 : if (_Phex < 0)
965 : *_Ptr++ = '0', ++_Phex; // put one back
966 : }
967 :
968 : for (; _First != _Last
969 : && 0 <= (_Dig = _Hexdig(*_First, _E0, _Al, _Au));
970 : _Seendigit = true, ++_First)
971 : if (_Significant < _MAX_SIG_DIG)
972 : { // save a significant fraction digit
973 : *_Ptr++ = "0123456789abcdef"[_Dig];
974 : ++_Significant;
975 : }
976 :
977 : if (_Seendigit && _First != _Last
978 : && (*_First == _MAKLOCCHR(_Elem, 'p', _Cvt)
979 : || *_First == _MAKLOCCHR(_Elem, 'P', _Cvt)))
980 : { // 'p' or 'P', collect exponent
981 : *_Ptr++ = 'p', ++_First;
982 : _Seendigit = false, _Significant = 0;
983 :
984 : if (_First == _Last)
985 : ; // 'p' or 'P' is last element
986 : else if (*_First == _MAKLOCCHR(_Elem, '+', _Cvt))
987 : *_Ptr++ = '+', ++_First; // gather plus sign
988 : else if (*_First == _MAKLOCCHR(_Elem, '-', _Cvt))
989 : *_Ptr++ = '-', ++_First; // gather minus sign
990 : for (; _First != _Last && *_First == _E0; )
991 : _Seendigit = true, ++_First; // strip leading zeros
992 : if (_Seendigit)
993 : *_Ptr++ = '0'; // put one back
994 : for (; _First != _Last
995 : && _E0 <= *_First && *_First <= _E0 + 9;
996 : _Seendigit = true, ++_First)
997 : if (_Significant < _MAX_EXP_DIG)
998 : { // save a significant exponent digit
999 : *_Ptr++ = (char)((*_First - _E0) + '0');
1000 : ++_Significant;
1001 : }
1002 : }
1003 :
1004 : if (_Bad || !_Seendigit)
1005 : _Ptr = _Ac; // roll back pointer to indicate failure
1006 : *_Ptr = '\0';
1007 : *_Phexexp = _Phex; // power of 16 multiplier
1008 : return (0); // power of 10 multiplier
1009 : }
1010 : };
1011 :
1012 : // STATIC num_get::id OBJECT
1013 : template<class _Elem,
1014 : class _InIt>
1015 : __PURE_APPDOMAIN_GLOBAL locale::id num_get<_Elem, _InIt>::id;
1016 :
1017 : // TEMPLATE CLASS num_put
1018 : template<class _Elem,
1019 : class _OutIt = ostreambuf_iterator<_Elem, char_traits<_Elem> > >
1020 : class num_put
1021 : : public locale::facet
1022 : { // facet for converting encoded numbers to text
1023 : public:
1024 : typedef numpunct<_Elem> _Mypunct;
1025 : typedef basic_string<_Elem, char_traits<_Elem>, allocator<_Elem> >
1026 : _Mystr;
1027 :
1028 : static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet **_Ppf = 0,
1029 : const locale *_Ploc = 0)
1030 9 : { // return locale category mask and construct standard facet
1031 9 : if (_Ppf != 0 && *_Ppf == 0)
1032 : *_Ppf = _NEW_CRT num_put<_Elem, _OutIt>(
1033 9 : _Locinfo(_Ploc->name()));
1034 9 : return (_X_NUMERIC);
1035 9 : }
1036 :
1037 : __PURE_APPDOMAIN_GLOBAL static locale::id id; // unique facet id
1038 :
1039 : _PROTECTED:
1040 : _VIRTUAL __CLR_OR_THIS_CALL ~num_put()
1041 9 : { // destroy the object
1042 9 : }
1043 :
1044 : protected:
1045 : void __CLR_OR_THIS_CALL _Init(const _Locinfo& _Lobj)
1046 13 : { // initialize from _Locinfo object
1047 9 : _Cvt = _Lobj._Getcvt();
1048 9 : }
1049 :
1050 : _Locinfo::_Cvtvec _Cvt; // conversion information
1051 :
1052 : public:
1053 : explicit __CLR_OR_THIS_CALL num_put(size_t _Refs = 0)
1054 : : locale::facet(_Refs)
1055 : { // construct from current locale
1056 : _BEGIN_LOCINFO(_Lobj)
1057 : _Init(_Lobj);
1058 : _END_LOCINFO()
1059 : }
1060 :
1061 : __CLR_OR_THIS_CALL num_put(const _Locinfo& _Lobj, size_t _Refs = 0)
1062 : : locale::facet(_Refs)
1063 9 : { // construct from specified locale
1064 9 : _Init(_Lobj);
1065 9 : }
1066 :
1067 : typedef _Elem char_type;
1068 : typedef _OutIt iter_type;
1069 :
1070 : _OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest,
1071 : ios_base& _Iosbase, _Elem _Fill, _Bool _Val) const
1072 : { // put formatted bool to _Dest
1073 : return (do_put(_Dest, _Iosbase, _Fill, _Val));
1074 : }
1075 :
1076 : _OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest,
1077 : ios_base& _Iosbase, _Elem _Fill, long _Val) const
1078 9 : { // put formatted long to _Dest
1079 9 : return (do_put(_Dest, _Iosbase, _Fill, _Val));
1080 9 : }
1081 :
1082 : _OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest,
1083 : ios_base& _Iosbase, _Elem _Fill, unsigned long _Val) const
1084 0 : { // put formatted unsigned long to _Dest
1085 0 : return (do_put(_Dest, _Iosbase, _Fill, _Val));
1086 0 : }
1087 :
1088 : #ifdef _LONGLONG
1089 : _OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest,
1090 : ios_base& _Iosbase, _Elem _Fill, _LONGLONG _Val) const
1091 9 : { // put formatted long long to _Dest
1092 9 : return (do_put(_Dest, _Iosbase, _Fill, _Val));
1093 9 : }
1094 :
1095 : _OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest,
1096 : ios_base& _Iosbase, _Elem _Fill, _ULONGLONG _Val) const
1097 0 : { // put formatted unsigned long long to _Dest
1098 0 : return (do_put(_Dest, _Iosbase, _Fill, _Val));
1099 0 : }
1100 : #endif /* _LONGLONG */
1101 :
1102 : _OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest,
1103 : ios_base& _Iosbase, _Elem _Fill, double _Val) const
1104 3 : { // put formatted double to _Dest
1105 3 : return (do_put(_Dest, _Iosbase, _Fill, _Val));
1106 3 : }
1107 :
1108 : _OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest,
1109 : ios_base& _Iosbase, _Elem _Fill, long double _Val) const
1110 : { // put formatted long double to _Dest
1111 : return (do_put(_Dest, _Iosbase, _Fill, _Val));
1112 : }
1113 :
1114 : _OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest,
1115 : ios_base& _Iosbase, _Elem _Fill, const void *_Val) const
1116 0 : { // put formatted void pointer to _Dest
1117 0 : return (do_put(_Dest, _Iosbase, _Fill, _Val));
1118 0 : }
1119 :
1120 : protected:
1121 : _VIRTUAL _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest,
1122 : ios_base& _Iosbase, _Elem _Fill, _Bool _Val) const
1123 0 : { // put formatted bool to _Dest
1124 0 : _DEBUG_POINTER(_Dest);
1125 0 : if (!(_Iosbase.flags() & ios_base::boolalpha))
1126 0 : return (do_put(_Dest, _Iosbase, _Fill, (long)_Val));
1127 : else
1128 : { // put "false" or "true"
1129 0 : const _Mypunct& _Punct_fac = _USE(_Iosbase.getloc(), _Mypunct);
1130 0 : _Mystr _Str;
1131 0 : if (_Val)
1132 0 : _Str.assign(_Punct_fac.truename());
1133 0 : else
1134 0 : _Str.assign(_Punct_fac.falsename());
1135 :
1136 : size_t _Fillcount = _Iosbase.width() <= 0
1137 : || (size_t)_Iosbase.width() <= _Str.size()
1138 0 : ? 0 : (size_t)_Iosbase.width() - _Str.size();
1139 :
1140 0 : if ((_Iosbase.flags() & ios_base::adjustfield) != ios_base::left)
1141 : { // put leading fill
1142 0 : _Dest = _Rep(_Dest, _Fill, _Fillcount);
1143 0 : _Fillcount = 0;
1144 : }
1145 0 : _Dest = _Put(_Dest, _Str.c_str(), _Str.size()); // put field
1146 0 : _Iosbase.width(0);
1147 0 : return (_Rep(_Dest, _Fill, _Fillcount)); // put trailing fill
1148 : }
1149 0 : }
1150 :
1151 : _VIRTUAL _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest,
1152 : ios_base& _Iosbase, _Elem _Fill, long _Val) const
1153 9 : { // put formatted long to _Dest
1154 9 : const size_t _Buf_size = 2 * _MAX_INT_DIG;
1155 : char _Buf[_Buf_size], _Fmt[6];
1156 : return (_Iput(_Dest, _Iosbase, _Fill, _Buf,
1157 : ::sprintf_s(_Buf, _Buf_size, _Ifmt(_Fmt, "ld",
1158 9 : _Iosbase.flags()), _Val)));
1159 9 : }
1160 :
1161 : _VIRTUAL _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest,
1162 : ios_base& _Iosbase, _Elem _Fill, unsigned long _Val) const
1163 0 : { // put formatted unsigned long to _Dest
1164 0 : const size_t _Buf_size = 2 * _MAX_INT_DIG;
1165 : char _Buf[_Buf_size], _Fmt[6];
1166 : return (_Iput(_Dest, _Iosbase, _Fill, _Buf,
1167 : ::sprintf_s(_Buf, _Buf_size, _Ifmt(_Fmt, "lu",
1168 0 : _Iosbase.flags()), _Val)));
1169 0 : }
1170 :
1171 : #ifdef _LONGLONG
1172 : _VIRTUAL _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest,
1173 : ios_base& _Iosbase, _Elem _Fill, _LONGLONG _Val) const
1174 9 : { // put formatted long long to _Dest
1175 9 : const size_t _Buf_size = 2 * _MAX_INT_DIG;
1176 : char _Buf[_Buf_size], _Fmt[8];
1177 : return (_Iput(_Dest, _Iosbase, _Fill, _Buf,
1178 : ::sprintf_s(_Buf, _Buf_size, _Ifmt(_Fmt, "Ld",
1179 9 : _Iosbase.flags()), _Val)));
1180 9 : }
1181 :
1182 : _VIRTUAL _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest,
1183 : ios_base& _Iosbase, _Elem _Fill, _ULONGLONG _Val) const
1184 0 : { // put formatted unsigned long long to _Dest
1185 0 : const size_t _Buf_size = 2 * _MAX_INT_DIG;
1186 : char _Buf[_Buf_size], _Fmt[8];
1187 : return (_Iput(_Dest, _Iosbase, _Fill, _Buf,
1188 : ::sprintf_s(_Buf, _Buf_size, _Ifmt(_Fmt, "Lu",
1189 0 : _Iosbase.flags()), _Val)));
1190 0 : }
1191 : #endif /* _LONGLONG */
1192 :
1193 : _VIRTUAL _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest,
1194 : ios_base& _Iosbase, _Elem _Fill, double _Val) const
1195 3 : { // put formatted double to _Dest
1196 3 : const size_t _Buf_size = _MAX_EXP_DIG + _MAX_SIG_DIG + 64;
1197 : char _Buf[_Buf_size], _Fmt[8];
1198 : streamsize _Precision = _Iosbase.precision() <= 0
1199 : && !(_Iosbase.flags() & ios_base::fixed)
1200 3 : ? 6 : _Iosbase.precision(); // desired precision
1201 : int _Significance = _MAX_SIG_DIG < _Precision
1202 3 : ? _MAX_SIG_DIG : (int)_Precision; // actual sprintf precision
1203 3 : _Precision -= _Significance;
1204 3 : size_t _Beforepoint = 0; // zeros to add before decimal point
1205 3 : size_t _Afterpoint = 0; // zeros to add after decimal point
1206 :
1207 : if ((_Iosbase.flags() & ios_base::floatfield) == ios_base::fixed
1208 3 : && _Val * 0.5 != _Val) // skip -Inf, 0, Inf
1209 : { // scale silly fixed-point value
1210 0 : bool _Signed = _Val < 0;
1211 0 : if (_Signed)
1212 0 : _Val = -_Val;
1213 :
1214 0 : for (; 1e35 <= _Val && _Beforepoint < 5000; _Beforepoint += 10)
1215 0 : _Val /= 1e10; // drop 10 zeros before decimal point
1216 :
1217 0 : if (0 < _Val)
1218 : for (; 10 <= _Precision && _Val <= 1e-35
1219 0 : && _Afterpoint < 5000; _Afterpoint += 10)
1220 : { // drop 10 zeros after decimal point
1221 0 : _Val *= 1e10;
1222 0 : _Precision -= 10;
1223 0 : }
1224 :
1225 0 : if (_Signed)
1226 0 : _Val = -_Val;
1227 : }
1228 :
1229 : return (_Fput(_Dest, _Iosbase, _Fill, _Buf,
1230 : _Beforepoint, _Afterpoint, _Precision,
1231 : ::sprintf_s(_Buf, _Buf_size, _Ffmt(_Fmt, 0, _Iosbase.flags()),
1232 3 : _Significance, _Val))); // convert and put
1233 3 : }
1234 :
1235 : _VIRTUAL _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest,
1236 : ios_base& _Iosbase, _Elem _Fill, long double _Val) const
1237 0 : { // put formatted long double to _Dest
1238 0 : const size_t _Buf_size = _MAX_EXP_DIG + _MAX_SIG_DIG + 64;
1239 : char _Buf[_Buf_size], _Fmt[8];
1240 : streamsize _Precision = _Iosbase.precision() <= 0
1241 : && !(_Iosbase.flags() & ios_base::fixed)
1242 0 : ? 6 : _Iosbase.precision(); // desired precision
1243 : int _Significance = _MAX_SIG_DIG < _Precision
1244 0 : ? _MAX_SIG_DIG : (int)_Precision; // actual sprintf precision
1245 0 : _Precision -= _Significance;
1246 0 : size_t _Beforepoint = 0; // zeros to add before decimal point
1247 0 : size_t _Afterpoint = 0; // zeros to add after decimal point
1248 :
1249 0 : if ((_Iosbase.flags() & ios_base::floatfield) == ios_base::fixed)
1250 : { // scale silly fixed-point value
1251 0 : bool _Signed = _Val < 0;
1252 0 : if (_Signed)
1253 0 : _Val = -_Val;
1254 :
1255 0 : for (; 1e35 <= _Val && _Beforepoint < 5000; _Beforepoint += 10)
1256 0 : _Val /= 1e10; // drop 10 zeros before decimal point
1257 :
1258 0 : if (0 < _Val)
1259 : for (; 10 <= _Precision && _Val <= 1e-35
1260 0 : && _Afterpoint < 5000; _Afterpoint += 10)
1261 : { // drop 10 zeros after decimal point
1262 0 : _Val *= 1e10;
1263 0 : _Precision -= 10;
1264 0 : }
1265 :
1266 0 : if (_Signed)
1267 0 : _Val = -_Val;
1268 : }
1269 :
1270 : return (_Fput(_Dest, _Iosbase, _Fill, _Buf,
1271 : _Beforepoint, _Afterpoint, _Precision,
1272 : ::sprintf_s(_Buf, _Buf_size, _Ffmt(_Fmt, 'L', _Iosbase.flags()),
1273 0 : _Significance, _Val))); // convert and put
1274 0 : }
1275 :
1276 : _VIRTUAL _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest,
1277 : ios_base& _Iosbase, _Elem _Fill, const void *_Val) const
1278 0 : { // put formatted void pointer to _Dest
1279 0 : const size_t _Buf_size = 2 * _MAX_INT_DIG;
1280 : char _Buf[_Buf_size];
1281 : return (_Iput(_Dest, _Iosbase, _Fill, _Buf,
1282 0 : ::sprintf_s(_Buf, _Buf_size, "%p", _Val)));
1283 0 : }
1284 :
1285 : private:
1286 : char *__CLRCALL_OR_CDECL _Ffmt(_Pre_notnull_ _Post_z_ char *_Fmt,
1287 : char _Spec, ios_base::fmtflags _Flags) const
1288 3 : { // generate sprintf format for floating-point
1289 3 : char *_Ptr = _Fmt;
1290 3 : *_Ptr++ = '%';
1291 :
1292 3 : if (_Flags & ios_base::showpos)
1293 0 : *_Ptr++ = '+';
1294 3 : if (_Flags & ios_base::showpoint)
1295 0 : *_Ptr++ = '#';
1296 3 : *_Ptr++ = '.';
1297 3 : *_Ptr++ = '*'; // for precision argument
1298 3 : if (_Spec != '\0')
1299 0 : *_Ptr++ = _Spec; // 'L' qualifier for long double only
1300 :
1301 3 : ios_base::fmtflags _Ffl = _Flags & ios_base::floatfield;
1302 : *_Ptr++ = _Ffl == ios_base::fixed ? 'f'
1303 : : _Ffl == ios_base::hexfloat ? 'a' // added with TR1
1304 3 : : _Ffl == ios_base::scientific ? 'e' : 'g'; // specifier
1305 3 : *_Ptr = '\0';
1306 3 : return (_Fmt);
1307 3 : }
1308 :
1309 : _OutIt __CLRCALL_OR_CDECL _Fput(_OutIt _Dest,
1310 : ios_base& _Iosbase, _Elem _Fill, const char *_Buf,
1311 : size_t _Beforepoint, size_t _Afterpoint,
1312 : size_t _Trailing, size_t _Count) const
1313 3 : { // put formatted floating-point to _Dest
1314 3 : _DEBUG_POINTER(_Dest);
1315 3 : const _Mypunct& _Punct_fac = _USE(_Iosbase.getloc(), _Mypunct);
1316 3 : const string _Grouping = _Punct_fac.grouping();
1317 3 : const _Elem _Kseparator = _Punct_fac.thousands_sep();
1318 3 : string _Groupstring;
1319 3 : const _Elem _E0 = _MAKLOCCHR(_Elem, '0', _Cvt);
1320 3 : size_t _Prefix = _Buf[0] == '+' || _Buf[0] == '-' ? 1 : 0;
1321 :
1322 : char _Enders[3];
1323 3 : _Enders[0] = ::localeconv()->decimal_point[0];
1324 3 : _Enders[1] = 'e';
1325 3 : _Enders[2] = '\0';
1326 :
1327 : const char *_Eptr = (const char *)::memchr(_Buf,
1328 3 : 'e', _Count); // find exponent
1329 : const char *_Pointptr = (const char *)::memchr(_Buf,
1330 3 : _Enders[0], _Count); // find decimal point
1331 3 : if (_Pointptr == 0)
1332 3 : _Trailing = 0;
1333 :
1334 3 : if (*_Grouping.c_str() != CHAR_MAX && '\0' < *_Grouping.c_str())
1335 : { // grouping specified, add thousands separators
1336 0 : _Groupstring.append(_Buf, _Count); // assemble field into string
1337 0 : if (_Eptr == 0)
1338 0 : _Groupstring.append(_Trailing, '0');
1339 0 : else
1340 : { /* dispose of any zeros before exponent */
1341 0 : if (_Pointptr == 0)
1342 : { /* no point but exponent, put scaling zeros */
1343 0 : _Groupstring.append(_Beforepoint, '0');
1344 0 : _Beforepoint = 0;
1345 : }
1346 0 : _Groupstring.insert(_Eptr - _Buf, _Trailing, '0');
1347 : }
1348 0 : _Trailing = 0;
1349 :
1350 0 : if (_Pointptr == 0)
1351 0 : _Groupstring.append(_Beforepoint, '0');
1352 0 : else
1353 : { // fill in zeros around decimal point
1354 0 : _Groupstring.insert(_Pointptr - _Buf + 1, _Afterpoint, '0');
1355 0 : _Groupstring.insert(_Pointptr - _Buf, _Beforepoint, '0');
1356 0 : _Afterpoint = 0;
1357 : }
1358 0 : _Beforepoint = 0;
1359 :
1360 0 : const char *_Pg = _Grouping.c_str();
1361 0 : size_t _Off = ::strcspn(&_Groupstring[0], &_Enders[0]);
1362 : while (*_Pg != CHAR_MAX && '\0' < *_Pg
1363 0 : && (size_t)*_Pg < _Off - _Prefix)
1364 : { // add a NUL to mark thousands separator
1365 0 : _Groupstring.insert(_Off -= *_Pg, (size_t)1, '\0');
1366 0 : if ('\0' < _Pg[1])
1367 0 : ++_Pg; // not last group, advance
1368 0 : }
1369 :
1370 0 : _Buf = &_Groupstring[0];
1371 0 : _Trailing = 0;
1372 0 : _Count = _Groupstring.size();
1373 : }
1374 :
1375 3 : size_t _Fillcount = _Beforepoint + _Afterpoint + _Trailing + _Count;
1376 : _Fillcount = _Iosbase.width() <= 0
1377 : || (size_t)_Iosbase.width() <= _Fillcount
1378 3 : ? 0 : (size_t)_Iosbase.width() - _Fillcount;
1379 : ios_base::fmtflags _Adjustfield =
1380 3 : _Iosbase.flags() & ios_base::adjustfield;
1381 : if (_Adjustfield != ios_base::left
1382 3 : && _Adjustfield != ios_base::internal)
1383 : { // put leading fill
1384 3 : _Dest = _Rep(_Dest, _Fill, _Fillcount);
1385 3 : _Fillcount = 0;
1386 : }
1387 0 : else if (_Adjustfield == ios_base::internal)
1388 : { // put internal fill
1389 0 : if (0 < _Prefix)
1390 : { // but first put sign
1391 0 : _Dest = _Putc(_Dest, _Buf, 1);
1392 0 : ++_Buf, --_Count;
1393 : }
1394 0 : _Dest = _Rep(_Dest, _Fill, _Fillcount);
1395 0 : _Fillcount = 0;
1396 : }
1397 :
1398 : _Pointptr = (const char *)::memchr(_Buf,
1399 3 : _Enders[0], _Count); // find decimal point again
1400 3 : if (_Pointptr != 0)
1401 : { // has decimal point, put pieces and zero fills
1402 0 : size_t _Fracoffset = _Pointptr - _Buf + 1;
1403 0 : _Dest = _Putgrouped(_Dest, _Buf, _Fracoffset - 1, _Kseparator);
1404 0 : _Dest = _Rep(_Dest, _E0, _Beforepoint);
1405 0 : _Dest = _Rep(_Dest, _Punct_fac.decimal_point(), 1);
1406 0 : _Dest = _Rep(_Dest, _E0, _Afterpoint);
1407 0 : _Buf += _Fracoffset, _Count -= _Fracoffset;
1408 : }
1409 :
1410 : _Eptr = (const char *)::memchr(_Buf,
1411 3 : 'e', _Count); // find exponent again
1412 3 : if (_Eptr != 0)
1413 : { // has exponent field, put it out
1414 0 : size_t _Expoffset = _Eptr - _Buf + 1;
1415 0 : _Dest = _Putgrouped(_Dest, _Buf, _Expoffset - 1, _Kseparator);
1416 0 : _Dest = _Rep(_Dest, _E0, _Trailing), _Trailing = 0;
1417 : _Dest = _Putc(_Dest, _Iosbase.flags() & ios_base::uppercase
1418 0 : ? "E" : "e", 1);
1419 0 : _Buf += _Expoffset, _Count -= _Expoffset;
1420 : }
1421 :
1422 : _Dest = _Putgrouped(_Dest, _Buf, _Count,
1423 3 : _Kseparator); // put leftover field
1424 3 : _Dest = _Rep(_Dest, _E0, _Trailing); // put trailing zeros
1425 3 : _Iosbase.width(0);
1426 3 : return (_Rep(_Dest, _Fill, _Fillcount)); // put trailing fill
1427 3 : }
1428 :
1429 : char *__CLRCALL_OR_CDECL _Ifmt(_Pre_notnull_ _Post_z_ char *_Fmt,
1430 : const char *_Spec, ios_base::fmtflags _Flags) const
1431 9 : { // generate sprintf format for integer
1432 9 : char *_Ptr = _Fmt;
1433 9 : *_Ptr++ = '%';
1434 :
1435 9 : if (_Flags & ios_base::showpos)
1436 0 : *_Ptr++ = '+';
1437 9 : if (_Flags & ios_base::showbase)
1438 0 : *_Ptr++ = '#';
1439 9 : if (_Spec[0] != 'L')
1440 9 : *_Ptr++ = _Spec[0]; // qualifier
1441 9 : else
1442 : { /* change L to I64 */
1443 9 : *_Ptr++ = 'I';
1444 9 : *_Ptr++ = '6';
1445 9 : *_Ptr++ = '4';
1446 : }
1447 :
1448 9 : ios_base::fmtflags _Basefield = _Flags & ios_base::basefield;
1449 : *_Ptr++ = _Basefield == ios_base::oct ? 'o'
1450 : : _Basefield != ios_base::hex ? _Spec[1] // 'd' or 'u'
1451 9 : : _Flags & ios_base::uppercase ? 'X' : 'x';
1452 9 : *_Ptr = '\0';
1453 9 : return (_Fmt);
1454 9 : }
1455 :
1456 : _OutIt __CLRCALL_OR_CDECL _Iput(_OutIt _Dest,
1457 : ios_base& _Iosbase, _Elem _Fill, _Inout_cap_(_Count) char *_Buf, size_t _Count) const
1458 9 : { // put formatted integer to _Dest
1459 9 : _DEBUG_POINTER(_Dest);
1460 9 : const _Mypunct& _Punct_fac = _USE(_Iosbase.getloc(), _Mypunct);
1461 9 : const string _Grouping = _Punct_fac.grouping();
1462 : const size_t _Prefix = *_Buf == '+' || *_Buf == '-' ? 1
1463 : : *_Buf == '0' && (_Buf[1] == 'x' || _Buf[1] == 'X') ? 2
1464 9 : : 0;
1465 :
1466 9 : if (*_Grouping.c_str() != CHAR_MAX && '\0' < *_Grouping.c_str())
1467 : { // grouping specified, add thousands separators
1468 0 : const char *_Pg = _Grouping.c_str();
1469 0 : size_t _Off = _Count;
1470 : while (*_Pg != CHAR_MAX && '\0' < *_Pg
1471 0 : && (size_t)*_Pg < _Off - _Prefix)
1472 : { // add a NUL to mark thousands separator
1473 0 : _Off -= *_Pg;
1474 0 : _CRT_SECURE_MEMMOVE(&_Buf[_Off + 1], _Count + 1 - _Off,
1475 : &_Buf[_Off], _Count + 1 - _Off);
1476 0 : _Buf[_Off] = '\0', ++_Count;
1477 0 : if ('\0' < _Pg[1])
1478 0 : ++_Pg; // not last group, advance
1479 0 : }
1480 : }
1481 :
1482 : size_t _Fillcount = _Iosbase.width() <= 0
1483 : || (size_t)_Iosbase.width() <= _Count
1484 9 : ? 0 : (size_t)_Iosbase.width() - _Count;
1485 :
1486 : ios_base::fmtflags _Adjustfield =
1487 9 : _Iosbase.flags() & ios_base::adjustfield;
1488 : if (_Adjustfield != ios_base::left
1489 9 : && _Adjustfield != ios_base::internal)
1490 : { // put leading fill
1491 9 : _Dest = _Rep(_Dest, _Fill, _Fillcount);
1492 9 : _Fillcount = 0;
1493 : }
1494 0 : else if (_Adjustfield == ios_base::internal)
1495 : { // put internal fill
1496 0 : _Dest = _Putc(_Dest, _Buf, _Prefix); // put prefix
1497 0 : _Buf += _Prefix, _Count -= _Prefix;
1498 0 : _Dest = _Rep(_Dest, _Fill, _Fillcount), _Fillcount = 0;
1499 : }
1500 :
1501 : _Dest = _Putgrouped(_Dest, _Buf, _Count,
1502 9 : _Punct_fac.thousands_sep()); // put field
1503 9 : _Iosbase.width(0);
1504 9 : return (_Rep(_Dest, _Fill, _Fillcount)); // put trailing fill
1505 9 : }
1506 :
1507 : _OutIt __CLRCALL_OR_CDECL _Put(_OutIt _Dest,
1508 : const _Elem *_Ptr, size_t _Count) const
1509 0 : { // put [_Ptr, _Ptr + _Count) to _Dest
1510 0 : for (; 0 < _Count; --_Count, ++_Dest, ++_Ptr)
1511 0 : *_Dest = *_Ptr;
1512 0 : return (_Dest);
1513 0 : }
1514 :
1515 : _OutIt __CLRCALL_OR_CDECL _Putc(_OutIt _Dest,
1516 : const char *_Ptr, size_t _Count) const
1517 9 : { // put char sequence [_Ptr, _Ptr + _Count) to _Dest
1518 9 : for (; 0 < _Count; --_Count, ++_Dest, ++_Ptr)
1519 9 : *_Dest = _MAKLOCCHR(_Elem, *_Ptr, _Cvt);
1520 9 : return (_Dest);
1521 9 : }
1522 :
1523 : _OutIt __CLRCALL_OR_CDECL _Putgrouped(_OutIt _Dest,
1524 : const char *_Ptr, size_t _Count, _Elem _Kseparator) const
1525 9 : { // put char sequence [_Ptr, _Ptr + _Count) to _Dest with commas
1526 9 : for (; ; ++_Ptr, --_Count)
1527 : { // put field with thousands separators for NULs
1528 : const char *_Pend =
1529 9 : (const char *)::memchr(_Ptr, '\0', _Count);
1530 9 : size_t _Groupsize = _Pend != 0 ? _Pend - _Ptr : _Count;
1531 :
1532 9 : _Dest = _Putc(_Dest, _Ptr, _Groupsize);
1533 9 : _Ptr += _Groupsize, _Count -= _Groupsize;
1534 9 : if (_Count == 0)
1535 9 : break;
1536 0 : if (_Kseparator != (_Elem)0)
1537 0 : _Dest = _Rep(_Dest, _Kseparator, 1);
1538 0 : }
1539 9 : return (_Dest);
1540 9 : }
1541 :
1542 : _OutIt __CLRCALL_OR_CDECL _Rep(_OutIt _Dest,
1543 : _Elem _Ch, size_t _Count) const
1544 9 : { // put _Count * _Ch to _Dest
1545 9 : for (; 0 < _Count; --_Count, ++_Dest)
1546 3 : *_Dest = _Ch;
1547 9 : return (_Dest);
1548 9 : }
1549 : };
1550 :
1551 : // STATIC num_put::id OBJECT
1552 : template<class _Elem,
1553 : class _OutIt>
1554 : __PURE_APPDOMAIN_GLOBAL locale::id num_put<_Elem, _OutIt>::id;
1555 :
1556 : #if defined(_DLL_CPPLIB) && !defined(_M_CEE_PURE)
1557 :
1558 : template class _CRTIMP2_PURE numpunct<char>;
1559 : template class _CRTIMP2_PURE num_get<char,
1560 : istreambuf_iterator<char, char_traits<char> > >;
1561 : template class _CRTIMP2_PURE num_put<char,
1562 : ostreambuf_iterator<char, char_traits<char> > >;
1563 :
1564 : template class _CRTIMP2_PURE numpunct<wchar_t>;
1565 : template class _CRTIMP2_PURE num_get<wchar_t,
1566 : istreambuf_iterator<wchar_t, char_traits<wchar_t> > >;
1567 : template class _CRTIMP2_PURE num_put<wchar_t,
1568 : ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >;
1569 :
1570 :
1571 :
1572 : #endif /* _DLL_CPPLIB */
1573 :
1574 : #pragma warning(pop)
1575 : _STD_END
1576 :
1577 : #ifdef _MSC_VER
1578 : #pragma warning(pop)
1579 : #pragma pack(pop)
1580 : #endif /* _MSC_VER */
1581 :
1582 : #endif /* RC_INVOKED */
1583 : #endif /* _XLOCNUM_ */
1584 :
1585 : /*
1586 : * Copyright (c) 1992-2008 by P.J. Plauger. ALL RIGHTS RESERVED.
1587 : * Consult your license regarding permissions and restrictions.
1588 : V5.05:0009 */
1589 :
1590 :
|
