libstdc++
locale_facets_nonio.tcc
Go to the documentation of this file.
1// Locale support -*- C++ -*-
2
3// Copyright (C) 2007-2020 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library. This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.
10
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14// GNU General Public License for more details.
15
16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.
19
20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23// <http://www.gnu.org/licenses/>.
24
25/** @file bits/locale_facets_nonio.tcc
26 * This is an internal header file, included by other library headers.
27 * Do not attempt to use it directly. @headername{locale}
28 */
29
30#ifndef _LOCALE_FACETS_NONIO_TCC
31#define _LOCALE_FACETS_NONIO_TCC 1
32
33#pragma GCC system_header
34
35namespace std _GLIBCXX_VISIBILITY(default)
36{
37_GLIBCXX_BEGIN_NAMESPACE_VERSION
38
39 template<typename _CharT, bool _Intl>
40 struct __use_cache<__moneypunct_cache<_CharT, _Intl> >
41 {
42 const __moneypunct_cache<_CharT, _Intl>*
43 operator() (const locale& __loc) const
44 {
45 const size_t __i = moneypunct<_CharT, _Intl>::id._M_id();
46 const locale::facet** __caches = __loc._M_impl->_M_caches;
47 if (!__caches[__i])
48 {
49 __moneypunct_cache<_CharT, _Intl>* __tmp = 0;
50 __try
51 {
52 __tmp = new __moneypunct_cache<_CharT, _Intl>;
53 __tmp->_M_cache(__loc);
54 }
55 __catch(...)
56 {
57 delete __tmp;
58 __throw_exception_again;
59 }
60 __loc._M_impl->_M_install_cache(__tmp, __i);
61 }
62 return static_cast<
63 const __moneypunct_cache<_CharT, _Intl>*>(__caches[__i]);
64 }
65 };
66
67 template<typename _CharT, bool _Intl>
68 void
69 __moneypunct_cache<_CharT, _Intl>::_M_cache(const locale& __loc)
70 {
71 const moneypunct<_CharT, _Intl>& __mp =
72 use_facet<moneypunct<_CharT, _Intl> >(__loc);
73
74 _M_decimal_point = __mp.decimal_point();
75 _M_thousands_sep = __mp.thousands_sep();
76 _M_frac_digits = __mp.frac_digits();
77
78 char* __grouping = 0;
79 _CharT* __curr_symbol = 0;
80 _CharT* __positive_sign = 0;
81 _CharT* __negative_sign = 0;
82 __try
83 {
84 const string& __g = __mp.grouping();
85 _M_grouping_size = __g.size();
86 __grouping = new char[_M_grouping_size];
87 __g.copy(__grouping, _M_grouping_size);
88 _M_use_grouping = (_M_grouping_size
89 && static_cast<signed char>(__grouping[0]) > 0
90 && (__grouping[0]
91 != __gnu_cxx::__numeric_traits<char>::__max));
92
93 const basic_string<_CharT>& __cs = __mp.curr_symbol();
94 _M_curr_symbol_size = __cs.size();
95 __curr_symbol = new _CharT[_M_curr_symbol_size];
96 __cs.copy(__curr_symbol, _M_curr_symbol_size);
97
98 const basic_string<_CharT>& __ps = __mp.positive_sign();
99 _M_positive_sign_size = __ps.size();
100 __positive_sign = new _CharT[_M_positive_sign_size];
101 __ps.copy(__positive_sign, _M_positive_sign_size);
102
103 const basic_string<_CharT>& __ns = __mp.negative_sign();
104 _M_negative_sign_size = __ns.size();
105 __negative_sign = new _CharT[_M_negative_sign_size];
106 __ns.copy(__negative_sign, _M_negative_sign_size);
107
108 _M_pos_format = __mp.pos_format();
109 _M_neg_format = __mp.neg_format();
110
111 const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
112 __ct.widen(money_base::_S_atoms,
113 money_base::_S_atoms + money_base::_S_end, _M_atoms);
114
115 _M_grouping = __grouping;
116 _M_curr_symbol = __curr_symbol;
117 _M_positive_sign = __positive_sign;
118 _M_negative_sign = __negative_sign;
119 _M_allocated = true;
120 }
121 __catch(...)
122 {
123 delete [] __grouping;
124 delete [] __curr_symbol;
125 delete [] __positive_sign;
126 delete [] __negative_sign;
127 __throw_exception_again;
128 }
129 }
130
131_GLIBCXX_BEGIN_NAMESPACE_LDBL_OR_CXX11
132
133 template<typename _CharT, typename _InIter>
134 template<bool _Intl>
135 _InIter
136 money_get<_CharT, _InIter>::
137 _M_extract(iter_type __beg, iter_type __end, ios_base& __io,
138 ios_base::iostate& __err, string& __units) const
139 {
140 typedef char_traits<_CharT> __traits_type;
141 typedef typename string_type::size_type size_type;
142 typedef money_base::part part;
143 typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
144
145 const locale& __loc = __io._M_getloc();
146 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
147
148 __use_cache<__cache_type> __uc;
149 const __cache_type* __lc = __uc(__loc);
150 const char_type* __lit = __lc->_M_atoms;
151
152 // Deduced sign.
153 bool __negative = false;
154 // Sign size.
155 size_type __sign_size = 0;
156 // True if sign is mandatory.
157 const bool __mandatory_sign = (__lc->_M_positive_sign_size
158 && __lc->_M_negative_sign_size);
159 // String of grouping info from thousands_sep plucked from __units.
160 string __grouping_tmp;
161 if (__lc->_M_use_grouping)
162 __grouping_tmp.reserve(32);
163 // Last position before the decimal point.
164 int __last_pos = 0;
165 // Separator positions, then, possibly, fractional digits.
166 int __n = 0;
167 // If input iterator is in a valid state.
168 bool __testvalid = true;
169 // Flag marking when a decimal point is found.
170 bool __testdecfound = false;
171
172 // The tentative returned string is stored here.
173 string __res;
174 __res.reserve(32);
175
176 const char_type* __lit_zero = __lit + money_base::_S_zero;
177 const money_base::pattern __p = __lc->_M_neg_format;
178 for (int __i = 0; __i < 4 && __testvalid; ++__i)
179 {
180 const part __which = static_cast<part>(__p.field[__i]);
181 switch (__which)
182 {
183 case money_base::symbol:
184 // According to 22.2.6.1.2, p2, symbol is required
185 // if (__io.flags() & ios_base::showbase), otherwise
186 // is optional and consumed only if other characters
187 // are needed to complete the format.
188 if (__io.flags() & ios_base::showbase || __sign_size > 1
189 || __i == 0
190 || (__i == 1 && (__mandatory_sign
191 || (static_cast<part>(__p.field[0])
192 == money_base::sign)
193 || (static_cast<part>(__p.field[2])
194 == money_base::space)))
195 || (__i == 2 && ((static_cast<part>(__p.field[3])
196 == money_base::value)
197 || (__mandatory_sign
198 && (static_cast<part>(__p.field[3])
199 == money_base::sign)))))
200 {
201 const size_type __len = __lc->_M_curr_symbol_size;
202 size_type __j = 0;
203 for (; __beg != __end && __j < __len
204 && *__beg == __lc->_M_curr_symbol[__j];
205 ++__beg, (void)++__j);
206 if (__j != __len
207 && (__j || __io.flags() & ios_base::showbase))
208 __testvalid = false;
209 }
210 break;
211 case money_base::sign:
212 // Sign might not exist, or be more than one character long.
213 if (__lc->_M_positive_sign_size && __beg != __end
214 && *__beg == __lc->_M_positive_sign[0])
215 {
216 __sign_size = __lc->_M_positive_sign_size;
217 ++__beg;
218 }
219 else if (__lc->_M_negative_sign_size && __beg != __end
220 && *__beg == __lc->_M_negative_sign[0])
221 {
222 __negative = true;
223 __sign_size = __lc->_M_negative_sign_size;
224 ++__beg;
225 }
226 else if (__lc->_M_positive_sign_size
227 && !__lc->_M_negative_sign_size)
228 // "... if no sign is detected, the result is given the sign
229 // that corresponds to the source of the empty string"
230 __negative = true;
231 else if (__mandatory_sign)
232 __testvalid = false;
233 break;
234 case money_base::value:
235 // Extract digits, remove and stash away the
236 // grouping of found thousands separators.
237 for (; __beg != __end; ++__beg)
238 {
239 const char_type __c = *__beg;
240 const char_type* __q = __traits_type::find(__lit_zero,
241 10, __c);
242 if (__q != 0)
243 {
244 __res += money_base::_S_atoms[__q - __lit];
245 ++__n;
246 }
247 else if (__c == __lc->_M_decimal_point
248 && !__testdecfound)
249 {
250 if (__lc->_M_frac_digits <= 0)
251 break;
252
253 __last_pos = __n;
254 __n = 0;
255 __testdecfound = true;
256 }
257 else if (__lc->_M_use_grouping
258 && __c == __lc->_M_thousands_sep
259 && !__testdecfound)
260 {
261 if (__n)
262 {
263 // Mark position for later analysis.
264 __grouping_tmp += static_cast<char>(__n);
265 __n = 0;
266 }
267 else
268 {
269 __testvalid = false;
270 break;
271 }
272 }
273 else
274 break;
275 }
276 if (__res.empty())
277 __testvalid = false;
278 break;
279 case money_base::space:
280 // At least one space is required.
281 if (__beg != __end && __ctype.is(ctype_base::space, *__beg))
282 ++__beg;
283 else
284 __testvalid = false;
285 // fallthrough
286 case money_base::none:
287 // Only if not at the end of the pattern.
288 if (__i != 3)
289 for (; __beg != __end
290 && __ctype.is(ctype_base::space, *__beg); ++__beg);
291 break;
292 }
293 }
294
295 // Need to get the rest of the sign characters, if they exist.
296 if (__sign_size > 1 && __testvalid)
297 {
298 const char_type* __sign = __negative ? __lc->_M_negative_sign
299 : __lc->_M_positive_sign;
300 size_type __i = 1;
301 for (; __beg != __end && __i < __sign_size
302 && *__beg == __sign[__i]; ++__beg, (void)++__i);
303
304 if (__i != __sign_size)
305 __testvalid = false;
306 }
307
308 if (__testvalid)
309 {
310 // Strip leading zeros.
311 if (__res.size() > 1)
312 {
313 const size_type __first = __res.find_first_not_of('0');
314 const bool __only_zeros = __first == string::npos;
315 if (__first)
316 __res.erase(0, __only_zeros ? __res.size() - 1 : __first);
317 }
318
319 // 22.2.6.1.2, p4
320 if (__negative && __res[0] != '0')
321 __res.insert(__res.begin(), '-');
322
323 // Test for grouping fidelity.
324 if (__grouping_tmp.size())
325 {
326 // Add the ending grouping.
327 __grouping_tmp += static_cast<char>(__testdecfound ? __last_pos
328 : __n);
329 if (!std::__verify_grouping(__lc->_M_grouping,
330 __lc->_M_grouping_size,
331 __grouping_tmp))
332 __err |= ios_base::failbit;
333 }
334
335 // Iff not enough digits were supplied after the decimal-point.
336 if (__testdecfound && __n != __lc->_M_frac_digits)
337 __testvalid = false;
338 }
339
340 // Iff valid sequence is not recognized.
341 if (!__testvalid)
342 __err |= ios_base::failbit;
343 else
344 __units.swap(__res);
345
346 // Iff no more characters are available.
347 if (__beg == __end)
348 __err |= ios_base::eofbit;
349 return __beg;
350 }
351
352#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ \
353 && _GLIBCXX_USE_CXX11_ABI == 0
354 template<typename _CharT, typename _InIter>
355 _InIter
356 money_get<_CharT, _InIter>::
357 __do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
358 ios_base::iostate& __err, double& __units) const
359 {
360 string __str;
361 __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
362 : _M_extract<false>(__beg, __end, __io, __err, __str);
363 std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
364 return __beg;
365 }
366#endif
367
368 template<typename _CharT, typename _InIter>
369 _InIter
372 ios_base::iostate& __err, long double& __units) const
373 {
374 string __str;
377 std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
378 return __beg;
379 }
380
381 template<typename _CharT, typename _InIter>
382 _InIter
385 ios_base::iostate& __err, string_type& __digits) const
386 {
387 typedef typename string::size_type size_type;
388
389 const locale& __loc = __io._M_getloc();
391
392 string __str;
395 const size_type __len = __str.size();
396 if (__len)
397 {
398 __digits.resize(__len);
399 __ctype.widen(__str.data(), __str.data() + __len, &__digits[0]);
400 }
401 return __beg;
402 }
403
404 template<typename _CharT, typename _OutIter>
405 template<bool _Intl>
408 _M_insert(iter_type __s, ios_base& __io, char_type __fill,
409 const string_type& __digits) const
410 {
411 typedef typename string_type::size_type size_type;
412 typedef money_base::part part;
413 typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
414
415 const locale& __loc = __io._M_getloc();
417
419 const __cache_type* __lc = __uc(__loc);
420 const char_type* __lit = __lc->_M_atoms;
421
422 // Determine if negative or positive formats are to be used, and
423 // discard leading negative_sign if it is present.
424 const char_type* __beg = __digits.data();
425
426 money_base::pattern __p;
427 const char_type* __sign;
428 size_type __sign_size;
429 if (!(*__beg == __lit[money_base::_S_minus]))
430 {
431 __p = __lc->_M_pos_format;
432 __sign = __lc->_M_positive_sign;
433 __sign_size = __lc->_M_positive_sign_size;
434 }
435 else
436 {
437 __p = __lc->_M_neg_format;
438 __sign = __lc->_M_negative_sign;
439 __sign_size = __lc->_M_negative_sign_size;
440 if (__digits.size())
441 ++__beg;
442 }
443
444 // Look for valid numbers in the ctype facet within input digits.
445 size_type __len = __ctype.scan_not(ctype_base::digit, __beg,
446 __beg + __digits.size()) - __beg;
447 if (__len)
448 {
449 // Assume valid input, and attempt to format.
450 // Break down input numbers into base components, as follows:
451 // final_value = grouped units + (decimal point) + (digits)
452 string_type __value;
453 __value.reserve(2 * __len);
454
455 // Add thousands separators to non-decimal digits, per
456 // grouping rules.
457 long __paddec = __len - __lc->_M_frac_digits;
458 if (__paddec > 0)
459 {
460 if (__lc->_M_frac_digits < 0)
461 __paddec = __len;
462 if (__lc->_M_grouping_size)
463 {
464 __value.assign(2 * __paddec, char_type());
465 _CharT* __vend =
466 std::__add_grouping(&__value[0], __lc->_M_thousands_sep,
467 __lc->_M_grouping,
468 __lc->_M_grouping_size,
469 __beg, __beg + __paddec);
470 __value.erase(__vend - &__value[0]);
471 }
472 else
473 __value.assign(__beg, __paddec);
474 }
475
476 // Deal with decimal point, decimal digits.
477 if (__lc->_M_frac_digits > 0)
478 {
479 __value += __lc->_M_decimal_point;
480 if (__paddec >= 0)
481 __value.append(__beg + __paddec, __lc->_M_frac_digits);
482 else
483 {
484 // Have to pad zeros in the decimal position.
485 __value.append(-__paddec, __lit[money_base::_S_zero]);
486 __value.append(__beg, __len);
487 }
488 }
489
490 // Calculate length of resulting string.
491 const ios_base::fmtflags __f = __io.flags()
493 __len = __value.size() + __sign_size;
494 __len += ((__io.flags() & ios_base::showbase)
495 ? __lc->_M_curr_symbol_size : 0);
496
497 string_type __res;
498 __res.reserve(2 * __len);
499
500 const size_type __width = static_cast<size_type>(__io.width());
501 const bool __testipad = (__f == ios_base::internal
502 && __len < __width);
503 // Fit formatted digits into the required pattern.
504 for (int __i = 0; __i < 4; ++__i)
505 {
506 const part __which = static_cast<part>(__p.field[__i]);
507 switch (__which)
508 {
509 case money_base::symbol:
510 if (__io.flags() & ios_base::showbase)
511 __res.append(__lc->_M_curr_symbol,
512 __lc->_M_curr_symbol_size);
513 break;
514 case money_base::sign:
515 // Sign might not exist, or be more than one
516 // character long. In that case, add in the rest
517 // below.
518 if (__sign_size)
519 __res += __sign[0];
520 break;
521 case money_base::value:
522 __res += __value;
523 break;
524 case money_base::space:
525 // At least one space is required, but if internal
526 // formatting is required, an arbitrary number of
527 // fill spaces will be necessary.
528 if (__testipad)
529 __res.append(__width - __len, __fill);
530 else
531 __res += __fill;
532 break;
533 case money_base::none:
534 if (__testipad)
535 __res.append(__width - __len, __fill);
536 break;
537 }
538 }
539
540 // Special case of multi-part sign parts.
541 if (__sign_size > 1)
542 __res.append(__sign + 1, __sign_size - 1);
543
544 // Pad, if still necessary.
545 __len = __res.size();
546 if (__width > __len)
547 {
548 if (__f == ios_base::left)
549 // After.
550 __res.append(__width - __len, __fill);
551 else
552 // Before.
553 __res.insert(0, __width - __len, __fill);
554 __len = __width;
555 }
556
557 // Write resulting, fully-formatted string to output iterator.
558 __s = std::__write(__s, __res.data(), __len);
559 }
560 __io.width(0);
561 return __s;
562 }
563
564#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ \
565 && _GLIBCXX_USE_CXX11_ABI == 0
566 template<typename _CharT, typename _OutIter>
567 _OutIter
568 money_put<_CharT, _OutIter>::
569 __do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
570 double __units) const
571 { return this->do_put(__s, __intl, __io, __fill, (long double) __units); }
572#endif
573
574 template<typename _CharT, typename _OutIter>
575 _OutIter
578 long double __units) const
579 {
580 const locale __loc = __io.getloc();
582#if _GLIBCXX_USE_C99_STDIO
583 // First try a buffer perhaps big enough.
584 int __cs_size = 64;
585 char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
586 // _GLIBCXX_RESOLVE_LIB_DEFECTS
587 // 328. Bad sprintf format modifier in money_put<>::do_put()
588 int __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
589 "%.*Lf", 0, __units);
590 // If the buffer was not large enough, try again with the correct size.
591 if (__len >= __cs_size)
592 {
593 __cs_size = __len + 1;
594 __cs = static_cast<char*>(__builtin_alloca(__cs_size));
595 __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
596 "%.*Lf", 0, __units);
597 }
598#else
599 // max_exponent10 + 1 for the integer part, + 2 for sign and '\0'.
600 const int __cs_size =
601 __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 3;
602 char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
603 int __len = std::__convert_from_v(_S_get_c_locale(), __cs, 0, "%.*Lf",
604 0, __units);
605#endif
606 string_type __digits(__len, char_type());
607 __ctype.widen(__cs, __cs + __len, &__digits[0]);
608 return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
609 : _M_insert<false>(__s, __io, __fill, __digits);
610 }
611
612 template<typename _CharT, typename _OutIter>
616 const string_type& __digits) const
617 { return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
618 : _M_insert<false>(__s, __io, __fill, __digits); }
619
620_GLIBCXX_END_NAMESPACE_LDBL_OR_CXX11
621
622 // NB: Not especially useful. Without an ios_base object or some
623 // kind of locale reference, we are left clawing at the air where
624 // the side of the mountain used to be...
625 template<typename _CharT, typename _InIter>
626 time_base::dateorder
628 { return time_base::no_order; }
629
630 // Expand a strftime format string and parse it. E.g., do_get_date() may
631 // pass %m/%d/%Y => extracted characters.
632 template<typename _CharT, typename _InIter>
633 _InIter
635 _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
636 ios_base::iostate& __err, tm* __tm,
637 const _CharT* __format) const
638 {
639 const locale& __loc = __io._M_getloc();
643
644 ios_base::iostate __tmperr = ios_base::goodbit;
645 size_t __i = 0;
646 for (; __beg != __end && __i < __len && !__tmperr; ++__i)
647 {
648 if (__ctype.narrow(__format[__i], 0) == '%')
649 {
650 // Verify valid formatting code, attempt to extract.
651 char __c = __ctype.narrow(__format[++__i], 0);
652 int __mem = 0;
653 if (__c == 'E' || __c == 'O')
654 __c = __ctype.narrow(__format[++__i], 0);
655 switch (__c)
656 {
657 const char* __cs;
658 _CharT __wcs[10];
659 case 'a':
660 // Abbreviated weekday name [tm_wday]
661 const char_type* __days1[7];
662 __tp._M_days_abbreviated(__days1);
663 __beg = _M_extract_name(__beg, __end, __mem, __days1,
664 7, __io, __tmperr);
665 if (!__tmperr)
666 __tm->tm_wday = __mem;
667 break;
668 case 'A':
669 // Weekday name [tm_wday].
670 const char_type* __days2[7];
671 __tp._M_days(__days2);
672 __beg = _M_extract_name(__beg, __end, __mem, __days2,
673 7, __io, __tmperr);
674 if (!__tmperr)
675 __tm->tm_wday = __mem;
676 break;
677 case 'h':
678 case 'b':
679 // Abbreviated month name [tm_mon]
680 const char_type* __months1[12];
681 __tp._M_months_abbreviated(__months1);
682 __beg = _M_extract_name(__beg, __end, __mem,
683 __months1, 12, __io, __tmperr);
684 if (!__tmperr)
685 __tm->tm_mon = __mem;
686 break;
687 case 'B':
688 // Month name [tm_mon].
689 const char_type* __months2[12];
690 __tp._M_months(__months2);
691 __beg = _M_extract_name(__beg, __end, __mem,
692 __months2, 12, __io, __tmperr);
693 if (!__tmperr)
694 __tm->tm_mon = __mem;
695 break;
696 case 'c':
697 // Default time and date representation.
698 const char_type* __dt[2];
699 __tp._M_date_time_formats(__dt);
700 __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
701 __tm, __dt[0]);
702 break;
703 case 'd':
704 // Day [01, 31]. [tm_mday]
705 __beg = _M_extract_num(__beg, __end, __mem, 1, 31, 2,
706 __io, __tmperr);
707 if (!__tmperr)
708 __tm->tm_mday = __mem;
709 break;
710 case 'e':
711 // Day [1, 31], with single digits preceded by
712 // space. [tm_mday]
713 if (__ctype.is(ctype_base::space, *__beg))
714 __beg = _M_extract_num(++__beg, __end, __mem, 1, 9,
715 1, __io, __tmperr);
716 else
717 __beg = _M_extract_num(__beg, __end, __mem, 10, 31,
718 2, __io, __tmperr);
719 if (!__tmperr)
720 __tm->tm_mday = __mem;
721 break;
722 case 'D':
723 // Equivalent to %m/%d/%y.[tm_mon, tm_mday, tm_year]
724 __cs = "%m/%d/%y";
725 __ctype.widen(__cs, __cs + 9, __wcs);
726 __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
727 __tm, __wcs);
728 break;
729 case 'H':
730 // Hour [00, 23]. [tm_hour]
731 __beg = _M_extract_num(__beg, __end, __mem, 0, 23, 2,
732 __io, __tmperr);
733 if (!__tmperr)
734 __tm->tm_hour = __mem;
735 break;
736 case 'I':
737 // Hour [01, 12]. [tm_hour]
738 __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2,
739 __io, __tmperr);
740 if (!__tmperr)
741 __tm->tm_hour = __mem;
742 break;
743 case 'm':
744 // Month [01, 12]. [tm_mon]
745 __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2,
746 __io, __tmperr);
747 if (!__tmperr)
748 __tm->tm_mon = __mem - 1;
749 break;
750 case 'M':
751 // Minute [00, 59]. [tm_min]
752 __beg = _M_extract_num(__beg, __end, __mem, 0, 59, 2,
753 __io, __tmperr);
754 if (!__tmperr)
755 __tm->tm_min = __mem;
756 break;
757 case 'n':
758 if (__ctype.narrow(*__beg, 0) == '\n')
759 ++__beg;
760 else
762 break;
763 case 'R':
764 // Equivalent to (%H:%M).
765 __cs = "%H:%M";
766 __ctype.widen(__cs, __cs + 6, __wcs);
767 __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
768 __tm, __wcs);
769 break;
770 case 'S':
771 // Seconds. [tm_sec]
772 // [00, 60] in C99 (one leap-second), [00, 61] in C89.
773#if _GLIBCXX_USE_C99
774 __beg = _M_extract_num(__beg, __end, __mem, 0, 60, 2,
775#else
776 __beg = _M_extract_num(__beg, __end, __mem, 0, 61, 2,
777#endif
778 __io, __tmperr);
779 if (!__tmperr)
780 __tm->tm_sec = __mem;
781 break;
782 case 't':
783 if (__ctype.narrow(*__beg, 0) == '\t')
784 ++__beg;
785 else
787 break;
788 case 'T':
789 // Equivalent to (%H:%M:%S).
790 __cs = "%H:%M:%S";
791 __ctype.widen(__cs, __cs + 9, __wcs);
792 __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
793 __tm, __wcs);
794 break;
795 case 'x':
796 // Locale's date.
797 const char_type* __dates[2];
798 __tp._M_date_formats(__dates);
799 __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
800 __tm, __dates[0]);
801 break;
802 case 'X':
803 // Locale's time.
804 const char_type* __times[2];
805 __tp._M_time_formats(__times);
806 __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
807 __tm, __times[0]);
808 break;
809 case 'y':
810 case 'C': // C99
811 // Two digit year.
812 case 'Y':
813 // Year [1900).
814 // NB: We parse either two digits, implicitly years since
815 // 1900, or 4 digits, full year. In both cases we can
816 // reconstruct [tm_year]. See also libstdc++/26701.
817 __beg = _M_extract_num(__beg, __end, __mem, 0, 9999, 4,
818 __io, __tmperr);
819 if (!__tmperr)
820 __tm->tm_year = __mem < 0 ? __mem + 100 : __mem - 1900;
821 break;
822 case 'Z':
823 // Timezone info.
824 if (__ctype.is(ctype_base::upper, *__beg))
825 {
826 int __tmp;
827 __beg = _M_extract_name(__beg, __end, __tmp,
828 __timepunct_cache<_CharT>::_S_timezones,
829 14, __io, __tmperr);
830
831 // GMT requires special effort.
832 if (__beg != __end && !__tmperr && __tmp == 0
833 && (*__beg == __ctype.widen('-')
834 || *__beg == __ctype.widen('+')))
835 {
836 __beg = _M_extract_num(__beg, __end, __tmp, 0, 23, 2,
837 __io, __tmperr);
838 __beg = _M_extract_num(__beg, __end, __tmp, 0, 59, 2,
839 __io, __tmperr);
840 }
841 }
842 else
843 __tmperr |= ios_base::failbit;
844 break;
845 default:
846 // Not recognized.
847 __tmperr |= ios_base::failbit;
848 }
849 }
850 else
851 {
852 // Verify format and input match, extract and discard.
853 if (__format[__i] == *__beg)
854 ++__beg;
855 else
856 __tmperr |= ios_base::failbit;
857 }
858 }
859
860 if (__tmperr || __i != __len)
861 __err |= ios_base::failbit;
862
863 return __beg;
864 }
865
866 template<typename _CharT, typename _InIter>
867 _InIter
868 time_get<_CharT, _InIter>::
869 _M_extract_num(iter_type __beg, iter_type __end, int& __member,
870 int __min, int __max, size_t __len,
871 ios_base& __io, ios_base::iostate& __err) const
872 {
873 const locale& __loc = __io._M_getloc();
874 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
875
876 // As-is works for __len = 1, 2, 4, the values actually used.
877 int __mult = __len == 2 ? 10 : (__len == 4 ? 1000 : 1);
878
879 ++__min;
880 size_t __i = 0;
881 int __value = 0;
882 for (; __beg != __end && __i < __len; ++__beg, (void)++__i)
883 {
884 const char __c = __ctype.narrow(*__beg, '*');
885 if (__c >= '0' && __c <= '9')
886 {
887 __value = __value * 10 + (__c - '0');
888 const int __valuec = __value * __mult;
889 if (__valuec > __max || __valuec + __mult < __min)
890 break;
891 __mult /= 10;
892 }
893 else
894 break;
895 }
896 if (__i == __len)
897 __member = __value;
898 // Special encoding for do_get_year, 'y', and 'Y' above.
899 else if (__len == 4 && __i == 2)
900 __member = __value - 100;
901 else
902 __err |= ios_base::failbit;
903
904 return __beg;
905 }
906
907 // Assumptions:
908 // All elements in __names are unique.
909 template<typename _CharT, typename _InIter>
910 _InIter
911 time_get<_CharT, _InIter>::
912 _M_extract_name(iter_type __beg, iter_type __end, int& __member,
913 const _CharT** __names, size_t __indexlen,
914 ios_base& __io, ios_base::iostate& __err) const
915 {
916 typedef char_traits<_CharT> __traits_type;
917 const locale& __loc = __io._M_getloc();
918 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
919
920 int* __matches = static_cast<int*>(__builtin_alloca(sizeof(int)
921 * __indexlen));
922 size_t __nmatches = 0;
923 size_t __pos = 0;
924 bool __testvalid = true;
925 const char_type* __name;
926
927 // Look for initial matches.
928 // NB: Some of the locale data is in the form of all lowercase
929 // names, and some is in the form of initially-capitalized
930 // names. Look for both.
931 if (__beg != __end)
932 {
933 const char_type __c = *__beg;
934 for (size_t __i1 = 0; __i1 < __indexlen; ++__i1)
935 if (__c == __names[__i1][0]
936 || __c == __ctype.toupper(__names[__i1][0]))
937 __matches[__nmatches++] = __i1;
938 }
939
940 while (__nmatches > 1)
941 {
942 // Find smallest matching string.
943 size_t __minlen = __traits_type::length(__names[__matches[0]]);
944 for (size_t __i2 = 1; __i2 < __nmatches; ++__i2)
945 __minlen = std::min(__minlen,
946 __traits_type::length(__names[__matches[__i2]]));
947 ++__beg;
948 ++__pos;
949 if (__pos < __minlen && __beg != __end)
950 for (size_t __i3 = 0; __i3 < __nmatches;)
951 {
952 __name = __names[__matches[__i3]];
953 if (!(__name[__pos] == *__beg))
954 __matches[__i3] = __matches[--__nmatches];
955 else
956 ++__i3;
957 }
958 else
959 break;
960 }
961
962 if (__nmatches == 1)
963 {
964 // Make sure found name is completely extracted.
965 ++__beg;
966 ++__pos;
967 __name = __names[__matches[0]];
968 const size_t __len = __traits_type::length(__name);
969 while (__pos < __len && __beg != __end && __name[__pos] == *__beg)
970 ++__beg, (void)++__pos;
971
972 if (__len == __pos)
973 __member = __matches[0];
974 else
975 __testvalid = false;
976 }
977 else
978 __testvalid = false;
979 if (!__testvalid)
980 __err |= ios_base::failbit;
981
982 return __beg;
983 }
984
985 template<typename _CharT, typename _InIter>
986 _InIter
987 time_get<_CharT, _InIter>::
988 _M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __member,
989 const _CharT** __names, size_t __indexlen,
990 ios_base& __io, ios_base::iostate& __err) const
991 {
992 typedef char_traits<_CharT> __traits_type;
993 const locale& __loc = __io._M_getloc();
994 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
995
996 int* __matches = static_cast<int*>(__builtin_alloca(2 * sizeof(int)
997 * __indexlen));
998 size_t __nmatches = 0;
999 size_t* __matches_lengths = 0;
1000 size_t __pos = 0;
1001
1002 if (__beg != __end)
1003 {
1004 const char_type __c = *__beg;
1005 for (size_t __i = 0; __i < 2 * __indexlen; ++__i)
1006 if (__c == __names[__i][0]
1007 || __c == __ctype.toupper(__names[__i][0]))
1008 __matches[__nmatches++] = __i;
1009 }
1010
1011 if (__nmatches)
1012 {
1013 ++__beg;
1014 ++__pos;
1015
1016 __matches_lengths
1017 = static_cast<size_t*>(__builtin_alloca(sizeof(size_t)
1018 * __nmatches));
1019 for (size_t __i = 0; __i < __nmatches; ++__i)
1020 __matches_lengths[__i]
1021 = __traits_type::length(__names[__matches[__i]]);
1022 }
1023
1024 for (; __beg != __end; ++__beg, (void)++__pos)
1025 {
1026 size_t __nskipped = 0;
1027 const char_type __c = *__beg;
1028 for (size_t __i = 0; __i < __nmatches;)
1029 {
1030 const char_type* __name = __names[__matches[__i]];
1031 if (__pos >= __matches_lengths[__i])
1032 ++__nskipped, ++__i;
1033 else if (!(__name[__pos] == __c))
1034 {
1035 --__nmatches;
1036 __matches[__i] = __matches[__nmatches];
1037 __matches_lengths[__i] = __matches_lengths[__nmatches];
1038 }
1039 else
1040 ++__i;
1041 }
1042 if (__nskipped == __nmatches)
1043 break;
1044 }
1045
1046 if ((__nmatches == 1 && __matches_lengths[0] == __pos)
1047 || (__nmatches == 2 && (__matches_lengths[0] == __pos
1048 || __matches_lengths[1] == __pos)))
1049 __member = (__matches[0] >= (int)__indexlen
1050 ? __matches[0] - (int)__indexlen : __matches[0]);
1051 else
1052 __err |= ios_base::failbit;
1053
1054 return __beg;
1055 }
1056
1057 template<typename _CharT, typename _InIter>
1058 _InIter
1061 ios_base::iostate& __err, tm* __tm) const
1062 {
1063 const locale& __loc = __io._M_getloc();
1065 const char_type* __times[2];
1066 __tp._M_time_formats(__times);
1067 __beg = _M_extract_via_format(__beg, __end, __io, __err,
1068 __tm, __times[0]);
1069 if (__beg == __end)
1071 return __beg;
1072 }
1073
1074 template<typename _CharT, typename _InIter>
1075 _InIter
1078 ios_base::iostate& __err, tm* __tm) const
1079 {
1080 const locale& __loc = __io._M_getloc();
1082 const char_type* __dates[2];
1083 __tp._M_date_formats(__dates);
1084 __beg = _M_extract_via_format(__beg, __end, __io, __err,
1085 __tm, __dates[0]);
1086 if (__beg == __end)
1088 return __beg;
1089 }
1090
1091 template<typename _CharT, typename _InIter>
1092 _InIter
1095 ios_base::iostate& __err, tm* __tm) const
1096 {
1097 const locale& __loc = __io._M_getloc();
1099 const char_type* __days[14];
1100 __tp._M_days_abbreviated(__days);
1101 __tp._M_days(__days + 7);
1102 int __tmpwday;
1103 ios_base::iostate __tmperr = ios_base::goodbit;
1104
1105 __beg = _M_extract_wday_or_month(__beg, __end, __tmpwday, __days, 7,
1106 __io, __tmperr);
1107 if (!__tmperr)
1108 __tm->tm_wday = __tmpwday;
1109 else
1111
1112 if (__beg == __end)
1114 return __beg;
1115 }
1116
1117 template<typename _CharT, typename _InIter>
1118 _InIter
1121 ios_base& __io, ios_base::iostate& __err, tm* __tm) const
1122 {
1123 const locale& __loc = __io._M_getloc();
1125 const char_type* __months[24];
1126 __tp._M_months_abbreviated(__months);
1127 __tp._M_months(__months + 12);
1128 int __tmpmon;
1129 ios_base::iostate __tmperr = ios_base::goodbit;
1130
1131 __beg = _M_extract_wday_or_month(__beg, __end, __tmpmon, __months, 12,
1132 __io, __tmperr);
1133 if (!__tmperr)
1134 __tm->tm_mon = __tmpmon;
1135 else
1137
1138 if (__beg == __end)
1140 return __beg;
1141 }
1142
1143 template<typename _CharT, typename _InIter>
1144 _InIter
1147 ios_base::iostate& __err, tm* __tm) const
1148 {
1149 int __tmpyear;
1150 ios_base::iostate __tmperr = ios_base::goodbit;
1151
1152 __beg = _M_extract_num(__beg, __end, __tmpyear, 0, 9999, 4,
1153 __io, __tmperr);
1154 if (!__tmperr)
1155 __tm->tm_year = __tmpyear < 0 ? __tmpyear + 100 : __tmpyear - 1900;
1156 else
1158
1159 if (__beg == __end)
1161 return __beg;
1162 }
1163
1164#if __cplusplus >= 201103L
1165 template<typename _CharT, typename _InIter>
1166 inline
1167 _InIter
1170 ios_base::iostate& __err, tm* __tm, const char_type* __fmt,
1171 const char_type* __fmtend) const
1172 {
1173 const locale& __loc = __io._M_getloc();
1176 while (__fmt != __fmtend &&
1178 {
1179 if (__s == __end)
1180 {
1182 break;
1183 }
1184 else if (__ctype.narrow(*__fmt, 0) == '%')
1185 {
1186 char __format;
1187 char __mod = 0;
1188 if (++__fmt == __fmtend)
1189 {
1191 break;
1192 }
1193 const char __c = __ctype.narrow(*__fmt, 0);
1194 if (__c != 'E' && __c != 'O')
1195 __format = __c;
1196 else if (++__fmt != __fmtend)
1197 {
1198 __mod = __c;
1199 __format = __ctype.narrow(*__fmt, 0);
1200 }
1201 else
1202 {
1204 break;
1205 }
1206 __s = this->do_get(__s, __end, __io, __err, __tm, __format,
1207 __mod);
1208 ++__fmt;
1209 }
1210 else if (__ctype.is(ctype_base::space, *__fmt))
1211 {
1212 ++__fmt;
1213 while (__fmt != __fmtend &&
1214 __ctype.is(ctype_base::space, *__fmt))
1215 ++__fmt;
1216
1217 while (__s != __end &&
1218 __ctype.is(ctype_base::space, *__s))
1219 ++__s;
1220 }
1221 // TODO real case-insensitive comparison
1222 else if (__ctype.tolower(*__s) == __ctype.tolower(*__fmt) ||
1223 __ctype.toupper(*__s) == __ctype.toupper(*__fmt))
1224 {
1225 ++__s;
1226 ++__fmt;
1227 }
1228 else
1229 {
1231 break;
1232 }
1233 }
1234 return __s;
1235 }
1236
1237 template<typename _CharT, typename _InIter>
1238 inline
1239 _InIter
1242 ios_base::iostate& __err, tm* __tm,
1243 char __format, char __mod) const
1244 {
1245 const locale& __loc = __io._M_getloc();
1248
1249 char_type __fmt[4];
1250 __fmt[0] = __ctype.widen('%');
1251 if (!__mod)
1252 {
1253 __fmt[1] = __format;
1254 __fmt[2] = char_type();
1255 }
1256 else
1257 {
1258 __fmt[1] = __mod;
1259 __fmt[2] = __format;
1260 __fmt[3] = char_type();
1261 }
1262
1263 __beg = _M_extract_via_format(__beg, __end, __io, __err, __tm, __fmt);
1264 if (__beg == __end)
1266 return __beg;
1267 }
1268
1269#endif // __cplusplus >= 201103L
1270
1271 template<typename _CharT, typename _OutIter>
1272 _OutIter
1274 put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
1275 const _CharT* __beg, const _CharT* __end) const
1276 {
1277 const locale& __loc = __io._M_getloc();
1279 for (; __beg != __end; ++__beg)
1280 if (__ctype.narrow(*__beg, 0) != '%')
1281 {
1282 *__s = *__beg;
1283 ++__s;
1284 }
1285 else if (++__beg != __end)
1286 {
1287 char __format;
1288 char __mod = 0;
1289 const char __c = __ctype.narrow(*__beg, 0);
1290 if (__c != 'E' && __c != 'O')
1291 __format = __c;
1292 else if (++__beg != __end)
1293 {
1294 __mod = __c;
1295 __format = __ctype.narrow(*__beg, 0);
1296 }
1297 else
1298 break;
1299 __s = this->do_put(__s, __io, __fill, __tm, __format, __mod);
1300 }
1301 else
1302 break;
1303 return __s;
1304 }
1305
1306 template<typename _CharT, typename _OutIter>
1307 _OutIter
1310 char __format, char __mod) const
1311 {
1312 const locale& __loc = __io._M_getloc();
1315
1316 // NB: This size is arbitrary. Should this be a data member,
1317 // initialized at construction?
1318 const size_t __maxlen = 128;
1320
1321 // NB: In IEE 1003.1-200x, and perhaps other locale models, it
1322 // is possible that the format character will be longer than one
1323 // character. Possibilities include 'E' or 'O' followed by a
1324 // format character: if __mod is not the default argument, assume
1325 // it's a valid modifier.
1326 char_type __fmt[4];
1327 __fmt[0] = __ctype.widen('%');
1328 if (!__mod)
1329 {
1330 __fmt[1] = __format;
1331 __fmt[2] = char_type();
1332 }
1333 else
1334 {
1335 __fmt[1] = __mod;
1336 __fmt[2] = __format;
1337 __fmt[3] = char_type();
1338 }
1339
1340 __tp._M_put(__res, __maxlen, __fmt, __tm);
1341
1342 // Write resulting, fully-formatted string to output iterator.
1343 return std::__write(__s, __res, char_traits<char_type>::length(__res));
1344 }
1345
1346
1347 // Inhibit implicit instantiations for required instantiations,
1348 // which are defined via explicit instantiations elsewhere.
1349#if _GLIBCXX_EXTERN_TEMPLATE
1350 extern template class moneypunct<char, false>;
1351 extern template class moneypunct<char, true>;
1352 extern template class moneypunct_byname<char, false>;
1353 extern template class moneypunct_byname<char, true>;
1354 extern template class _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 money_get<char>;
1355 extern template class _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 money_put<char>;
1356 extern template class __timepunct<char>;
1357 extern template class time_put<char>;
1358 extern template class time_put_byname<char>;
1359 extern template class time_get<char>;
1360 extern template class time_get_byname<char>;
1361 extern template class messages<char>;
1362 extern template class messages_byname<char>;
1363
1364 extern template
1367
1368 extern template
1371
1372 extern template
1373 const money_put<char>&
1375
1376 extern template
1377 const money_get<char>&
1379
1380 extern template
1381 const __timepunct<char>&
1383
1384 extern template
1385 const time_put<char>&
1387
1388 extern template
1389 const time_get<char>&
1391
1392 extern template
1393 const messages<char>&
1395
1396 extern template
1397 bool
1399
1400 extern template
1401 bool
1403
1404 extern template
1405 bool
1407
1408 extern template
1409 bool
1411
1412 extern template
1413 bool
1415
1416 extern template
1417 bool
1419
1420 extern template
1421 bool
1423
1424#ifdef _GLIBCXX_USE_WCHAR_T
1425 extern template class moneypunct<wchar_t, false>;
1426 extern template class moneypunct<wchar_t, true>;
1427 extern template class moneypunct_byname<wchar_t, false>;
1428 extern template class moneypunct_byname<wchar_t, true>;
1429 extern template class _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 money_get<wchar_t>;
1430 extern template class _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 money_put<wchar_t>;
1431 extern template class __timepunct<wchar_t>;
1432 extern template class time_put<wchar_t>;
1433 extern template class time_put_byname<wchar_t>;
1434 extern template class time_get<wchar_t>;
1435 extern template class time_get_byname<wchar_t>;
1436 extern template class messages<wchar_t>;
1437 extern template class messages_byname<wchar_t>;
1438
1439 extern template
1442
1443 extern template
1446
1447 extern template
1448 const money_put<wchar_t>&
1450
1451 extern template
1452 const money_get<wchar_t>&
1454
1455 extern template
1458
1459 extern template
1460 const time_put<wchar_t>&
1462
1463 extern template
1464 const time_get<wchar_t>&
1466
1467 extern template
1468 const messages<wchar_t>&
1470
1471 extern template
1472 bool
1474
1475 extern template
1476 bool
1478
1479 extern template
1480 bool
1482
1483 extern template
1484 bool
1486
1487 extern template
1488 bool
1490
1491 extern template
1492 bool
1494
1495 extern template
1496 bool
1498#endif
1499#endif
1500
1501_GLIBCXX_END_NAMESPACE_VERSION
1502} // namespace std
1503
1504#endif
constexpr const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
ISO C++ entities toplevel namespace is std.
void resize(size_type __n, _CharT __c)
Resizes the string to the specified number of characters.
static const size_type npos
Value returned by various member functions when they fail.
Basis for explicit traits specializations.
The base of the I/O class hierarchy.
Definition ios_base.h:229
_Ios_Fmtflags fmtflags
This is a bitmask type.
Definition ios_base.h:341
_Ios_Iostate iostate
This is a bitmask type.
Definition ios_base.h:416
static const fmtflags showbase
Generates a prefix indicating the numeric base of generated integer output.
Definition ios_base.h:376
static const fmtflags internal
Adds fill characters at a designated internal point in certain generated output, or identical to righ...
Definition ios_base.h:358
fmtflags flags() const
Access to format flags.
Definition ios_base.h:649
static const iostate eofbit
Indicates that an input operation reached the end of an input sequence.
Definition ios_base.h:423
static const iostate goodbit
Indicates all is well.
Definition ios_base.h:431
streamsize width() const
Flags access.
Definition ios_base.h:742
static const fmtflags left
Adds fill characters on the right (final positions) of certain generated output. (I....
Definition ios_base.h:362
static const iostate failbit
Indicates that an input operation failed to read the expected characters, or that an output operation...
Definition ios_base.h:428
static const fmtflags adjustfield
A mask of left|right|internal. Useful for the 2-arg form of setf.
Definition ios_base.h:396
Container class for localization functionality.
Primary class template time_get.
virtual iter_type do_get_year(iter_type __beg, iter_type __end, ios_base &__io, ios_base::iostate &__err, tm *__tm) const
Parse input year string.
_InIter iter_type
Public typedefs.
virtual iter_type do_get_weekday(iter_type __beg, iter_type __end, ios_base &, ios_base::iostate &__err, tm *__tm) const
Parse input weekday string.
virtual iter_type do_get_monthname(iter_type __beg, iter_type __end, ios_base &, ios_base::iostate &__err, tm *__tm) const
Parse input month string.
_CharT char_type
Public typedefs.
iter_type do_get(iter_type __s, iter_type __end, ios_base &__f, ios_base::iostate &__err, tm *__tm, char __format, char __modifier) const
Parse input string according to format.
iter_type get(iter_type __s, iter_type __end, ios_base &__io, ios_base::iostate &__err, tm *__tm, char __format, char __modifier=0) const
Parse input string according to format.
virtual dateorder do_date_order() const
Return preferred order of month, day, and year.
virtual iter_type do_get_date(iter_type __beg, iter_type __end, ios_base &__io, ios_base::iostate &__err, tm *__tm) const
Parse input date string.
virtual iter_type do_get_time(iter_type __beg, iter_type __end, ios_base &__io, ios_base::iostate &__err, tm *__tm) const
Parse input time string.
virtual iter_type do_put(iter_type __s, ios_base &__io, char_type __fill, const tm *__tm, char __format, char __mod) const
Format and output a time or date.
_CharT char_type
Public typedefs.
iter_type put(iter_type __s, ios_base &__io, char_type __fill, const tm *__tm, const _CharT *__beg, const _CharT *__end) const
Format and output a time or date.
_OutIter iter_type
Public typedefs.
static locale::id id
Numpunct facet id.
virtual iter_type do_get(iter_type __s, iter_type __end, bool __intl, ios_base &__io, ios_base::iostate &__err, long double &__units) const
Read and parse a monetary value.
_InIter iter_type
Public typedefs.
Primary class template money_put.
virtual iter_type do_put(iter_type __s, bool __intl, ios_base &__io, char_type __fill, long double __units) const
Format and output a monetary value.
_OutIter iter_type
Public typedefs.
_CharT char_type
Public typedefs.