libstdc++
locale_facets_nonio.tcc
Go to the documentation of this file.
1 // Locale support -*- C++ -*-
2 
3 // Copyright (C) 2007-2016 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  case money_base::none:
286  // Only if not at the end of the pattern.
287  if (__i != 3)
288  for (; __beg != __end
289  && __ctype.is(ctype_base::space, *__beg); ++__beg);
290  break;
291  }
292  }
293 
294  // Need to get the rest of the sign characters, if they exist.
295  if (__sign_size > 1 && __testvalid)
296  {
297  const char_type* __sign = __negative ? __lc->_M_negative_sign
298  : __lc->_M_positive_sign;
299  size_type __i = 1;
300  for (; __beg != __end && __i < __sign_size
301  && *__beg == __sign[__i]; ++__beg, (void)++__i);
302 
303  if (__i != __sign_size)
304  __testvalid = false;
305  }
306 
307  if (__testvalid)
308  {
309  // Strip leading zeros.
310  if (__res.size() > 1)
311  {
312  const size_type __first = __res.find_first_not_of('0');
313  const bool __only_zeros = __first == string::npos;
314  if (__first)
315  __res.erase(0, __only_zeros ? __res.size() - 1 : __first);
316  }
317 
318  // 22.2.6.1.2, p4
319  if (__negative && __res[0] != '0')
320  __res.insert(__res.begin(), '-');
321 
322  // Test for grouping fidelity.
323  if (__grouping_tmp.size())
324  {
325  // Add the ending grouping.
326  __grouping_tmp += static_cast<char>(__testdecfound ? __last_pos
327  : __n);
328  if (!std::__verify_grouping(__lc->_M_grouping,
329  __lc->_M_grouping_size,
330  __grouping_tmp))
331  __err |= ios_base::failbit;
332  }
333 
334  // Iff not enough digits were supplied after the decimal-point.
335  if (__testdecfound && __n != __lc->_M_frac_digits)
336  __testvalid = false;
337  }
338 
339  // Iff valid sequence is not recognized.
340  if (!__testvalid)
341  __err |= ios_base::failbit;
342  else
343  __units.swap(__res);
344 
345  // Iff no more characters are available.
346  if (__beg == __end)
347  __err |= ios_base::eofbit;
348  return __beg;
349  }
350 
351 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ \
352  && _GLIBCXX_USE_CXX11_ABI == 0
353  template<typename _CharT, typename _InIter>
354  _InIter
355  money_get<_CharT, _InIter>::
356  __do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
357  ios_base::iostate& __err, double& __units) const
358  {
359  string __str;
360  __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
361  : _M_extract<false>(__beg, __end, __io, __err, __str);
362  std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
363  return __beg;
364  }
365 #endif
366 
367  template<typename _CharT, typename _InIter>
368  _InIter
370  do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
371  ios_base::iostate& __err, long double& __units) const
372  {
373  string __str;
374  __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
375  : _M_extract<false>(__beg, __end, __io, __err, __str);
376  std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
377  return __beg;
378  }
379 
380  template<typename _CharT, typename _InIter>
381  _InIter
383  do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
384  ios_base::iostate& __err, string_type& __digits) const
385  {
386  typedef typename string::size_type size_type;
387 
388  const locale& __loc = __io._M_getloc();
389  const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
390 
391  string __str;
392  __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
393  : _M_extract<false>(__beg, __end, __io, __err, __str);
394  const size_type __len = __str.size();
395  if (__len)
396  {
397  __digits.resize(__len);
398  __ctype.widen(__str.data(), __str.data() + __len, &__digits[0]);
399  }
400  return __beg;
401  }
402 
403  template<typename _CharT, typename _OutIter>
404  template<bool _Intl>
405  _OutIter
407  _M_insert(iter_type __s, ios_base& __io, char_type __fill,
408  const string_type& __digits) const
409  {
410  typedef typename string_type::size_type size_type;
411  typedef money_base::part part;
412  typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
413 
414  const locale& __loc = __io._M_getloc();
415  const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
416 
417  __use_cache<__cache_type> __uc;
418  const __cache_type* __lc = __uc(__loc);
419  const char_type* __lit = __lc->_M_atoms;
420 
421  // Determine if negative or positive formats are to be used, and
422  // discard leading negative_sign if it is present.
423  const char_type* __beg = __digits.data();
424 
425  money_base::pattern __p;
426  const char_type* __sign;
427  size_type __sign_size;
428  if (!(*__beg == __lit[money_base::_S_minus]))
429  {
430  __p = __lc->_M_pos_format;
431  __sign = __lc->_M_positive_sign;
432  __sign_size = __lc->_M_positive_sign_size;
433  }
434  else
435  {
436  __p = __lc->_M_neg_format;
437  __sign = __lc->_M_negative_sign;
438  __sign_size = __lc->_M_negative_sign_size;
439  if (__digits.size())
440  ++__beg;
441  }
442 
443  // Look for valid numbers in the ctype facet within input digits.
444  size_type __len = __ctype.scan_not(ctype_base::digit, __beg,
445  __beg + __digits.size()) - __beg;
446  if (__len)
447  {
448  // Assume valid input, and attempt to format.
449  // Break down input numbers into base components, as follows:
450  // final_value = grouped units + (decimal point) + (digits)
451  string_type __value;
452  __value.reserve(2 * __len);
453 
454  // Add thousands separators to non-decimal digits, per
455  // grouping rules.
456  long __paddec = __len - __lc->_M_frac_digits;
457  if (__paddec > 0)
458  {
459  if (__lc->_M_frac_digits < 0)
460  __paddec = __len;
461  if (__lc->_M_grouping_size)
462  {
463  __value.assign(2 * __paddec, char_type());
464  _CharT* __vend =
465  std::__add_grouping(&__value[0], __lc->_M_thousands_sep,
466  __lc->_M_grouping,
467  __lc->_M_grouping_size,
468  __beg, __beg + __paddec);
469  __value.erase(__vend - &__value[0]);
470  }
471  else
472  __value.assign(__beg, __paddec);
473  }
474 
475  // Deal with decimal point, decimal digits.
476  if (__lc->_M_frac_digits > 0)
477  {
478  __value += __lc->_M_decimal_point;
479  if (__paddec >= 0)
480  __value.append(__beg + __paddec, __lc->_M_frac_digits);
481  else
482  {
483  // Have to pad zeros in the decimal position.
484  __value.append(-__paddec, __lit[money_base::_S_zero]);
485  __value.append(__beg, __len);
486  }
487  }
488 
489  // Calculate length of resulting string.
490  const ios_base::fmtflags __f = __io.flags()
492  __len = __value.size() + __sign_size;
493  __len += ((__io.flags() & ios_base::showbase)
494  ? __lc->_M_curr_symbol_size : 0);
495 
496  string_type __res;
497  __res.reserve(2 * __len);
498 
499  const size_type __width = static_cast<size_type>(__io.width());
500  const bool __testipad = (__f == ios_base::internal
501  && __len < __width);
502  // Fit formatted digits into the required pattern.
503  for (int __i = 0; __i < 4; ++__i)
504  {
505  const part __which = static_cast<part>(__p.field[__i]);
506  switch (__which)
507  {
508  case money_base::symbol:
509  if (__io.flags() & ios_base::showbase)
510  __res.append(__lc->_M_curr_symbol,
511  __lc->_M_curr_symbol_size);
512  break;
513  case money_base::sign:
514  // Sign might not exist, or be more than one
515  // character long. In that case, add in the rest
516  // below.
517  if (__sign_size)
518  __res += __sign[0];
519  break;
520  case money_base::value:
521  __res += __value;
522  break;
523  case money_base::space:
524  // At least one space is required, but if internal
525  // formatting is required, an arbitrary number of
526  // fill spaces will be necessary.
527  if (__testipad)
528  __res.append(__width - __len, __fill);
529  else
530  __res += __fill;
531  break;
532  case money_base::none:
533  if (__testipad)
534  __res.append(__width - __len, __fill);
535  break;
536  }
537  }
538 
539  // Special case of multi-part sign parts.
540  if (__sign_size > 1)
541  __res.append(__sign + 1, __sign_size - 1);
542 
543  // Pad, if still necessary.
544  __len = __res.size();
545  if (__width > __len)
546  {
547  if (__f == ios_base::left)
548  // After.
549  __res.append(__width - __len, __fill);
550  else
551  // Before.
552  __res.insert(0, __width - __len, __fill);
553  __len = __width;
554  }
555 
556  // Write resulting, fully-formatted string to output iterator.
557  __s = std::__write(__s, __res.data(), __len);
558  }
559  __io.width(0);
560  return __s;
561  }
562 
563 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ \
564  && _GLIBCXX_USE_CXX11_ABI == 0
565  template<typename _CharT, typename _OutIter>
566  _OutIter
567  money_put<_CharT, _OutIter>::
568  __do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
569  double __units) const
570  { return this->do_put(__s, __intl, __io, __fill, (long double) __units); }
571 #endif
572 
573  template<typename _CharT, typename _OutIter>
574  _OutIter
576  do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
577  long double __units) const
578  {
579  const locale __loc = __io.getloc();
580  const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
581 #if _GLIBCXX_USE_C99_STDIO
582  // First try a buffer perhaps big enough.
583  int __cs_size = 64;
584  char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
585  // _GLIBCXX_RESOLVE_LIB_DEFECTS
586  // 328. Bad sprintf format modifier in money_put<>::do_put()
587  int __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
588  "%.*Lf", 0, __units);
589  // If the buffer was not large enough, try again with the correct size.
590  if (__len >= __cs_size)
591  {
592  __cs_size = __len + 1;
593  __cs = static_cast<char*>(__builtin_alloca(__cs_size));
594  __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
595  "%.*Lf", 0, __units);
596  }
597 #else
598  // max_exponent10 + 1 for the integer part, + 2 for sign and '\0'.
599  const int __cs_size =
600  __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 3;
601  char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
602  int __len = std::__convert_from_v(_S_get_c_locale(), __cs, 0, "%.*Lf",
603  0, __units);
604 #endif
605  string_type __digits(__len, char_type());
606  __ctype.widen(__cs, __cs + __len, &__digits[0]);
607  return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
608  : _M_insert<false>(__s, __io, __fill, __digits);
609  }
610 
611  template<typename _CharT, typename _OutIter>
612  _OutIter
614  do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
615  const string_type& __digits) const
616  { return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
617  : _M_insert<false>(__s, __io, __fill, __digits); }
618 
619 _GLIBCXX_END_NAMESPACE_LDBL_OR_CXX11
620 
621  // NB: Not especially useful. Without an ios_base object or some
622  // kind of locale reference, we are left clawing at the air where
623  // the side of the mountain used to be...
624  template<typename _CharT, typename _InIter>
625  time_base::dateorder
627  { return time_base::no_order; }
628 
629  // Expand a strftime format string and parse it. E.g., do_get_date() may
630  // pass %m/%d/%Y => extracted characters.
631  template<typename _CharT, typename _InIter>
632  _InIter
634  _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
635  ios_base::iostate& __err, tm* __tm,
636  const _CharT* __format) const
637  {
638  const locale& __loc = __io._M_getloc();
639  const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
640  const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
641  const size_t __len = char_traits<_CharT>::length(__format);
642 
643  ios_base::iostate __tmperr = ios_base::goodbit;
644  size_t __i = 0;
645  for (; __beg != __end && __i < __len && !__tmperr; ++__i)
646  {
647  if (__ctype.narrow(__format[__i], 0) == '%')
648  {
649  // Verify valid formatting code, attempt to extract.
650  char __c = __ctype.narrow(__format[++__i], 0);
651  int __mem = 0;
652  if (__c == 'E' || __c == 'O')
653  __c = __ctype.narrow(__format[++__i], 0);
654  switch (__c)
655  {
656  const char* __cs;
657  _CharT __wcs[10];
658  case 'a':
659  // Abbreviated weekday name [tm_wday]
660  const char_type* __days1[7];
661  __tp._M_days_abbreviated(__days1);
662  __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days1,
663  7, __io, __tmperr);
664  break;
665  case 'A':
666  // Weekday name [tm_wday].
667  const char_type* __days2[7];
668  __tp._M_days(__days2);
669  __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days2,
670  7, __io, __tmperr);
671  break;
672  case 'h':
673  case 'b':
674  // Abbreviated month name [tm_mon]
675  const char_type* __months1[12];
676  __tp._M_months_abbreviated(__months1);
677  __beg = _M_extract_name(__beg, __end, __tm->tm_mon,
678  __months1, 12, __io, __tmperr);
679  break;
680  case 'B':
681  // Month name [tm_mon].
682  const char_type* __months2[12];
683  __tp._M_months(__months2);
684  __beg = _M_extract_name(__beg, __end, __tm->tm_mon,
685  __months2, 12, __io, __tmperr);
686  break;
687  case 'c':
688  // Default time and date representation.
689  const char_type* __dt[2];
690  __tp._M_date_time_formats(__dt);
691  __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
692  __tm, __dt[0]);
693  break;
694  case 'd':
695  // Day [01, 31]. [tm_mday]
696  __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 1, 31, 2,
697  __io, __tmperr);
698  break;
699  case 'e':
700  // Day [1, 31], with single digits preceded by
701  // space. [tm_mday]
702  if (__ctype.is(ctype_base::space, *__beg))
703  __beg = _M_extract_num(++__beg, __end, __tm->tm_mday, 1, 9,
704  1, __io, __tmperr);
705  else
706  __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 10, 31,
707  2, __io, __tmperr);
708  break;
709  case 'D':
710  // Equivalent to %m/%d/%y.[tm_mon, tm_mday, tm_year]
711  __cs = "%m/%d/%y";
712  __ctype.widen(__cs, __cs + 9, __wcs);
713  __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
714  __tm, __wcs);
715  break;
716  case 'H':
717  // Hour [00, 23]. [tm_hour]
718  __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 0, 23, 2,
719  __io, __tmperr);
720  break;
721  case 'I':
722  // Hour [01, 12]. [tm_hour]
723  __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 1, 12, 2,
724  __io, __tmperr);
725  break;
726  case 'm':
727  // Month [01, 12]. [tm_mon]
728  __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2,
729  __io, __tmperr);
730  if (!__tmperr)
731  __tm->tm_mon = __mem - 1;
732  break;
733  case 'M':
734  // Minute [00, 59]. [tm_min]
735  __beg = _M_extract_num(__beg, __end, __tm->tm_min, 0, 59, 2,
736  __io, __tmperr);
737  break;
738  case 'n':
739  if (__ctype.narrow(*__beg, 0) == '\n')
740  ++__beg;
741  else
742  __tmperr |= ios_base::failbit;
743  break;
744  case 'R':
745  // Equivalent to (%H:%M).
746  __cs = "%H:%M";
747  __ctype.widen(__cs, __cs + 6, __wcs);
748  __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
749  __tm, __wcs);
750  break;
751  case 'S':
752  // Seconds. [tm_sec]
753  // [00, 60] in C99 (one leap-second), [00, 61] in C89.
754 #if _GLIBCXX_USE_C99
755  __beg = _M_extract_num(__beg, __end, __tm->tm_sec, 0, 60, 2,
756 #else
757  __beg = _M_extract_num(__beg, __end, __tm->tm_sec, 0, 61, 2,
758 #endif
759  __io, __tmperr);
760  break;
761  case 't':
762  if (__ctype.narrow(*__beg, 0) == '\t')
763  ++__beg;
764  else
765  __tmperr |= ios_base::failbit;
766  break;
767  case 'T':
768  // Equivalent to (%H:%M:%S).
769  __cs = "%H:%M:%S";
770  __ctype.widen(__cs, __cs + 9, __wcs);
771  __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
772  __tm, __wcs);
773  break;
774  case 'x':
775  // Locale's date.
776  const char_type* __dates[2];
777  __tp._M_date_formats(__dates);
778  __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
779  __tm, __dates[0]);
780  break;
781  case 'X':
782  // Locale's time.
783  const char_type* __times[2];
784  __tp._M_time_formats(__times);
785  __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
786  __tm, __times[0]);
787  break;
788  case 'y':
789  case 'C': // C99
790  // Two digit year.
791  case 'Y':
792  // Year [1900).
793  // NB: We parse either two digits, implicitly years since
794  // 1900, or 4 digits, full year. In both cases we can
795  // reconstruct [tm_year]. See also libstdc++/26701.
796  __beg = _M_extract_num(__beg, __end, __mem, 0, 9999, 4,
797  __io, __tmperr);
798  if (!__tmperr)
799  __tm->tm_year = __mem < 0 ? __mem + 100 : __mem - 1900;
800  break;
801  case 'Z':
802  // Timezone info.
803  if (__ctype.is(ctype_base::upper, *__beg))
804  {
805  int __tmp;
806  __beg = _M_extract_name(__beg, __end, __tmp,
807  __timepunct_cache<_CharT>::_S_timezones,
808  14, __io, __tmperr);
809 
810  // GMT requires special effort.
811  if (__beg != __end && !__tmperr && __tmp == 0
812  && (*__beg == __ctype.widen('-')
813  || *__beg == __ctype.widen('+')))
814  {
815  __beg = _M_extract_num(__beg, __end, __tmp, 0, 23, 2,
816  __io, __tmperr);
817  __beg = _M_extract_num(__beg, __end, __tmp, 0, 59, 2,
818  __io, __tmperr);
819  }
820  }
821  else
822  __tmperr |= ios_base::failbit;
823  break;
824  default:
825  // Not recognized.
826  __tmperr |= ios_base::failbit;
827  }
828  }
829  else
830  {
831  // Verify format and input match, extract and discard.
832  if (__format[__i] == *__beg)
833  ++__beg;
834  else
835  __tmperr |= ios_base::failbit;
836  }
837  }
838 
839  if (__tmperr || __i != __len)
840  __err |= ios_base::failbit;
841 
842  return __beg;
843  }
844 
845  template<typename _CharT, typename _InIter>
846  _InIter
847  time_get<_CharT, _InIter>::
848  _M_extract_num(iter_type __beg, iter_type __end, int& __member,
849  int __min, int __max, size_t __len,
850  ios_base& __io, ios_base::iostate& __err) const
851  {
852  const locale& __loc = __io._M_getloc();
853  const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
854 
855  // As-is works for __len = 1, 2, 4, the values actually used.
856  int __mult = __len == 2 ? 10 : (__len == 4 ? 1000 : 1);
857 
858  ++__min;
859  size_t __i = 0;
860  int __value = 0;
861  for (; __beg != __end && __i < __len; ++__beg, (void)++__i)
862  {
863  const char __c = __ctype.narrow(*__beg, '*');
864  if (__c >= '0' && __c <= '9')
865  {
866  __value = __value * 10 + (__c - '0');
867  const int __valuec = __value * __mult;
868  if (__valuec > __max || __valuec + __mult < __min)
869  break;
870  __mult /= 10;
871  }
872  else
873  break;
874  }
875  if (__i == __len)
876  __member = __value;
877  // Special encoding for do_get_year, 'y', and 'Y' above.
878  else if (__len == 4 && __i == 2)
879  __member = __value - 100;
880  else
881  __err |= ios_base::failbit;
882 
883  return __beg;
884  }
885 
886  // Assumptions:
887  // All elements in __names are unique.
888  template<typename _CharT, typename _InIter>
889  _InIter
890  time_get<_CharT, _InIter>::
891  _M_extract_name(iter_type __beg, iter_type __end, int& __member,
892  const _CharT** __names, size_t __indexlen,
893  ios_base& __io, ios_base::iostate& __err) const
894  {
895  typedef char_traits<_CharT> __traits_type;
896  const locale& __loc = __io._M_getloc();
897  const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
898 
899  int* __matches = static_cast<int*>(__builtin_alloca(sizeof(int)
900  * __indexlen));
901  size_t __nmatches = 0;
902  size_t __pos = 0;
903  bool __testvalid = true;
904  const char_type* __name;
905 
906  // Look for initial matches.
907  // NB: Some of the locale data is in the form of all lowercase
908  // names, and some is in the form of initially-capitalized
909  // names. Look for both.
910  if (__beg != __end)
911  {
912  const char_type __c = *__beg;
913  for (size_t __i1 = 0; __i1 < __indexlen; ++__i1)
914  if (__c == __names[__i1][0]
915  || __c == __ctype.toupper(__names[__i1][0]))
916  __matches[__nmatches++] = __i1;
917  }
918 
919  while (__nmatches > 1)
920  {
921  // Find smallest matching string.
922  size_t __minlen = __traits_type::length(__names[__matches[0]]);
923  for (size_t __i2 = 1; __i2 < __nmatches; ++__i2)
924  __minlen = std::min(__minlen,
925  __traits_type::length(__names[__matches[__i2]]));
926  ++__beg;
927  ++__pos;
928  if (__pos < __minlen && __beg != __end)
929  for (size_t __i3 = 0; __i3 < __nmatches;)
930  {
931  __name = __names[__matches[__i3]];
932  if (!(__name[__pos] == *__beg))
933  __matches[__i3] = __matches[--__nmatches];
934  else
935  ++__i3;
936  }
937  else
938  break;
939  }
940 
941  if (__nmatches == 1)
942  {
943  // Make sure found name is completely extracted.
944  ++__beg;
945  ++__pos;
946  __name = __names[__matches[0]];
947  const size_t __len = __traits_type::length(__name);
948  while (__pos < __len && __beg != __end && __name[__pos] == *__beg)
949  ++__beg, (void)++__pos;
950 
951  if (__len == __pos)
952  __member = __matches[0];
953  else
954  __testvalid = false;
955  }
956  else
957  __testvalid = false;
958  if (!__testvalid)
959  __err |= ios_base::failbit;
960 
961  return __beg;
962  }
963 
964  template<typename _CharT, typename _InIter>
965  _InIter
966  time_get<_CharT, _InIter>::
967  _M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __member,
968  const _CharT** __names, size_t __indexlen,
969  ios_base& __io, ios_base::iostate& __err) const
970  {
971  typedef char_traits<_CharT> __traits_type;
972  const locale& __loc = __io._M_getloc();
973  const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
974 
975  int* __matches = static_cast<int*>(__builtin_alloca(2 * sizeof(int)
976  * __indexlen));
977  size_t __nmatches = 0;
978  size_t* __matches_lengths = 0;
979  size_t __pos = 0;
980 
981  if (__beg != __end)
982  {
983  const char_type __c = *__beg;
984  for (size_t __i = 0; __i < 2 * __indexlen; ++__i)
985  if (__c == __names[__i][0]
986  || __c == __ctype.toupper(__names[__i][0]))
987  __matches[__nmatches++] = __i;
988  }
989 
990  if (__nmatches)
991  {
992  ++__beg;
993  ++__pos;
994 
995  __matches_lengths
996  = static_cast<size_t*>(__builtin_alloca(sizeof(size_t)
997  * __nmatches));
998  for (size_t __i = 0; __i < __nmatches; ++__i)
999  __matches_lengths[__i]
1000  = __traits_type::length(__names[__matches[__i]]);
1001  }
1002 
1003  for (; __beg != __end; ++__beg, (void)++__pos)
1004  {
1005  size_t __nskipped = 0;
1006  const char_type __c = *__beg;
1007  for (size_t __i = 0; __i < __nmatches;)
1008  {
1009  const char_type* __name = __names[__matches[__i]];
1010  if (__pos >= __matches_lengths[__i])
1011  ++__nskipped, ++__i;
1012  else if (!(__name[__pos] == __c))
1013  {
1014  --__nmatches;
1015  __matches[__i] = __matches[__nmatches];
1016  __matches_lengths[__i] = __matches_lengths[__nmatches];
1017  }
1018  else
1019  ++__i;
1020  }
1021  if (__nskipped == __nmatches)
1022  break;
1023  }
1024 
1025  if ((__nmatches == 1 && __matches_lengths[0] == __pos)
1026  || (__nmatches == 2 && (__matches_lengths[0] == __pos
1027  || __matches_lengths[1] == __pos)))
1028  __member = (__matches[0] >= __indexlen
1029  ? __matches[0] - __indexlen : __matches[0]);
1030  else
1031  __err |= ios_base::failbit;
1032 
1033  return __beg;
1034  }
1035 
1036  template<typename _CharT, typename _InIter>
1037  _InIter
1040  ios_base::iostate& __err, tm* __tm) const
1041  {
1042  const locale& __loc = __io._M_getloc();
1043  const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
1044  const char_type* __times[2];
1045  __tp._M_time_formats(__times);
1046  __beg = _M_extract_via_format(__beg, __end, __io, __err,
1047  __tm, __times[0]);
1048  if (__beg == __end)
1049  __err |= ios_base::eofbit;
1050  return __beg;
1051  }
1052 
1053  template<typename _CharT, typename _InIter>
1054  _InIter
1057  ios_base::iostate& __err, tm* __tm) const
1058  {
1059  const locale& __loc = __io._M_getloc();
1060  const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
1061  const char_type* __dates[2];
1062  __tp._M_date_formats(__dates);
1063  __beg = _M_extract_via_format(__beg, __end, __io, __err,
1064  __tm, __dates[0]);
1065  if (__beg == __end)
1066  __err |= ios_base::eofbit;
1067  return __beg;
1068  }
1069 
1070  template<typename _CharT, typename _InIter>
1071  _InIter
1074  ios_base::iostate& __err, tm* __tm) const
1075  {
1076  const locale& __loc = __io._M_getloc();
1077  const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
1078  const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
1079  const char_type* __days[14];
1080  __tp._M_days_abbreviated(__days);
1081  __tp._M_days(__days + 7);
1082  int __tmpwday;
1083  ios_base::iostate __tmperr = ios_base::goodbit;
1084 
1085  __beg = _M_extract_wday_or_month(__beg, __end, __tmpwday, __days, 7,
1086  __io, __tmperr);
1087  if (!__tmperr)
1088  __tm->tm_wday = __tmpwday;
1089  else
1090  __err |= ios_base::failbit;
1091 
1092  if (__beg == __end)
1093  __err |= ios_base::eofbit;
1094  return __beg;
1095  }
1096 
1097  template<typename _CharT, typename _InIter>
1098  _InIter
1101  ios_base& __io, ios_base::iostate& __err, tm* __tm) const
1102  {
1103  const locale& __loc = __io._M_getloc();
1104  const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
1105  const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
1106  const char_type* __months[24];
1107  __tp._M_months_abbreviated(__months);
1108  __tp._M_months(__months + 12);
1109  int __tmpmon;
1110  ios_base::iostate __tmperr = ios_base::goodbit;
1111 
1112  __beg = _M_extract_wday_or_month(__beg, __end, __tmpmon, __months, 12,
1113  __io, __tmperr);
1114  if (!__tmperr)
1115  __tm->tm_mon = __tmpmon;
1116  else
1117  __err |= ios_base::failbit;
1118 
1119  if (__beg == __end)
1120  __err |= ios_base::eofbit;
1121  return __beg;
1122  }
1123 
1124  template<typename _CharT, typename _InIter>
1125  _InIter
1128  ios_base::iostate& __err, tm* __tm) const
1129  {
1130  const locale& __loc = __io._M_getloc();
1131  const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
1132  int __tmpyear;
1133  ios_base::iostate __tmperr = ios_base::goodbit;
1134 
1135  __beg = _M_extract_num(__beg, __end, __tmpyear, 0, 9999, 4,
1136  __io, __tmperr);
1137  if (!__tmperr)
1138  __tm->tm_year = __tmpyear < 0 ? __tmpyear + 100 : __tmpyear - 1900;
1139  else
1140  __err |= ios_base::failbit;
1141 
1142  if (__beg == __end)
1143  __err |= ios_base::eofbit;
1144  return __beg;
1145  }
1146 
1147 #if __cplusplus >= 201103L
1148  template<typename _CharT, typename _InIter>
1149  inline
1150  _InIter
1152  get(iter_type __s, iter_type __end, ios_base& __io,
1153  ios_base::iostate& __err, tm* __tm, const char_type* __fmt,
1154  const char_type* __fmtend) const
1155  {
1156  const locale& __loc = __io._M_getloc();
1157  ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
1158  __err = ios_base::goodbit;
1159  while (__fmt != __fmtend &&
1160  __err == ios_base::goodbit)
1161  {
1162  if (__s == __end)
1163  {
1165  break;
1166  }
1167  else if (__ctype.narrow(*__fmt, 0) == '%')
1168  {
1169  char __format;
1170  char __mod = 0;
1171  if (++__fmt == __fmtend)
1172  {
1173  __err = ios_base::failbit;
1174  break;
1175  }
1176  const char __c = __ctype.narrow(*__fmt, 0);
1177  if (__c != 'E' && __c != 'O')
1178  __format = __c;
1179  else if (++__fmt != __fmtend)
1180  {
1181  __mod = __c;
1182  __format = __ctype.narrow(*__fmt, 0);
1183  }
1184  else
1185  {
1186  __err = ios_base::failbit;
1187  break;
1188  }
1189  __s = this->do_get(__s, __end, __io, __err, __tm, __format,
1190  __mod);
1191  ++__fmt;
1192  }
1193  else if (__ctype.is(ctype_base::space, *__fmt))
1194  {
1195  ++__fmt;
1196  while (__fmt != __fmtend &&
1197  __ctype.is(ctype_base::space, *__fmt))
1198  ++__fmt;
1199 
1200  while (__s != __end &&
1201  __ctype.is(ctype_base::space, *__s))
1202  ++__s;
1203  }
1204  // TODO real case-insensitive comparison
1205  else if (__ctype.tolower(*__s) == __ctype.tolower(*__fmt) ||
1206  __ctype.toupper(*__s) == __ctype.toupper(*__fmt))
1207  {
1208  ++__s;
1209  ++__fmt;
1210  }
1211  else
1212  {
1213  __err = ios_base::failbit;
1214  break;
1215  }
1216  }
1217  return __s;
1218  }
1219 
1220  template<typename _CharT, typename _InIter>
1221  inline
1222  _InIter
1224  do_get(iter_type __beg, iter_type __end, ios_base& __io,
1225  ios_base::iostate& __err, tm* __tm,
1226  char __format, char __mod) const
1227  {
1228  const locale& __loc = __io._M_getloc();
1229  ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
1230  __err = ios_base::goodbit;
1231 
1232  char_type __fmt[4];
1233  __fmt[0] = __ctype.widen('%');
1234  if (!__mod)
1235  {
1236  __fmt[1] = __format;
1237  __fmt[2] = char_type();
1238  }
1239  else
1240  {
1241  __fmt[1] = __mod;
1242  __fmt[2] = __format;
1243  __fmt[3] = char_type();
1244  }
1245 
1246  __beg = _M_extract_via_format(__beg, __end, __io, __err, __tm, __fmt);
1247  if (__beg == __end)
1248  __err |= ios_base::eofbit;
1249  return __beg;
1250  }
1251 
1252 #endif // __cplusplus >= 201103L
1253 
1254  template<typename _CharT, typename _OutIter>
1255  _OutIter
1257  put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
1258  const _CharT* __beg, const _CharT* __end) const
1259  {
1260  const locale& __loc = __io._M_getloc();
1261  ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
1262  for (; __beg != __end; ++__beg)
1263  if (__ctype.narrow(*__beg, 0) != '%')
1264  {
1265  *__s = *__beg;
1266  ++__s;
1267  }
1268  else if (++__beg != __end)
1269  {
1270  char __format;
1271  char __mod = 0;
1272  const char __c = __ctype.narrow(*__beg, 0);
1273  if (__c != 'E' && __c != 'O')
1274  __format = __c;
1275  else if (++__beg != __end)
1276  {
1277  __mod = __c;
1278  __format = __ctype.narrow(*__beg, 0);
1279  }
1280  else
1281  break;
1282  __s = this->do_put(__s, __io, __fill, __tm, __format, __mod);
1283  }
1284  else
1285  break;
1286  return __s;
1287  }
1288 
1289  template<typename _CharT, typename _OutIter>
1290  _OutIter
1292  do_put(iter_type __s, ios_base& __io, char_type, const tm* __tm,
1293  char __format, char __mod) const
1294  {
1295  const locale& __loc = __io._M_getloc();
1296  ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
1297  __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
1298 
1299  // NB: This size is arbitrary. Should this be a data member,
1300  // initialized at construction?
1301  const size_t __maxlen = 128;
1302  char_type __res[__maxlen];
1303 
1304  // NB: In IEE 1003.1-200x, and perhaps other locale models, it
1305  // is possible that the format character will be longer than one
1306  // character. Possibilities include 'E' or 'O' followed by a
1307  // format character: if __mod is not the default argument, assume
1308  // it's a valid modifier.
1309  char_type __fmt[4];
1310  __fmt[0] = __ctype.widen('%');
1311  if (!__mod)
1312  {
1313  __fmt[1] = __format;
1314  __fmt[2] = char_type();
1315  }
1316  else
1317  {
1318  __fmt[1] = __mod;
1319  __fmt[2] = __format;
1320  __fmt[3] = char_type();
1321  }
1322 
1323  __tp._M_put(__res, __maxlen, __fmt, __tm);
1324 
1325  // Write resulting, fully-formatted string to output iterator.
1326  return std::__write(__s, __res, char_traits<char_type>::length(__res));
1327  }
1328 
1329 
1330  // Inhibit implicit instantiations for required instantiations,
1331  // which are defined via explicit instantiations elsewhere.
1332 #if _GLIBCXX_EXTERN_TEMPLATE
1333  extern template class moneypunct<char, false>;
1334  extern template class moneypunct<char, true>;
1335  extern template class moneypunct_byname<char, false>;
1336  extern template class moneypunct_byname<char, true>;
1337  extern template class _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 money_get<char>;
1338  extern template class _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 money_put<char>;
1339  extern template class __timepunct<char>;
1340  extern template class time_put<char>;
1341  extern template class time_put_byname<char>;
1342  extern template class time_get<char>;
1343  extern template class time_get_byname<char>;
1344  extern template class messages<char>;
1345  extern template class messages_byname<char>;
1346 
1347  extern template
1348  const moneypunct<char, true>&
1349  use_facet<moneypunct<char, true> >(const locale&);
1350 
1351  extern template
1353  use_facet<moneypunct<char, false> >(const locale&);
1354 
1355  extern template
1356  const money_put<char>&
1357  use_facet<money_put<char> >(const locale&);
1358 
1359  extern template
1360  const money_get<char>&
1361  use_facet<money_get<char> >(const locale&);
1362 
1363  extern template
1364  const __timepunct<char>&
1365  use_facet<__timepunct<char> >(const locale&);
1366 
1367  extern template
1368  const time_put<char>&
1369  use_facet<time_put<char> >(const locale&);
1370 
1371  extern template
1372  const time_get<char>&
1373  use_facet<time_get<char> >(const locale&);
1374 
1375  extern template
1376  const messages<char>&
1377  use_facet<messages<char> >(const locale&);
1378 
1379  extern template
1380  bool
1381  has_facet<moneypunct<char> >(const locale&);
1382 
1383  extern template
1384  bool
1385  has_facet<money_put<char> >(const locale&);
1386 
1387  extern template
1388  bool
1389  has_facet<money_get<char> >(const locale&);
1390 
1391  extern template
1392  bool
1393  has_facet<__timepunct<char> >(const locale&);
1394 
1395  extern template
1396  bool
1397  has_facet<time_put<char> >(const locale&);
1398 
1399  extern template
1400  bool
1401  has_facet<time_get<char> >(const locale&);
1402 
1403  extern template
1404  bool
1405  has_facet<messages<char> >(const locale&);
1406 
1407 #ifdef _GLIBCXX_USE_WCHAR_T
1408  extern template class moneypunct<wchar_t, false>;
1409  extern template class moneypunct<wchar_t, true>;
1410  extern template class moneypunct_byname<wchar_t, false>;
1411  extern template class moneypunct_byname<wchar_t, true>;
1412  extern template class _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 money_get<wchar_t>;
1413  extern template class _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 money_put<wchar_t>;
1414  extern template class __timepunct<wchar_t>;
1415  extern template class time_put<wchar_t>;
1416  extern template class time_put_byname<wchar_t>;
1417  extern template class time_get<wchar_t>;
1418  extern template class time_get_byname<wchar_t>;
1419  extern template class messages<wchar_t>;
1420  extern template class messages_byname<wchar_t>;
1421 
1422  extern template
1424  use_facet<moneypunct<wchar_t, true> >(const locale&);
1425 
1426  extern template
1428  use_facet<moneypunct<wchar_t, false> >(const locale&);
1429 
1430  extern template
1431  const money_put<wchar_t>&
1432  use_facet<money_put<wchar_t> >(const locale&);
1433 
1434  extern template
1435  const money_get<wchar_t>&
1436  use_facet<money_get<wchar_t> >(const locale&);
1437 
1438  extern template
1439  const __timepunct<wchar_t>&
1440  use_facet<__timepunct<wchar_t> >(const locale&);
1441 
1442  extern template
1443  const time_put<wchar_t>&
1444  use_facet<time_put<wchar_t> >(const locale&);
1445 
1446  extern template
1447  const time_get<wchar_t>&
1448  use_facet<time_get<wchar_t> >(const locale&);
1449 
1450  extern template
1451  const messages<wchar_t>&
1452  use_facet<messages<wchar_t> >(const locale&);
1453 
1454  extern template
1455  bool
1456  has_facet<moneypunct<wchar_t> >(const locale&);
1457 
1458  extern template
1459  bool
1460  has_facet<money_put<wchar_t> >(const locale&);
1461 
1462  extern template
1463  bool
1464  has_facet<money_get<wchar_t> >(const locale&);
1465 
1466  extern template
1467  bool
1468  has_facet<__timepunct<wchar_t> >(const locale&);
1469 
1470  extern template
1471  bool
1472  has_facet<time_put<wchar_t> >(const locale&);
1473 
1474  extern template
1475  bool
1476  has_facet<time_get<wchar_t> >(const locale&);
1477 
1478  extern template
1479  bool
1480  has_facet<messages<wchar_t> >(const locale&);
1481 #endif
1482 #endif
1483 
1484 _GLIBCXX_END_NAMESPACE_VERSION
1485 } // namespace std
1486 
1487 #endif
class messages_byname [22.2.7.2].
static const iostate eofbit
Indicates that an input operation reached the end of an input sequence.
Definition: ios_base.h:405
Primary class template money_put.This facet encapsulates the code to format and output a monetary amo...
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.
_GLIBCXX14_CONSTEXPR const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
Definition: stl_algobase.h:195
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.
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.
The base of the I/O class hierarchy.This class defines everything that can be defined about I/O that ...
Definition: ios_base.h:228
streamsize width() const
Flags access.
Definition: ios_base.h:712
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.
_CharT char_type
Public typedefs.
const _CharT * c_str() const noexcept
Return const pointer to null-terminated contents.
static const iostate goodbit
Indicates all is well.
Definition: ios_base.h:413
bool is(mask __m, char_type __c) const
Test char_type classification.
static const size_type npos
Value returned by various member functions when they fail.
_Ios_Iostate iostate
This is a bitmask type.
Definition: ios_base.h:398
virtual dateorder do_date_order() const
Return preferred order of month, day, and year.
_CharT char_type
Public typedefs.
Primary class template time_put.This facet encapsulates the code to format and output dates and times...
char_type widen(char __c) const
Widen char to char_type.
char narrow(char_type __c, char __dfault) const
Narrow char_type to char.
Primary class template moneypunct.This facet encapsulates the punctuation, grouping and other formatt...
static const iostate failbit
Indicates that an input operation failed to read the expected characters, or that an output operation...
Definition: ios_base.h:410
char_type toupper(char_type __c) const
Convert to uppercase.
_OutIter iter_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.
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.
static const fmtflags adjustfield
A mask of left|right|internal. Useful for the 2-arg form of setf.
Definition: ios_base.h:378
static const fmtflags internal
Adds fill characters at a designated internal point in certain generated output, or identical to righ...
Definition: ios_base.h:340
Primary class template messages.This facet encapsulates the code to retrieve messages from message ca...
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.
Primary class template money_get.This facet encapsulates the code to parse and return a monetary amou...
const locale & _M_getloc() const
Locale access.
Definition: ios_base.h:774
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.
class time_get_byname [22.2.5.2].
void resize(size_type __n, _CharT __c)
Resizes the string to the specified number of characters.
Container class for localization functionality.The locale class is first a class wrapper for C librar...
char_type tolower(char_type __c) const
Convert to lowercase.
ISO C++ entities toplevel namespace is std.
_Ios_Fmtflags fmtflags
This is a bitmask type.
Definition: ios_base.h:323
_CharT char_type
Public typedefs.
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.
class time_put_byname [22.2.5.4].
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.
const char_type * scan_not(mask __m, const char_type *__lo, const char_type *__hi) const
Find char_type not matching a mask.
locale getloc() const
Locale access.
Definition: ios_base.h:763
Primary class template time_get.This facet encapsulates the code to parse and return a date or time f...
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.
static locale::id id
Numpunct facet id.
_InIter iter_type
Public typedefs.
static const fmtflags left
Adds fill characters on the right (final positions) of certain generated output. (I.e., the thing you print is flush left.)
Definition: ios_base.h:344
_OutIter iter_type
Public typedefs.
class moneypunct_byname [22.2.6.4].
Primary class template ctype facet.This template class defines classification and conversion function...
static const fmtflags showbase
Generates a prefix indicating the numeric base of generated integer output.
Definition: ios_base.h:358
fmtflags flags() const
Access to format flags.
Definition: ios_base.h:619
_InIter iter_type
Public typedefs.
Basis for explicit traits specializations.
Definition: char_traits.h:227