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 
35 namespace 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
371  do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
372  ios_base::iostate& __err, long double& __units) const
373  {
374  string __str;
375  __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
376  : _M_extract<false>(__beg, __end, __io, __err, __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
384  do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
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();
390  const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
391 
392  string __str;
393  __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
394  : _M_extract<false>(__beg, __end, __io, __err, __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>
406  _OutIter
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();
416  const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
417 
418  __use_cache<__cache_type> __uc;
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
577  do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
578  long double __units) const
579  {
580  const locale __loc = __io.getloc();
581  const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
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>
613  _OutIter
615  do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
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();
640  const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
641  const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
642  const size_t __len = char_traits<_CharT>::length(__format);
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
761  __tmperr |= ios_base::failbit;
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
786  __tmperr |= ios_base::failbit;
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
1060  do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
1061  ios_base::iostate& __err, tm* __tm) const
1062  {
1063  const locale& __loc = __io._M_getloc();
1064  const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
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)
1070  __err |= ios_base::eofbit;
1071  return __beg;
1072  }
1073 
1074  template<typename _CharT, typename _InIter>
1075  _InIter
1077  do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
1078  ios_base::iostate& __err, tm* __tm) const
1079  {
1080  const locale& __loc = __io._M_getloc();
1081  const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
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)
1087  __err |= ios_base::eofbit;
1088  return __beg;
1089  }
1090 
1091  template<typename _CharT, typename _InIter>
1092  _InIter
1094  do_get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
1095  ios_base::iostate& __err, tm* __tm) const
1096  {
1097  const locale& __loc = __io._M_getloc();
1098  const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
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
1110  __err |= ios_base::failbit;
1111 
1112  if (__beg == __end)
1113  __err |= ios_base::eofbit;
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();
1124  const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
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
1136  __err |= ios_base::failbit;
1137 
1138  if (__beg == __end)
1139  __err |= ios_base::eofbit;
1140  return __beg;
1141  }
1142 
1143  template<typename _CharT, typename _InIter>
1144  _InIter
1146  do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
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
1157  __err |= ios_base::failbit;
1158 
1159  if (__beg == __end)
1160  __err |= ios_base::eofbit;
1161  return __beg;
1162  }
1163 
1164 #if __cplusplus >= 201103L
1165  template<typename _CharT, typename _InIter>
1166  inline
1167  _InIter
1169  get(iter_type __s, iter_type __end, ios_base& __io,
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();
1174  ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
1175  __err = ios_base::goodbit;
1176  while (__fmt != __fmtend &&
1177  __err == ios_base::goodbit)
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  {
1190  __err = ios_base::failbit;
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  {
1203  __err = ios_base::failbit;
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  {
1230  __err = ios_base::failbit;
1231  break;
1232  }
1233  }
1234  return __s;
1235  }
1236 
1237  template<typename _CharT, typename _InIter>
1238  inline
1239  _InIter
1241  do_get(iter_type __beg, iter_type __end, ios_base& __io,
1242  ios_base::iostate& __err, tm* __tm,
1243  char __format, char __mod) const
1244  {
1245  const locale& __loc = __io._M_getloc();
1246  ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
1247  __err = ios_base::goodbit;
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)
1265  __err |= ios_base::eofbit;
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();
1278  ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
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
1309  do_put(iter_type __s, ios_base& __io, char_type, const tm* __tm,
1310  char __format, char __mod) const
1311  {
1312  const locale& __loc = __io._M_getloc();
1313  ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
1314  __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
1315 
1316  // NB: This size is arbitrary. Should this be a data member,
1317  // initialized at construction?
1318  const size_t __maxlen = 128;
1319  char_type __res[__maxlen];
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
1365  const moneypunct<char, true>&
1366  use_facet<moneypunct<char, true> >(const locale&);
1367 
1368  extern template
1370  use_facet<moneypunct<char, false> >(const locale&);
1371 
1372  extern template
1373  const money_put<char>&
1374  use_facet<money_put<char> >(const locale&);
1375 
1376  extern template
1377  const money_get<char>&
1378  use_facet<money_get<char> >(const locale&);
1379 
1380  extern template
1381  const __timepunct<char>&
1382  use_facet<__timepunct<char> >(const locale&);
1383 
1384  extern template
1385  const time_put<char>&
1386  use_facet<time_put<char> >(const locale&);
1387 
1388  extern template
1389  const time_get<char>&
1390  use_facet<time_get<char> >(const locale&);
1391 
1392  extern template
1393  const messages<char>&
1394  use_facet<messages<char> >(const locale&);
1395 
1396  extern template
1397  bool
1398  has_facet<moneypunct<char> >(const locale&);
1399 
1400  extern template
1401  bool
1402  has_facet<money_put<char> >(const locale&);
1403 
1404  extern template
1405  bool
1406  has_facet<money_get<char> >(const locale&);
1407 
1408  extern template
1409  bool
1410  has_facet<__timepunct<char> >(const locale&);
1411 
1412  extern template
1413  bool
1414  has_facet<time_put<char> >(const locale&);
1415 
1416  extern template
1417  bool
1418  has_facet<time_get<char> >(const locale&);
1419 
1420  extern template
1421  bool
1422  has_facet<messages<char> >(const locale&);
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
1441  use_facet<moneypunct<wchar_t, true> >(const locale&);
1442 
1443  extern template
1445  use_facet<moneypunct<wchar_t, false> >(const locale&);
1446 
1447  extern template
1448  const money_put<wchar_t>&
1449  use_facet<money_put<wchar_t> >(const locale&);
1450 
1451  extern template
1452  const money_get<wchar_t>&
1453  use_facet<money_get<wchar_t> >(const locale&);
1454 
1455  extern template
1456  const __timepunct<wchar_t>&
1457  use_facet<__timepunct<wchar_t> >(const locale&);
1458 
1459  extern template
1460  const time_put<wchar_t>&
1461  use_facet<time_put<wchar_t> >(const locale&);
1462 
1463  extern template
1464  const time_get<wchar_t>&
1465  use_facet<time_get<wchar_t> >(const locale&);
1466 
1467  extern template
1468  const messages<wchar_t>&
1469  use_facet<messages<wchar_t> >(const locale&);
1470 
1471  extern template
1472  bool
1473  has_facet<moneypunct<wchar_t> >(const locale&);
1474 
1475  extern template
1476  bool
1477  has_facet<money_put<wchar_t> >(const locale&);
1478 
1479  extern template
1480  bool
1481  has_facet<money_get<wchar_t> >(const locale&);
1482 
1483  extern template
1484  bool
1485  has_facet<__timepunct<wchar_t> >(const locale&);
1486 
1487  extern template
1488  bool
1489  has_facet<time_put<wchar_t> >(const locale&);
1490 
1491  extern template
1492  bool
1493  has_facet<time_get<wchar_t> >(const locale&);
1494 
1495  extern template
1496  bool
1497  has_facet<messages<wchar_t> >(const locale&);
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.
Definition: stl_algobase.h:230
ISO C++ entities toplevel namespace is std.
const _CharT * c_str() const noexcept
Return const pointer to null-terminated contents.
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.
Definition: char_traits.h:339
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
const locale & _M_getloc() const
Locale access.
Definition: ios_base.h:804
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
locale getloc() const
Locale access.
Definition: ios_base.h:793
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.
const char_type * scan_not(mask __m, const char_type *__lo, const char_type *__hi) const
Find char_type not matching a mask.
char_type tolower(char_type __c) const
Convert to lowercase.
char_type toupper(char_type __c) const
Convert to uppercase.
char_type widen(char __c) const
Widen char to char_type.
char narrow(char_type __c, char __dfault) const
Narrow char_type to char.
bool is(mask __m, char_type __c) const
Test char_type classification.
Primary class template ctype facet.
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.
class time_get_byname [22.2.5.2].
Primary class template time_put.
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.
class time_put_byname [22.2.5.4].
Primary class template moneypunct.
static locale::id id
Numpunct facet id.
class moneypunct_byname [22.2.6.4].
Primary class template money_get.
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.
Primary class template messages.
class messages_byname [22.2.7.2].