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