libstdc++
locale_facets.h
Go to the documentation of this file.
1 // Locale support -*- C++ -*-
2 
3 // Copyright (C) 1997-2021 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.h
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 //
31 // ISO C++ 14882: 22.1 Locales
32 //
33 
34 #ifndef _LOCALE_FACETS_H
35 #define _LOCALE_FACETS_H 1
36 
37 #pragma GCC system_header
38 
39 #include <cwctype> // For wctype_t
40 #include <cctype>
41 #include <bits/ctype_base.h>
42 #include <iosfwd>
43 #include <bits/ios_base.h> // For ios_base, ios_base::iostate
44 #include <streambuf>
45 #include <bits/cpp_type_traits.h>
46 #include <ext/type_traits.h>
47 #include <ext/numeric_traits.h>
49 
50 namespace std _GLIBCXX_VISIBILITY(default)
51 {
52 _GLIBCXX_BEGIN_NAMESPACE_VERSION
53 
54 // Number of standard facets (for narrow characters only)
55 #define _GLIBCXX_NUM_FACETS 14
56 
57 // Number of duplicated facets for cxx11 ABI
58 #define _GLIBCXX_NUM_CXX11_FACETS (_GLIBCXX_USE_DUAL_ABI ? 8 : 0)
59 
60 // codecvt<char16_t> and codecvt<char32_t>
61 #ifdef _GLIBCXX_USE_CHAR8_T
62 # define _GLIBCXX_NUM_UNICODE_FACETS 4
63 #else
64 # define _GLIBCXX_NUM_UNICODE_FACETS 2
65 #endif
66 
67 // Facets duplicated for alt128 long double format
68 // num_get, num_put, money_get, money_put (+ cxx11 money_get, money_put)
69 #define _GLIBCXX_NUM_LBDL_ALT128_FACETS (4 + (_GLIBCXX_USE_DUAL_ABI ? 2 : 0))
70 
71  // Convert string to numeric value of type _Tp and store results.
72  // NB: This is specialized for all required types, there is no
73  // generic definition.
74  template<typename _Tp>
75  void
76  __convert_to_v(const char*, _Tp&, ios_base::iostate&,
77  const __c_locale&) throw();
78 
79  // Explicit specializations for required types.
80  template<>
81  void
82  __convert_to_v(const char*, float&, ios_base::iostate&,
83  const __c_locale&) throw();
84 
85  template<>
86  void
87  __convert_to_v(const char*, double&, ios_base::iostate&,
88  const __c_locale&) throw();
89 
90  template<>
91  void
92  __convert_to_v(const char*, long double&, ios_base::iostate&,
93  const __c_locale&) throw();
94 
95  // NB: __pad is a struct, rather than a function, so it can be
96  // partially-specialized.
97  template<typename _CharT, typename _Traits>
98  struct __pad
99  {
100  static void
101  _S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
102  const _CharT* __olds, streamsize __newlen, streamsize __oldlen);
103  };
104 
105  // Used by both numeric and monetary facets.
106  // Inserts "group separator" characters into an array of characters.
107  // It's recursive, one iteration per group. It moves the characters
108  // in the buffer this way: "xxxx12345" -> "12,345xxx". Call this
109  // only with __gsize != 0.
110  template<typename _CharT>
111  _CharT*
112  __add_grouping(_CharT* __s, _CharT __sep,
113  const char* __gbeg, size_t __gsize,
114  const _CharT* __first, const _CharT* __last);
115 
116  // This template permits specializing facet output code for
117  // ostreambuf_iterator. For ostreambuf_iterator, sputn is
118  // significantly more efficient than incrementing iterators.
119  template<typename _CharT>
120  inline
121  ostreambuf_iterator<_CharT>
122  __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
123  {
124  __s._M_put(__ws, __len);
125  return __s;
126  }
127 
128  // This is the unspecialized form of the template.
129  template<typename _CharT, typename _OutIter>
130  inline
131  _OutIter
132  __write(_OutIter __s, const _CharT* __ws, int __len)
133  {
134  for (int __j = 0; __j < __len; __j++, ++__s)
135  *__s = __ws[__j];
136  return __s;
137  }
138 
139 
140  // 22.2.1.1 Template class ctype
141  // Include host and configuration specific ctype enums for ctype_base.
142 
143  /**
144  * @brief Common base for ctype facet
145  *
146  * This template class provides implementations of the public functions
147  * that forward to the protected virtual functions.
148  *
149  * This template also provides abstract stubs for the protected virtual
150  * functions.
151  */
152  template<typename _CharT>
154  {
155  public:
156  // Types:
157  /// Typedef for the template parameter
158  typedef _CharT char_type;
159 
160  /**
161  * @brief Test char_type classification.
162  *
163  * This function finds a mask M for @a __c and compares it to
164  * mask @a __m. It does so by returning the value of
165  * ctype<char_type>::do_is().
166  *
167  * @param __c The char_type to compare the mask of.
168  * @param __m The mask to compare against.
169  * @return (M & __m) != 0.
170  */
171  bool
172  is(mask __m, char_type __c) const
173  { return this->do_is(__m, __c); }
174 
175  /**
176  * @brief Return a mask array.
177  *
178  * This function finds the mask for each char_type in the range [lo,hi)
179  * and successively writes it to vec. vec must have as many elements
180  * as the char array. It does so by returning the value of
181  * ctype<char_type>::do_is().
182  *
183  * @param __lo Pointer to start of range.
184  * @param __hi Pointer to end of range.
185  * @param __vec Pointer to an array of mask storage.
186  * @return @a __hi.
187  */
188  const char_type*
189  is(const char_type *__lo, const char_type *__hi, mask *__vec) const
190  { return this->do_is(__lo, __hi, __vec); }
191 
192  /**
193  * @brief Find char_type matching a mask
194  *
195  * This function searches for and returns the first char_type c in
196  * [lo,hi) for which is(m,c) is true. It does so by returning
197  * ctype<char_type>::do_scan_is().
198  *
199  * @param __m The mask to compare against.
200  * @param __lo Pointer to start of range.
201  * @param __hi Pointer to end of range.
202  * @return Pointer to matching char_type if found, else @a __hi.
203  */
204  const char_type*
205  scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
206  { return this->do_scan_is(__m, __lo, __hi); }
207 
208  /**
209  * @brief Find char_type not matching a mask
210  *
211  * This function searches for and returns the first char_type c in
212  * [lo,hi) for which is(m,c) is false. It does so by returning
213  * ctype<char_type>::do_scan_not().
214  *
215  * @param __m The mask to compare against.
216  * @param __lo Pointer to first char in range.
217  * @param __hi Pointer to end of range.
218  * @return Pointer to non-matching char if found, else @a __hi.
219  */
220  const char_type*
221  scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
222  { return this->do_scan_not(__m, __lo, __hi); }
223 
224  /**
225  * @brief Convert to uppercase.
226  *
227  * This function converts the argument to uppercase if possible.
228  * If not possible (for example, '2'), returns the argument. It does
229  * so by returning ctype<char_type>::do_toupper().
230  *
231  * @param __c The char_type to convert.
232  * @return The uppercase char_type if convertible, else @a __c.
233  */
234  char_type
235  toupper(char_type __c) const
236  { return this->do_toupper(__c); }
237 
238  /**
239  * @brief Convert array to uppercase.
240  *
241  * This function converts each char_type in the range [lo,hi) to
242  * uppercase if possible. Other elements remain untouched. It does so
243  * by returning ctype<char_type>:: do_toupper(lo, hi).
244  *
245  * @param __lo Pointer to start of range.
246  * @param __hi Pointer to end of range.
247  * @return @a __hi.
248  */
249  const char_type*
250  toupper(char_type *__lo, const char_type* __hi) const
251  { return this->do_toupper(__lo, __hi); }
252 
253  /**
254  * @brief Convert to lowercase.
255  *
256  * This function converts the argument to lowercase if possible. If
257  * not possible (for example, '2'), returns the argument. It does so
258  * by returning ctype<char_type>::do_tolower(c).
259  *
260  * @param __c The char_type to convert.
261  * @return The lowercase char_type if convertible, else @a __c.
262  */
263  char_type
264  tolower(char_type __c) const
265  { return this->do_tolower(__c); }
266 
267  /**
268  * @brief Convert array to lowercase.
269  *
270  * This function converts each char_type in the range [__lo,__hi) to
271  * lowercase if possible. Other elements remain untouched. It does so
272  * by returning ctype<char_type>:: do_tolower(__lo, __hi).
273  *
274  * @param __lo Pointer to start of range.
275  * @param __hi Pointer to end of range.
276  * @return @a __hi.
277  */
278  const char_type*
279  tolower(char_type* __lo, const char_type* __hi) const
280  { return this->do_tolower(__lo, __hi); }
281 
282  /**
283  * @brief Widen char to char_type
284  *
285  * This function converts the char argument to char_type using the
286  * simplest reasonable transformation. It does so by returning
287  * ctype<char_type>::do_widen(c).
288  *
289  * Note: this is not what you want for codepage conversions. See
290  * codecvt for that.
291  *
292  * @param __c The char to convert.
293  * @return The converted char_type.
294  */
295  char_type
296  widen(char __c) const
297  { return this->do_widen(__c); }
298 
299  /**
300  * @brief Widen array to char_type
301  *
302  * This function converts each char in the input to char_type using the
303  * simplest reasonable transformation. It does so by returning
304  * ctype<char_type>::do_widen(c).
305  *
306  * Note: this is not what you want for codepage conversions. See
307  * codecvt for that.
308  *
309  * @param __lo Pointer to start of range.
310  * @param __hi Pointer to end of range.
311  * @param __to Pointer to the destination array.
312  * @return @a __hi.
313  */
314  const char*
315  widen(const char* __lo, const char* __hi, char_type* __to) const
316  { return this->do_widen(__lo, __hi, __to); }
317 
318  /**
319  * @brief Narrow char_type to char
320  *
321  * This function converts the char_type to char using the simplest
322  * reasonable transformation. If the conversion fails, dfault is
323  * returned instead. It does so by returning
324  * ctype<char_type>::do_narrow(__c).
325  *
326  * Note: this is not what you want for codepage conversions. See
327  * codecvt for that.
328  *
329  * @param __c The char_type to convert.
330  * @param __dfault Char to return if conversion fails.
331  * @return The converted char.
332  */
333  char
334  narrow(char_type __c, char __dfault) const
335  { return this->do_narrow(__c, __dfault); }
336 
337  /**
338  * @brief Narrow array to char array
339  *
340  * This function converts each char_type in the input to char using the
341  * simplest reasonable transformation and writes the results to the
342  * destination array. For any char_type in the input that cannot be
343  * converted, @a dfault is used instead. It does so by returning
344  * ctype<char_type>::do_narrow(__lo, __hi, __dfault, __to).
345  *
346  * Note: this is not what you want for codepage conversions. See
347  * codecvt for that.
348  *
349  * @param __lo Pointer to start of range.
350  * @param __hi Pointer to end of range.
351  * @param __dfault Char to use if conversion fails.
352  * @param __to Pointer to the destination array.
353  * @return @a __hi.
354  */
355  const char_type*
356  narrow(const char_type* __lo, const char_type* __hi,
357  char __dfault, char* __to) const
358  { return this->do_narrow(__lo, __hi, __dfault, __to); }
359 
360  protected:
361  explicit
362  __ctype_abstract_base(size_t __refs = 0): facet(__refs) { }
363 
364  virtual
365  ~__ctype_abstract_base() { }
366 
367  /**
368  * @brief Test char_type classification.
369  *
370  * This function finds a mask M for @a c and compares it to mask @a m.
371  *
372  * do_is() is a hook for a derived facet to change the behavior of
373  * classifying. do_is() must always return the same result for the
374  * same input.
375  *
376  * @param __c The char_type to find the mask of.
377  * @param __m The mask to compare against.
378  * @return (M & __m) != 0.
379  */
380  virtual bool
381  do_is(mask __m, char_type __c) const = 0;
382 
383  /**
384  * @brief Return a mask array.
385  *
386  * This function finds the mask for each char_type in the range [lo,hi)
387  * and successively writes it to vec. vec must have as many elements
388  * as the input.
389  *
390  * do_is() is a hook for a derived facet to change the behavior of
391  * classifying. do_is() must always return the same result for the
392  * same input.
393  *
394  * @param __lo Pointer to start of range.
395  * @param __hi Pointer to end of range.
396  * @param __vec Pointer to an array of mask storage.
397  * @return @a __hi.
398  */
399  virtual const char_type*
400  do_is(const char_type* __lo, const char_type* __hi,
401  mask* __vec) const = 0;
402 
403  /**
404  * @brief Find char_type matching mask
405  *
406  * This function searches for and returns the first char_type c in
407  * [__lo,__hi) for which is(__m,c) is true.
408  *
409  * do_scan_is() is a hook for a derived facet to change the behavior of
410  * match searching. do_is() must always return the same result for the
411  * same input.
412  *
413  * @param __m The mask to compare against.
414  * @param __lo Pointer to start of range.
415  * @param __hi Pointer to end of range.
416  * @return Pointer to a matching char_type if found, else @a __hi.
417  */
418  virtual const char_type*
419  do_scan_is(mask __m, const char_type* __lo,
420  const char_type* __hi) const = 0;
421 
422  /**
423  * @brief Find char_type not matching mask
424  *
425  * This function searches for and returns a pointer to the first
426  * char_type c of [lo,hi) for which is(m,c) is false.
427  *
428  * do_scan_is() is a hook for a derived facet to change the behavior of
429  * match searching. do_is() must always return the same result for the
430  * same input.
431  *
432  * @param __m The mask to compare against.
433  * @param __lo Pointer to start of range.
434  * @param __hi Pointer to end of range.
435  * @return Pointer to a non-matching char_type if found, else @a __hi.
436  */
437  virtual const char_type*
438  do_scan_not(mask __m, const char_type* __lo,
439  const char_type* __hi) const = 0;
440 
441  /**
442  * @brief Convert to uppercase.
443  *
444  * This virtual function converts the char_type argument to uppercase
445  * if possible. If not possible (for example, '2'), returns the
446  * argument.
447  *
448  * do_toupper() is a hook for a derived facet to change the behavior of
449  * uppercasing. do_toupper() must always return the same result for
450  * the same input.
451  *
452  * @param __c The char_type to convert.
453  * @return The uppercase char_type if convertible, else @a __c.
454  */
455  virtual char_type
456  do_toupper(char_type __c) const = 0;
457 
458  /**
459  * @brief Convert array to uppercase.
460  *
461  * This virtual function converts each char_type in the range [__lo,__hi)
462  * to uppercase if possible. Other elements remain untouched.
463  *
464  * do_toupper() is a hook for a derived facet to change the behavior of
465  * uppercasing. do_toupper() must always return the same result for
466  * the same input.
467  *
468  * @param __lo Pointer to start of range.
469  * @param __hi Pointer to end of range.
470  * @return @a __hi.
471  */
472  virtual const char_type*
473  do_toupper(char_type* __lo, const char_type* __hi) const = 0;
474 
475  /**
476  * @brief Convert to lowercase.
477  *
478  * This virtual function converts the argument to lowercase if
479  * possible. If not possible (for example, '2'), returns the argument.
480  *
481  * do_tolower() is a hook for a derived facet to change the behavior of
482  * lowercasing. do_tolower() must always return the same result for
483  * the same input.
484  *
485  * @param __c The char_type to convert.
486  * @return The lowercase char_type if convertible, else @a __c.
487  */
488  virtual char_type
489  do_tolower(char_type __c) const = 0;
490 
491  /**
492  * @brief Convert array to lowercase.
493  *
494  * This virtual function converts each char_type in the range [__lo,__hi)
495  * to lowercase if possible. Other elements remain untouched.
496  *
497  * do_tolower() is a hook for a derived facet to change the behavior of
498  * lowercasing. do_tolower() must always return the same result for
499  * the same input.
500  *
501  * @param __lo Pointer to start of range.
502  * @param __hi Pointer to end of range.
503  * @return @a __hi.
504  */
505  virtual const char_type*
506  do_tolower(char_type* __lo, const char_type* __hi) const = 0;
507 
508  /**
509  * @brief Widen char
510  *
511  * This virtual function converts the char to char_type using the
512  * simplest reasonable transformation.
513  *
514  * do_widen() is a hook for a derived facet to change the behavior of
515  * widening. do_widen() must always return the same result for the
516  * same input.
517  *
518  * Note: this is not what you want for codepage conversions. See
519  * codecvt for that.
520  *
521  * @param __c The char to convert.
522  * @return The converted char_type
523  */
524  virtual char_type
525  do_widen(char __c) const = 0;
526 
527  /**
528  * @brief Widen char array
529  *
530  * This function converts each char in the input to char_type using the
531  * simplest reasonable transformation.
532  *
533  * do_widen() is a hook for a derived facet to change the behavior of
534  * widening. do_widen() must always return the same result for the
535  * same input.
536  *
537  * Note: this is not what you want for codepage conversions. See
538  * codecvt for that.
539  *
540  * @param __lo Pointer to start range.
541  * @param __hi Pointer to end of range.
542  * @param __to Pointer to the destination array.
543  * @return @a __hi.
544  */
545  virtual const char*
546  do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0;
547 
548  /**
549  * @brief Narrow char_type to char
550  *
551  * This virtual function converts the argument to char using the
552  * simplest reasonable transformation. If the conversion fails, dfault
553  * is returned instead.
554  *
555  * do_narrow() is a hook for a derived facet to change the behavior of
556  * narrowing. do_narrow() must always return the same result for the
557  * same input.
558  *
559  * Note: this is not what you want for codepage conversions. See
560  * codecvt for that.
561  *
562  * @param __c The char_type to convert.
563  * @param __dfault Char to return if conversion fails.
564  * @return The converted char.
565  */
566  virtual char
567  do_narrow(char_type __c, char __dfault) const = 0;
568 
569  /**
570  * @brief Narrow char_type array to char
571  *
572  * This virtual function converts each char_type in the range
573  * [__lo,__hi) to char using the simplest reasonable
574  * transformation and writes the results to the destination
575  * array. For any element in the input that cannot be
576  * converted, @a __dfault is used instead.
577  *
578  * do_narrow() is a hook for a derived facet to change the behavior of
579  * narrowing. do_narrow() must always return the same result for the
580  * same input.
581  *
582  * Note: this is not what you want for codepage conversions. See
583  * codecvt for that.
584  *
585  * @param __lo Pointer to start of range.
586  * @param __hi Pointer to end of range.
587  * @param __dfault Char to use if conversion fails.
588  * @param __to Pointer to the destination array.
589  * @return @a __hi.
590  */
591  virtual const char_type*
592  do_narrow(const char_type* __lo, const char_type* __hi,
593  char __dfault, char* __to) const = 0;
594  };
595 
596  /**
597  * @brief Primary class template ctype facet.
598  * @ingroup locales
599  *
600  * This template class defines classification and conversion functions for
601  * character sets. It wraps cctype functionality. Ctype gets used by
602  * streams for many I/O operations.
603  *
604  * This template provides the protected virtual functions the developer
605  * will have to replace in a derived class or specialization to make a
606  * working facet. The public functions that access them are defined in
607  * __ctype_abstract_base, to allow for implementation flexibility. See
608  * ctype<wchar_t> for an example. The functions are documented in
609  * __ctype_abstract_base.
610  *
611  * Note: implementations are provided for all the protected virtual
612  * functions, but will likely not be useful.
613  */
614  template<typename _CharT>
615  class ctype : public __ctype_abstract_base<_CharT>
616  {
617  public:
618  // Types:
619  typedef _CharT char_type;
620  typedef typename __ctype_abstract_base<_CharT>::mask mask;
621 
622  /// The facet id for ctype<char_type>
623  static locale::id id;
624 
625  explicit
626  ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }
627 
628  protected:
629  virtual
630  ~ctype();
631 
632  virtual bool
633  do_is(mask __m, char_type __c) const;
634 
635  virtual const char_type*
636  do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
637 
638  virtual const char_type*
639  do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
640 
641  virtual const char_type*
642  do_scan_not(mask __m, const char_type* __lo,
643  const char_type* __hi) const;
644 
645  virtual char_type
646  do_toupper(char_type __c) const;
647 
648  virtual const char_type*
649  do_toupper(char_type* __lo, const char_type* __hi) const;
650 
651  virtual char_type
652  do_tolower(char_type __c) const;
653 
654  virtual const char_type*
655  do_tolower(char_type* __lo, const char_type* __hi) const;
656 
657  virtual char_type
658  do_widen(char __c) const;
659 
660  virtual const char*
661  do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
662 
663  virtual char
664  do_narrow(char_type, char __dfault) const;
665 
666  virtual const char_type*
667  do_narrow(const char_type* __lo, const char_type* __hi,
668  char __dfault, char* __to) const;
669  };
670 
671  template<typename _CharT>
672  locale::id ctype<_CharT>::id;
673 
674  /**
675  * @brief The ctype<char> specialization.
676  * @ingroup locales
677  *
678  * This class defines classification and conversion functions for
679  * the char type. It gets used by char streams for many I/O
680  * operations. The char specialization provides a number of
681  * optimizations as well.
682  */
683  template<>
684  class ctype<char> : public locale::facet, public ctype_base
685  {
686  public:
687  // Types:
688  /// Typedef for the template parameter char.
689  typedef char char_type;
690 
691  protected:
692  // Data Members:
693  __c_locale _M_c_locale_ctype;
694  bool _M_del;
695  __to_type _M_toupper;
696  __to_type _M_tolower;
697  const mask* _M_table;
698  mutable char _M_widen_ok;
699  mutable char _M_widen[1 + static_cast<unsigned char>(-1)];
700  mutable char _M_narrow[1 + static_cast<unsigned char>(-1)];
701  mutable char _M_narrow_ok; // 0 uninitialized, 1 init,
702  // 2 memcpy can't be used
703 
704  public:
705  /// The facet id for ctype<char>
706  static locale::id id;
707  /// The size of the mask table. It is SCHAR_MAX + 1.
708  static const size_t table_size = 1 + static_cast<unsigned char>(-1);
709 
710  /**
711  * @brief Constructor performs initialization.
712  *
713  * This is the constructor provided by the standard.
714  *
715  * @param __table If non-zero, table is used as the per-char mask.
716  * Else classic_table() is used.
717  * @param __del If true, passes ownership of table to this facet.
718  * @param __refs Passed to the base facet class.
719  */
720  explicit
721  ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
722 
723  /**
724  * @brief Constructor performs static initialization.
725  *
726  * This constructor is used to construct the initial C locale facet.
727  *
728  * @param __cloc Handle to C locale data.
729  * @param __table If non-zero, table is used as the per-char mask.
730  * @param __del If true, passes ownership of table to this facet.
731  * @param __refs Passed to the base facet class.
732  */
733  explicit
734  ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
735  size_t __refs = 0);
736 
737  /**
738  * @brief Test char classification.
739  *
740  * This function compares the mask table[c] to @a __m.
741  *
742  * @param __c The char to compare the mask of.
743  * @param __m The mask to compare against.
744  * @return True if __m & table[__c] is true, false otherwise.
745  */
746  inline bool
747  is(mask __m, char __c) const;
748 
749  /**
750  * @brief Return a mask array.
751  *
752  * This function finds the mask for each char in the range [lo, hi) and
753  * successively writes it to vec. vec must have as many elements as
754  * the char array.
755  *
756  * @param __lo Pointer to start of range.
757  * @param __hi Pointer to end of range.
758  * @param __vec Pointer to an array of mask storage.
759  * @return @a __hi.
760  */
761  inline const char*
762  is(const char* __lo, const char* __hi, mask* __vec) const;
763 
764  /**
765  * @brief Find char matching a mask
766  *
767  * This function searches for and returns the first char in [lo,hi) for
768  * which is(m,char) is true.
769  *
770  * @param __m The mask to compare against.
771  * @param __lo Pointer to start of range.
772  * @param __hi Pointer to end of range.
773  * @return Pointer to a matching char if found, else @a __hi.
774  */
775  inline const char*
776  scan_is(mask __m, const char* __lo, const char* __hi) const;
777 
778  /**
779  * @brief Find char not matching a mask
780  *
781  * This function searches for and returns a pointer to the first char
782  * in [__lo,__hi) for which is(m,char) is false.
783  *
784  * @param __m The mask to compare against.
785  * @param __lo Pointer to start of range.
786  * @param __hi Pointer to end of range.
787  * @return Pointer to a non-matching char if found, else @a __hi.
788  */
789  inline const char*
790  scan_not(mask __m, const char* __lo, const char* __hi) const;
791 
792  /**
793  * @brief Convert to uppercase.
794  *
795  * This function converts the char argument to uppercase if possible.
796  * If not possible (for example, '2'), returns the argument.
797  *
798  * toupper() acts as if it returns ctype<char>::do_toupper(c).
799  * do_toupper() must always return the same result for the same input.
800  *
801  * @param __c The char to convert.
802  * @return The uppercase char if convertible, else @a __c.
803  */
804  char_type
805  toupper(char_type __c) const
806  { return this->do_toupper(__c); }
807 
808  /**
809  * @brief Convert array to uppercase.
810  *
811  * This function converts each char in the range [__lo,__hi) to uppercase
812  * if possible. Other chars remain untouched.
813  *
814  * toupper() acts as if it returns ctype<char>:: do_toupper(__lo, __hi).
815  * do_toupper() must always return the same result for the same input.
816  *
817  * @param __lo Pointer to first char in range.
818  * @param __hi Pointer to end of range.
819  * @return @a __hi.
820  */
821  const char_type*
822  toupper(char_type *__lo, const char_type* __hi) const
823  { return this->do_toupper(__lo, __hi); }
824 
825  /**
826  * @brief Convert to lowercase.
827  *
828  * This function converts the char argument to lowercase if possible.
829  * If not possible (for example, '2'), returns the argument.
830  *
831  * tolower() acts as if it returns ctype<char>::do_tolower(__c).
832  * do_tolower() must always return the same result for the same input.
833  *
834  * @param __c The char to convert.
835  * @return The lowercase char if convertible, else @a __c.
836  */
837  char_type
838  tolower(char_type __c) const
839  { return this->do_tolower(__c); }
840 
841  /**
842  * @brief Convert array to lowercase.
843  *
844  * This function converts each char in the range [lo,hi) to lowercase
845  * if possible. Other chars remain untouched.
846  *
847  * tolower() acts as if it returns ctype<char>:: do_tolower(__lo, __hi).
848  * do_tolower() must always return the same result for the same input.
849  *
850  * @param __lo Pointer to first char in range.
851  * @param __hi Pointer to end of range.
852  * @return @a __hi.
853  */
854  const char_type*
855  tolower(char_type* __lo, const char_type* __hi) const
856  { return this->do_tolower(__lo, __hi); }
857 
858  /**
859  * @brief Widen char
860  *
861  * This function converts the char to char_type using the simplest
862  * reasonable transformation. For an underived ctype<char> facet, the
863  * argument will be returned unchanged.
864  *
865  * This function works as if it returns ctype<char>::do_widen(c).
866  * do_widen() must always return the same result for the same input.
867  *
868  * Note: this is not what you want for codepage conversions. See
869  * codecvt for that.
870  *
871  * @param __c The char to convert.
872  * @return The converted character.
873  */
874  char_type
875  widen(char __c) const
876  {
877  if (_M_widen_ok)
878  return _M_widen[static_cast<unsigned char>(__c)];
879  this->_M_widen_init();
880  return this->do_widen(__c);
881  }
882 
883  /**
884  * @brief Widen char array
885  *
886  * This function converts each char in the input to char using the
887  * simplest reasonable transformation. For an underived ctype<char>
888  * facet, the argument will be copied unchanged.
889  *
890  * This function works as if it returns ctype<char>::do_widen(c).
891  * do_widen() must always return the same result for the same input.
892  *
893  * Note: this is not what you want for codepage conversions. See
894  * codecvt for that.
895  *
896  * @param __lo Pointer to first char in range.
897  * @param __hi Pointer to end of range.
898  * @param __to Pointer to the destination array.
899  * @return @a __hi.
900  */
901  const char*
902  widen(const char* __lo, const char* __hi, char_type* __to) const
903  {
904  if (_M_widen_ok == 1)
905  {
906  if (__builtin_expect(__hi != __lo, true))
907  __builtin_memcpy(__to, __lo, __hi - __lo);
908  return __hi;
909  }
910  if (!_M_widen_ok)
911  _M_widen_init();
912  return this->do_widen(__lo, __hi, __to);
913  }
914 
915  /**
916  * @brief Narrow char
917  *
918  * This function converts the char to char using the simplest
919  * reasonable transformation. If the conversion fails, dfault is
920  * returned instead. For an underived ctype<char> facet, @a c
921  * will be returned unchanged.
922  *
923  * This function works as if it returns ctype<char>::do_narrow(c).
924  * do_narrow() must always return the same result for the same input.
925  *
926  * Note: this is not what you want for codepage conversions. See
927  * codecvt for that.
928  *
929  * @param __c The char to convert.
930  * @param __dfault Char to return if conversion fails.
931  * @return The converted character.
932  */
933  char
934  narrow(char_type __c, char __dfault) const
935  {
936  if (_M_narrow[static_cast<unsigned char>(__c)])
937  return _M_narrow[static_cast<unsigned char>(__c)];
938  const char __t = do_narrow(__c, __dfault);
939  if (__t != __dfault)
940  _M_narrow[static_cast<unsigned char>(__c)] = __t;
941  return __t;
942  }
943 
944  /**
945  * @brief Narrow char array
946  *
947  * This function converts each char in the input to char using the
948  * simplest reasonable transformation and writes the results to the
949  * destination array. For any char in the input that cannot be
950  * converted, @a dfault is used instead. For an underived ctype<char>
951  * facet, the argument will be copied unchanged.
952  *
953  * This function works as if it returns ctype<char>::do_narrow(lo, hi,
954  * dfault, to). do_narrow() must always return the same result for the
955  * same input.
956  *
957  * Note: this is not what you want for codepage conversions. See
958  * codecvt for that.
959  *
960  * @param __lo Pointer to start of range.
961  * @param __hi Pointer to end of range.
962  * @param __dfault Char to use if conversion fails.
963  * @param __to Pointer to the destination array.
964  * @return @a __hi.
965  */
966  const char_type*
967  narrow(const char_type* __lo, const char_type* __hi,
968  char __dfault, char* __to) const
969  {
970  if (__builtin_expect(_M_narrow_ok == 1, true))
971  {
972  if (__builtin_expect(__hi != __lo, true))
973  __builtin_memcpy(__to, __lo, __hi - __lo);
974  return __hi;
975  }
976  if (!_M_narrow_ok)
977  _M_narrow_init();
978  return this->do_narrow(__lo, __hi, __dfault, __to);
979  }
980 
981  // _GLIBCXX_RESOLVE_LIB_DEFECTS
982  // DR 695. ctype<char>::classic_table() not accessible.
983  /// Returns a pointer to the mask table provided to the constructor, or
984  /// the default from classic_table() if none was provided.
985  const mask*
986  table() const throw()
987  { return _M_table; }
988 
989  /// Returns a pointer to the C locale mask table.
990  static const mask*
991  classic_table() throw();
992  protected:
993 
994  /**
995  * @brief Destructor.
996  *
997  * This function deletes table() if @a del was true in the
998  * constructor.
999  */
1000  virtual
1001  ~ctype();
1002 
1003  /**
1004  * @brief Convert to uppercase.
1005  *
1006  * This virtual function converts the char argument to uppercase if
1007  * possible. If not possible (for example, '2'), returns the argument.
1008  *
1009  * do_toupper() is a hook for a derived facet to change the behavior of
1010  * uppercasing. do_toupper() must always return the same result for
1011  * the same input.
1012  *
1013  * @param __c The char to convert.
1014  * @return The uppercase char if convertible, else @a __c.
1015  */
1016  virtual char_type
1017  do_toupper(char_type __c) const;
1018 
1019  /**
1020  * @brief Convert array to uppercase.
1021  *
1022  * This virtual function converts each char in the range [lo,hi) to
1023  * uppercase if possible. Other chars remain untouched.
1024  *
1025  * do_toupper() is a hook for a derived facet to change the behavior of
1026  * uppercasing. do_toupper() must always return the same result for
1027  * the same input.
1028  *
1029  * @param __lo Pointer to start of range.
1030  * @param __hi Pointer to end of range.
1031  * @return @a __hi.
1032  */
1033  virtual const char_type*
1034  do_toupper(char_type* __lo, const char_type* __hi) const;
1035 
1036  /**
1037  * @brief Convert to lowercase.
1038  *
1039  * This virtual function converts the char argument to lowercase if
1040  * possible. If not possible (for example, '2'), returns the argument.
1041  *
1042  * do_tolower() is a hook for a derived facet to change the behavior of
1043  * lowercasing. do_tolower() must always return the same result for
1044  * the same input.
1045  *
1046  * @param __c The char to convert.
1047  * @return The lowercase char if convertible, else @a __c.
1048  */
1049  virtual char_type
1050  do_tolower(char_type __c) const;
1051 
1052  /**
1053  * @brief Convert array to lowercase.
1054  *
1055  * This virtual function converts each char in the range [lo,hi) to
1056  * lowercase if possible. Other chars remain untouched.
1057  *
1058  * do_tolower() is a hook for a derived facet to change the behavior of
1059  * lowercasing. do_tolower() must always return the same result for
1060  * the same input.
1061  *
1062  * @param __lo Pointer to first char in range.
1063  * @param __hi Pointer to end of range.
1064  * @return @a __hi.
1065  */
1066  virtual const char_type*
1067  do_tolower(char_type* __lo, const char_type* __hi) const;
1068 
1069  /**
1070  * @brief Widen char
1071  *
1072  * This virtual function converts the char to char using the simplest
1073  * reasonable transformation. For an underived ctype<char> facet, the
1074  * argument will be returned unchanged.
1075  *
1076  * do_widen() is a hook for a derived facet to change the behavior of
1077  * widening. do_widen() must always return the same result for the
1078  * same input.
1079  *
1080  * Note: this is not what you want for codepage conversions. See
1081  * codecvt for that.
1082  *
1083  * @param __c The char to convert.
1084  * @return The converted character.
1085  */
1086  virtual char_type
1087  do_widen(char __c) const
1088  { return __c; }
1089 
1090  /**
1091  * @brief Widen char array
1092  *
1093  * This function converts each char in the range [lo,hi) to char using
1094  * the simplest reasonable transformation. For an underived
1095  * ctype<char> facet, the argument will be copied unchanged.
1096  *
1097  * do_widen() is a hook for a derived facet to change the behavior of
1098  * widening. do_widen() must always return the same result for the
1099  * same input.
1100  *
1101  * Note: this is not what you want for codepage conversions. See
1102  * codecvt for that.
1103  *
1104  * @param __lo Pointer to start of range.
1105  * @param __hi Pointer to end of range.
1106  * @param __to Pointer to the destination array.
1107  * @return @a __hi.
1108  */
1109  virtual const char*
1110  do_widen(const char* __lo, const char* __hi, char_type* __to) const
1111  {
1112  if (__builtin_expect(__hi != __lo, true))
1113  __builtin_memcpy(__to, __lo, __hi - __lo);
1114  return __hi;
1115  }
1116 
1117  /**
1118  * @brief Narrow char
1119  *
1120  * This virtual function converts the char to char using the simplest
1121  * reasonable transformation. If the conversion fails, dfault is
1122  * returned instead. For an underived ctype<char> facet, @a c will be
1123  * returned unchanged.
1124  *
1125  * do_narrow() is a hook for a derived facet to change the behavior of
1126  * narrowing. do_narrow() must always return the same result for the
1127  * same input.
1128  *
1129  * Note: this is not what you want for codepage conversions. See
1130  * codecvt for that.
1131  *
1132  * @param __c The char to convert.
1133  * @param __dfault Char to return if conversion fails.
1134  * @return The converted char.
1135  */
1136  virtual char
1137  do_narrow(char_type __c, char __dfault __attribute__((__unused__))) const
1138  { return __c; }
1139 
1140  /**
1141  * @brief Narrow char array to char array
1142  *
1143  * This virtual function converts each char in the range [lo,hi) to
1144  * char using the simplest reasonable transformation and writes the
1145  * results to the destination array. For any char in the input that
1146  * cannot be converted, @a dfault is used instead. For an underived
1147  * ctype<char> facet, the argument will be copied unchanged.
1148  *
1149  * do_narrow() is a hook for a derived facet to change the behavior of
1150  * narrowing. do_narrow() must always return the same result for the
1151  * same input.
1152  *
1153  * Note: this is not what you want for codepage conversions. See
1154  * codecvt for that.
1155  *
1156  * @param __lo Pointer to start of range.
1157  * @param __hi Pointer to end of range.
1158  * @param __dfault Char to use if conversion fails.
1159  * @param __to Pointer to the destination array.
1160  * @return @a __hi.
1161  */
1162  virtual const char_type*
1163  do_narrow(const char_type* __lo, const char_type* __hi,
1164  char __dfault __attribute__((__unused__)), char* __to) const
1165  {
1166  if (__builtin_expect(__hi != __lo, true))
1167  __builtin_memcpy(__to, __lo, __hi - __lo);
1168  return __hi;
1169  }
1170 
1171  private:
1172  void _M_narrow_init() const;
1173  void _M_widen_init() const;
1174  };
1175 
1176 #ifdef _GLIBCXX_USE_WCHAR_T
1177  /**
1178  * @brief The ctype<wchar_t> specialization.
1179  * @ingroup locales
1180  *
1181  * This class defines classification and conversion functions for the
1182  * wchar_t type. It gets used by wchar_t streams for many I/O operations.
1183  * The wchar_t specialization provides a number of optimizations as well.
1184  *
1185  * ctype<wchar_t> inherits its public methods from
1186  * __ctype_abstract_base<wchar_t>.
1187  */
1188  template<>
1189  class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
1190  {
1191  public:
1192  // Types:
1193  /// Typedef for the template parameter wchar_t.
1194  typedef wchar_t char_type;
1195  typedef wctype_t __wmask_type;
1196 
1197  protected:
1198  __c_locale _M_c_locale_ctype;
1199 
1200  // Pre-computed narrowed and widened chars.
1201  bool _M_narrow_ok;
1202  char _M_narrow[128];
1203  wint_t _M_widen[1 + static_cast<unsigned char>(-1)];
1204 
1205  // Pre-computed elements for do_is.
1206  mask _M_bit[16];
1207  __wmask_type _M_wmask[16];
1208 
1209  public:
1210  // Data Members:
1211  /// The facet id for ctype<wchar_t>
1212  static locale::id id;
1213 
1214  /**
1215  * @brief Constructor performs initialization.
1216  *
1217  * This is the constructor provided by the standard.
1218  *
1219  * @param __refs Passed to the base facet class.
1220  */
1221  explicit
1222  ctype(size_t __refs = 0);
1223 
1224  /**
1225  * @brief Constructor performs static initialization.
1226  *
1227  * This constructor is used to construct the initial C locale facet.
1228  *
1229  * @param __cloc Handle to C locale data.
1230  * @param __refs Passed to the base facet class.
1231  */
1232  explicit
1233  ctype(__c_locale __cloc, size_t __refs = 0);
1234 
1235  protected:
1236  __wmask_type
1237  _M_convert_to_wmask(const mask __m) const throw();
1238 
1239  /// Destructor
1240  virtual
1241  ~ctype();
1242 
1243  /**
1244  * @brief Test wchar_t classification.
1245  *
1246  * This function finds a mask M for @a c and compares it to mask @a m.
1247  *
1248  * do_is() is a hook for a derived facet to change the behavior of
1249  * classifying. do_is() must always return the same result for the
1250  * same input.
1251  *
1252  * @param __c The wchar_t to find the mask of.
1253  * @param __m The mask to compare against.
1254  * @return (M & __m) != 0.
1255  */
1256  virtual bool
1257  do_is(mask __m, char_type __c) const;
1258 
1259  /**
1260  * @brief Return a mask array.
1261  *
1262  * This function finds the mask for each wchar_t in the range [lo,hi)
1263  * and successively writes it to vec. vec must have as many elements
1264  * as the input.
1265  *
1266  * do_is() is a hook for a derived facet to change the behavior of
1267  * classifying. do_is() must always return the same result for the
1268  * same input.
1269  *
1270  * @param __lo Pointer to start of range.
1271  * @param __hi Pointer to end of range.
1272  * @param __vec Pointer to an array of mask storage.
1273  * @return @a __hi.
1274  */
1275  virtual const char_type*
1276  do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
1277 
1278  /**
1279  * @brief Find wchar_t matching mask
1280  *
1281  * This function searches for and returns the first wchar_t c in
1282  * [__lo,__hi) for which is(__m,c) is true.
1283  *
1284  * do_scan_is() is a hook for a derived facet to change the behavior of
1285  * match searching. do_is() must always return the same result for the
1286  * same input.
1287  *
1288  * @param __m The mask to compare against.
1289  * @param __lo Pointer to start of range.
1290  * @param __hi Pointer to end of range.
1291  * @return Pointer to a matching wchar_t if found, else @a __hi.
1292  */
1293  virtual const char_type*
1294  do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
1295 
1296  /**
1297  * @brief Find wchar_t not matching mask
1298  *
1299  * This function searches for and returns a pointer to the first
1300  * wchar_t c of [__lo,__hi) for which is(__m,c) is false.
1301  *
1302  * do_scan_is() is a hook for a derived facet to change the behavior of
1303  * match searching. do_is() must always return the same result for the
1304  * same input.
1305  *
1306  * @param __m The mask to compare against.
1307  * @param __lo Pointer to start of range.
1308  * @param __hi Pointer to end of range.
1309  * @return Pointer to a non-matching wchar_t if found, else @a __hi.
1310  */
1311  virtual const char_type*
1312  do_scan_not(mask __m, const char_type* __lo,
1313  const char_type* __hi) const;
1314 
1315  /**
1316  * @brief Convert to uppercase.
1317  *
1318  * This virtual function converts the wchar_t argument to uppercase if
1319  * possible. If not possible (for example, '2'), returns the argument.
1320  *
1321  * do_toupper() is a hook for a derived facet to change the behavior of
1322  * uppercasing. do_toupper() must always return the same result for
1323  * the same input.
1324  *
1325  * @param __c The wchar_t to convert.
1326  * @return The uppercase wchar_t if convertible, else @a __c.
1327  */
1328  virtual char_type
1329  do_toupper(char_type __c) const;
1330 
1331  /**
1332  * @brief Convert array to uppercase.
1333  *
1334  * This virtual function converts each wchar_t in the range [lo,hi) to
1335  * uppercase if possible. Other elements remain untouched.
1336  *
1337  * do_toupper() is a hook for a derived facet to change the behavior of
1338  * uppercasing. do_toupper() must always return the same result for
1339  * the same input.
1340  *
1341  * @param __lo Pointer to start of range.
1342  * @param __hi Pointer to end of range.
1343  * @return @a __hi.
1344  */
1345  virtual const char_type*
1346  do_toupper(char_type* __lo, const char_type* __hi) const;
1347 
1348  /**
1349  * @brief Convert to lowercase.
1350  *
1351  * This virtual function converts the argument to lowercase if
1352  * possible. If not possible (for example, '2'), returns the argument.
1353  *
1354  * do_tolower() is a hook for a derived facet to change the behavior of
1355  * lowercasing. do_tolower() must always return the same result for
1356  * the same input.
1357  *
1358  * @param __c The wchar_t to convert.
1359  * @return The lowercase wchar_t if convertible, else @a __c.
1360  */
1361  virtual char_type
1362  do_tolower(char_type __c) const;
1363 
1364  /**
1365  * @brief Convert array to lowercase.
1366  *
1367  * This virtual function converts each wchar_t in the range [lo,hi) to
1368  * lowercase if possible. Other elements remain untouched.
1369  *
1370  * do_tolower() is a hook for a derived facet to change the behavior of
1371  * lowercasing. do_tolower() must always return the same result for
1372  * the same input.
1373  *
1374  * @param __lo Pointer to start of range.
1375  * @param __hi Pointer to end of range.
1376  * @return @a __hi.
1377  */
1378  virtual const char_type*
1379  do_tolower(char_type* __lo, const char_type* __hi) const;
1380 
1381  /**
1382  * @brief Widen char to wchar_t
1383  *
1384  * This virtual function converts the char to wchar_t using the
1385  * simplest reasonable transformation. For an underived ctype<wchar_t>
1386  * facet, the argument will be cast to wchar_t.
1387  *
1388  * do_widen() is a hook for a derived facet to change the behavior of
1389  * widening. do_widen() must always return the same result for the
1390  * same input.
1391  *
1392  * Note: this is not what you want for codepage conversions. See
1393  * codecvt for that.
1394  *
1395  * @param __c The char to convert.
1396  * @return The converted wchar_t.
1397  */
1398  virtual char_type
1399  do_widen(char __c) const;
1400 
1401  /**
1402  * @brief Widen char array to wchar_t array
1403  *
1404  * This function converts each char in the input to wchar_t using the
1405  * simplest reasonable transformation. For an underived ctype<wchar_t>
1406  * facet, the argument will be copied, casting each element to wchar_t.
1407  *
1408  * do_widen() is a hook for a derived facet to change the behavior of
1409  * widening. do_widen() must always return the same result for the
1410  * same input.
1411  *
1412  * Note: this is not what you want for codepage conversions. See
1413  * codecvt for that.
1414  *
1415  * @param __lo Pointer to start range.
1416  * @param __hi Pointer to end of range.
1417  * @param __to Pointer to the destination array.
1418  * @return @a __hi.
1419  */
1420  virtual const char*
1421  do_widen(const char* __lo, const char* __hi, char_type* __to) const;
1422 
1423  /**
1424  * @brief Narrow wchar_t to char
1425  *
1426  * This virtual function converts the argument to char using
1427  * the simplest reasonable transformation. If the conversion
1428  * fails, dfault is returned instead. For an underived
1429  * ctype<wchar_t> facet, @a c will be cast to char and
1430  * returned.
1431  *
1432  * do_narrow() is a hook for a derived facet to change the
1433  * behavior of narrowing. do_narrow() must always return the
1434  * same result for the same input.
1435  *
1436  * Note: this is not what you want for codepage conversions. See
1437  * codecvt for that.
1438  *
1439  * @param __c The wchar_t to convert.
1440  * @param __dfault Char to return if conversion fails.
1441  * @return The converted char.
1442  */
1443  virtual char
1444  do_narrow(char_type __c, char __dfault) const;
1445 
1446  /**
1447  * @brief Narrow wchar_t array to char array
1448  *
1449  * This virtual function converts each wchar_t in the range [lo,hi) to
1450  * char using the simplest reasonable transformation and writes the
1451  * results to the destination array. For any wchar_t in the input that
1452  * cannot be converted, @a dfault is used instead. For an underived
1453  * ctype<wchar_t> facet, the argument will be copied, casting each
1454  * element to char.
1455  *
1456  * do_narrow() is a hook for a derived facet to change the behavior of
1457  * narrowing. do_narrow() must always return the same result for the
1458  * same input.
1459  *
1460  * Note: this is not what you want for codepage conversions. See
1461  * codecvt for that.
1462  *
1463  * @param __lo Pointer to start of range.
1464  * @param __hi Pointer to end of range.
1465  * @param __dfault Char to use if conversion fails.
1466  * @param __to Pointer to the destination array.
1467  * @return @a __hi.
1468  */
1469  virtual const char_type*
1470  do_narrow(const char_type* __lo, const char_type* __hi,
1471  char __dfault, char* __to) const;
1472 
1473  // For use at construction time only.
1474  void
1475  _M_initialize_ctype() throw();
1476  };
1477 #endif //_GLIBCXX_USE_WCHAR_T
1478 
1479  /// class ctype_byname [22.2.1.2].
1480  template<typename _CharT>
1481  class ctype_byname : public ctype<_CharT>
1482  {
1483  public:
1484  typedef typename ctype<_CharT>::mask mask;
1485 
1486  explicit
1487  ctype_byname(const char* __s, size_t __refs = 0);
1488 
1489 #if __cplusplus >= 201103L
1490  explicit
1491  ctype_byname(const string& __s, size_t __refs = 0)
1492  : ctype_byname(__s.c_str(), __refs) { }
1493 #endif
1494 
1495  protected:
1496  virtual
1497  ~ctype_byname() { }
1498  };
1499 
1500  /// 22.2.1.4 Class ctype_byname specializations.
1501  template<>
1502  class ctype_byname<char> : public ctype<char>
1503  {
1504  public:
1505  explicit
1506  ctype_byname(const char* __s, size_t __refs = 0);
1507 
1508 #if __cplusplus >= 201103L
1509  explicit
1510  ctype_byname(const string& __s, size_t __refs = 0);
1511 #endif
1512 
1513  protected:
1514  virtual
1515  ~ctype_byname();
1516  };
1517 
1518 #ifdef _GLIBCXX_USE_WCHAR_T
1519  template<>
1520  class ctype_byname<wchar_t> : public ctype<wchar_t>
1521  {
1522  public:
1523  explicit
1524  ctype_byname(const char* __s, size_t __refs = 0);
1525 
1526 #if __cplusplus >= 201103L
1527  explicit
1528  ctype_byname(const string& __s, size_t __refs = 0);
1529 #endif
1530 
1531  protected:
1532  virtual
1533  ~ctype_byname();
1534  };
1535 #endif
1536 
1537 _GLIBCXX_END_NAMESPACE_VERSION
1538 } // namespace
1539 
1540 // Include host and configuration specific ctype inlines.
1541 #include <bits/ctype_inline.h>
1542 
1543 namespace std _GLIBCXX_VISIBILITY(default)
1544 {
1545 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1546 
1547  // 22.2.2 The numeric category.
1548  class __num_base
1549  {
1550  public:
1551  // NB: Code depends on the order of _S_atoms_out elements.
1552  // Below are the indices into _S_atoms_out.
1553  enum
1554  {
1555  _S_ominus,
1556  _S_oplus,
1557  _S_ox,
1558  _S_oX,
1559  _S_odigits,
1560  _S_odigits_end = _S_odigits + 16,
1561  _S_oudigits = _S_odigits_end,
1562  _S_oudigits_end = _S_oudigits + 16,
1563  _S_oe = _S_odigits + 14, // For scientific notation, 'e'
1564  _S_oE = _S_oudigits + 14, // For scientific notation, 'E'
1565  _S_oend = _S_oudigits_end
1566  };
1567 
1568  // A list of valid numeric literals for output. This array
1569  // contains chars that will be passed through the current locale's
1570  // ctype<_CharT>.widen() and then used to render numbers.
1571  // For the standard "C" locale, this is
1572  // "-+xX0123456789abcdef0123456789ABCDEF".
1573  static const char* _S_atoms_out;
1574 
1575  // String literal of acceptable (narrow) input, for num_get.
1576  // "-+xX0123456789abcdefABCDEF"
1577  static const char* _S_atoms_in;
1578 
1579  enum
1580  {
1581  _S_iminus,
1582  _S_iplus,
1583  _S_ix,
1584  _S_iX,
1585  _S_izero,
1586  _S_ie = _S_izero + 14,
1587  _S_iE = _S_izero + 20,
1588  _S_iend = 26
1589  };
1590 
1591  // num_put
1592  // Construct and return valid scanf format for floating point types.
1593  static void
1594  _S_format_float(const ios_base& __io, char* __fptr, char __mod) throw();
1595  };
1596 
1597  template<typename _CharT>
1598  struct __numpunct_cache : public locale::facet
1599  {
1600  const char* _M_grouping;
1601  size_t _M_grouping_size;
1602  bool _M_use_grouping;
1603  const _CharT* _M_truename;
1604  size_t _M_truename_size;
1605  const _CharT* _M_falsename;
1606  size_t _M_falsename_size;
1607  _CharT _M_decimal_point;
1608  _CharT _M_thousands_sep;
1609 
1610  // A list of valid numeric literals for output: in the standard
1611  // "C" locale, this is "-+xX0123456789abcdef0123456789ABCDEF".
1612  // This array contains the chars after having been passed
1613  // through the current locale's ctype<_CharT>.widen().
1614  _CharT _M_atoms_out[__num_base::_S_oend];
1615 
1616  // A list of valid numeric literals for input: in the standard
1617  // "C" locale, this is "-+xX0123456789abcdefABCDEF"
1618  // This array contains the chars after having been passed
1619  // through the current locale's ctype<_CharT>.widen().
1620  _CharT _M_atoms_in[__num_base::_S_iend];
1621 
1622  bool _M_allocated;
1623 
1624  __numpunct_cache(size_t __refs = 0)
1625  : facet(__refs), _M_grouping(0), _M_grouping_size(0),
1626  _M_use_grouping(false),
1627  _M_truename(0), _M_truename_size(0), _M_falsename(0),
1628  _M_falsename_size(0), _M_decimal_point(_CharT()),
1629  _M_thousands_sep(_CharT()), _M_allocated(false)
1630  { }
1631 
1632  ~__numpunct_cache();
1633 
1634  void
1635  _M_cache(const locale& __loc);
1636 
1637  private:
1638  __numpunct_cache&
1639  operator=(const __numpunct_cache&);
1640 
1641  explicit
1642  __numpunct_cache(const __numpunct_cache&);
1643  };
1644 
1645  template<typename _CharT>
1646  __numpunct_cache<_CharT>::~__numpunct_cache()
1647  {
1648  if (_M_allocated)
1649  {
1650  delete [] _M_grouping;
1651  delete [] _M_truename;
1652  delete [] _M_falsename;
1653  }
1654  }
1655 
1656 _GLIBCXX_BEGIN_NAMESPACE_CXX11
1657 
1658  /**
1659  * @brief Primary class template numpunct.
1660  * @ingroup locales
1661  *
1662  * This facet stores several pieces of information related to printing and
1663  * scanning numbers, such as the decimal point character. It takes a
1664  * template parameter specifying the char type. The numpunct facet is
1665  * used by streams for many I/O operations involving numbers.
1666  *
1667  * The numpunct template uses protected virtual functions to provide the
1668  * actual results. The public accessors forward the call to the virtual
1669  * functions. These virtual functions are hooks for developers to
1670  * implement the behavior they require from a numpunct facet.
1671  */
1672  template<typename _CharT>
1673  class numpunct : public locale::facet
1674  {
1675  public:
1676  // Types:
1677  ///@{
1678  /// Public typedefs
1679  typedef _CharT char_type;
1681  ///@}
1682  typedef __numpunct_cache<_CharT> __cache_type;
1683 
1684  protected:
1685  __cache_type* _M_data;
1686 
1687  public:
1688  /// Numpunct facet id.
1689  static locale::id id;
1690 
1691  /**
1692  * @brief Numpunct constructor.
1693  *
1694  * @param __refs Refcount to pass to the base class.
1695  */
1696  explicit
1697  numpunct(size_t __refs = 0)
1698  : facet(__refs), _M_data(0)
1699  { _M_initialize_numpunct(); }
1700 
1701  /**
1702  * @brief Internal constructor. Not for general use.
1703  *
1704  * This is a constructor for use by the library itself to set up the
1705  * predefined locale facets.
1706  *
1707  * @param __cache __numpunct_cache object.
1708  * @param __refs Refcount to pass to the base class.
1709  */
1710  explicit
1711  numpunct(__cache_type* __cache, size_t __refs = 0)
1712  : facet(__refs), _M_data(__cache)
1713  { _M_initialize_numpunct(); }
1714 
1715  /**
1716  * @brief Internal constructor. Not for general use.
1717  *
1718  * This is a constructor for use by the library itself to set up new
1719  * locales.
1720  *
1721  * @param __cloc The C locale.
1722  * @param __refs Refcount to pass to the base class.
1723  */
1724  explicit
1725  numpunct(__c_locale __cloc, size_t __refs = 0)
1726  : facet(__refs), _M_data(0)
1727  { _M_initialize_numpunct(__cloc); }
1728 
1729  /**
1730  * @brief Return decimal point character.
1731  *
1732  * This function returns a char_type to use as a decimal point. It
1733  * does so by returning returning
1734  * numpunct<char_type>::do_decimal_point().
1735  *
1736  * @return @a char_type representing a decimal point.
1737  */
1738  char_type
1740  { return this->do_decimal_point(); }
1741 
1742  /**
1743  * @brief Return thousands separator character.
1744  *
1745  * This function returns a char_type to use as a thousands
1746  * separator. It does so by returning returning
1747  * numpunct<char_type>::do_thousands_sep().
1748  *
1749  * @return char_type representing a thousands separator.
1750  */
1751  char_type
1753  { return this->do_thousands_sep(); }
1754 
1755  /**
1756  * @brief Return grouping specification.
1757  *
1758  * This function returns a string representing groupings for the
1759  * integer part of a number. Groupings indicate where thousands
1760  * separators should be inserted in the integer part of a number.
1761  *
1762  * Each char in the return string is interpret as an integer
1763  * rather than a character. These numbers represent the number
1764  * of digits in a group. The first char in the string
1765  * represents the number of digits in the least significant
1766  * group. If a char is negative, it indicates an unlimited
1767  * number of digits for the group. If more chars from the
1768  * string are required to group a number, the last char is used
1769  * repeatedly.
1770  *
1771  * For example, if the grouping() returns "\003\002" and is
1772  * applied to the number 123456789, this corresponds to
1773  * 12,34,56,789. Note that if the string was "32", this would
1774  * put more than 50 digits into the least significant group if
1775  * the character set is ASCII.
1776  *
1777  * The string is returned by calling
1778  * numpunct<char_type>::do_grouping().
1779  *
1780  * @return string representing grouping specification.
1781  */
1782  string
1783  grouping() const
1784  { return this->do_grouping(); }
1785 
1786  /**
1787  * @brief Return string representation of bool true.
1788  *
1789  * This function returns a string_type containing the text
1790  * representation for true bool variables. It does so by calling
1791  * numpunct<char_type>::do_truename().
1792  *
1793  * @return string_type representing printed form of true.
1794  */
1795  string_type
1796  truename() const
1797  { return this->do_truename(); }
1798 
1799  /**
1800  * @brief Return string representation of bool false.
1801  *
1802  * This function returns a string_type containing the text
1803  * representation for false bool variables. It does so by calling
1804  * numpunct<char_type>::do_falsename().
1805  *
1806  * @return string_type representing printed form of false.
1807  */
1808  string_type
1809  falsename() const
1810  { return this->do_falsename(); }
1811 
1812  protected:
1813  /// Destructor.
1814  virtual
1815  ~numpunct();
1816 
1817  /**
1818  * @brief Return decimal point character.
1819  *
1820  * Returns a char_type to use as a decimal point. This function is a
1821  * hook for derived classes to change the value returned.
1822  *
1823  * @return @a char_type representing a decimal point.
1824  */
1825  virtual char_type
1827  { return _M_data->_M_decimal_point; }
1828 
1829  /**
1830  * @brief Return thousands separator character.
1831  *
1832  * Returns a char_type to use as a thousands separator. This function
1833  * is a hook for derived classes to change the value returned.
1834  *
1835  * @return @a char_type representing a thousands separator.
1836  */
1837  virtual char_type
1839  { return _M_data->_M_thousands_sep; }
1840 
1841  /**
1842  * @brief Return grouping specification.
1843  *
1844  * Returns a string representing groupings for the integer part of a
1845  * number. This function is a hook for derived classes to change the
1846  * value returned. @see grouping() for details.
1847  *
1848  * @return String representing grouping specification.
1849  */
1850  virtual string
1851  do_grouping() const
1852  { return _M_data->_M_grouping; }
1853 
1854  /**
1855  * @brief Return string representation of bool true.
1856  *
1857  * Returns a string_type containing the text representation for true
1858  * bool variables. This function is a hook for derived classes to
1859  * change the value returned.
1860  *
1861  * @return string_type representing printed form of true.
1862  */
1863  virtual string_type
1864  do_truename() const
1865  { return _M_data->_M_truename; }
1866 
1867  /**
1868  * @brief Return string representation of bool false.
1869  *
1870  * Returns a string_type containing the text representation for false
1871  * bool variables. This function is a hook for derived classes to
1872  * change the value returned.
1873  *
1874  * @return string_type representing printed form of false.
1875  */
1876  virtual string_type
1878  { return _M_data->_M_falsename; }
1879 
1880  // For use at construction time only.
1881  void
1882  _M_initialize_numpunct(__c_locale __cloc = 0);
1883  };
1884 
1885  template<typename _CharT>
1886  locale::id numpunct<_CharT>::id;
1887 
1888  template<>
1890 
1891  template<>
1892  void
1893  numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
1894 
1895 #ifdef _GLIBCXX_USE_WCHAR_T
1896  template<>
1898 
1899  template<>
1900  void
1901  numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);
1902 #endif
1903 
1904  /// class numpunct_byname [22.2.3.2].
1905  template<typename _CharT>
1906  class numpunct_byname : public numpunct<_CharT>
1907  {
1908  public:
1909  typedef _CharT char_type;
1911 
1912  explicit
1913  numpunct_byname(const char* __s, size_t __refs = 0)
1914  : numpunct<_CharT>(__refs)
1915  {
1916  if (__builtin_strcmp(__s, "C") != 0
1917  && __builtin_strcmp(__s, "POSIX") != 0)
1918  {
1919  __c_locale __tmp;
1920  this->_S_create_c_locale(__tmp, __s);
1921  this->_M_initialize_numpunct(__tmp);
1922  this->_S_destroy_c_locale(__tmp);
1923  }
1924  }
1925 
1926 #if __cplusplus >= 201103L
1927  explicit
1928  numpunct_byname(const string& __s, size_t __refs = 0)
1929  : numpunct_byname(__s.c_str(), __refs) { }
1930 #endif
1931 
1932  protected:
1933  virtual
1934  ~numpunct_byname() { }
1935  };
1936 
1937 _GLIBCXX_END_NAMESPACE_CXX11
1938 
1939 _GLIBCXX_BEGIN_NAMESPACE_LDBL
1940 
1941  /**
1942  * @brief Primary class template num_get.
1943  * @ingroup locales
1944  *
1945  * This facet encapsulates the code to parse and return a number
1946  * from a string. It is used by the istream numeric extraction
1947  * operators.
1948  *
1949  * The num_get template uses protected virtual functions to provide the
1950  * actual results. The public accessors forward the call to the virtual
1951  * functions. These virtual functions are hooks for developers to
1952  * implement the behavior they require from the num_get facet.
1953  */
1954  template<typename _CharT, typename _InIter>
1955  class num_get : public locale::facet
1956  {
1957  public:
1958  // Types:
1959  ///@{
1960  /// Public typedefs
1961  typedef _CharT char_type;
1962  typedef _InIter iter_type;
1963  ///@}
1964 
1965  /// Numpunct facet id.
1966  static locale::id id;
1967 
1968  /**
1969  * @brief Constructor performs initialization.
1970  *
1971  * This is the constructor provided by the standard.
1972  *
1973  * @param __refs Passed to the base facet class.
1974  */
1975  explicit
1976  num_get(size_t __refs = 0) : facet(__refs) { }
1977 
1978  /**
1979  * @brief Numeric parsing.
1980  *
1981  * Parses the input stream into the bool @a v. It does so by calling
1982  * num_get::do_get().
1983  *
1984  * If ios_base::boolalpha is set, attempts to read
1985  * ctype<CharT>::truename() or ctype<CharT>::falsename(). Sets
1986  * @a v to true or false if successful. Sets err to
1987  * ios_base::failbit if reading the string fails. Sets err to
1988  * ios_base::eofbit if the stream is emptied.
1989  *
1990  * If ios_base::boolalpha is not set, proceeds as with reading a long,
1991  * except if the value is 1, sets @a v to true, if the value is 0, sets
1992  * @a v to false, and otherwise set err to ios_base::failbit.
1993  *
1994  * @param __in Start of input stream.
1995  * @param __end End of input stream.
1996  * @param __io Source of locale and flags.
1997  * @param __err Error flags to set.
1998  * @param __v Value to format and insert.
1999  * @return Iterator after reading.
2000  */
2001  iter_type
2002  get(iter_type __in, iter_type __end, ios_base& __io,
2003  ios_base::iostate& __err, bool& __v) const
2004  { return this->do_get(__in, __end, __io, __err, __v); }
2005 
2006  ///@{
2007  /**
2008  * @brief Numeric parsing.
2009  *
2010  * Parses the input stream into the integral variable @a v. It does so
2011  * by calling num_get::do_get().
2012  *
2013  * Parsing is affected by the flag settings in @a io.
2014  *
2015  * The basic parse is affected by the value of io.flags() &
2016  * ios_base::basefield. If equal to ios_base::oct, parses like the
2017  * scanf %o specifier. Else if equal to ios_base::hex, parses like %X
2018  * specifier. Else if basefield equal to 0, parses like the %i
2019  * specifier. Otherwise, parses like %d for signed and %u for unsigned
2020  * types. The matching type length modifier is also used.
2021  *
2022  * Digit grouping is interpreted according to
2023  * numpunct::grouping() and numpunct::thousands_sep(). If the
2024  * pattern of digit groups isn't consistent, sets err to
2025  * ios_base::failbit.
2026  *
2027  * If parsing the string yields a valid value for @a v, @a v is set.
2028  * Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
2029  * Sets err to ios_base::eofbit if the stream is emptied.
2030  *
2031  * @param __in Start of input stream.
2032  * @param __end End of input stream.
2033  * @param __io Source of locale and flags.
2034  * @param __err Error flags to set.
2035  * @param __v Value to format and insert.
2036  * @return Iterator after reading.
2037  */
2038  iter_type
2039  get(iter_type __in, iter_type __end, ios_base& __io,
2040  ios_base::iostate& __err, long& __v) const
2041  { return this->do_get(__in, __end, __io, __err, __v); }
2042 
2043  iter_type
2044  get(iter_type __in, iter_type __end, ios_base& __io,
2045  ios_base::iostate& __err, unsigned short& __v) const
2046  { return this->do_get(__in, __end, __io, __err, __v); }
2047 
2048  iter_type
2049  get(iter_type __in, iter_type __end, ios_base& __io,
2050  ios_base::iostate& __err, unsigned int& __v) const
2051  { return this->do_get(__in, __end, __io, __err, __v); }
2052 
2053  iter_type
2054  get(iter_type __in, iter_type __end, ios_base& __io,
2055  ios_base::iostate& __err, unsigned long& __v) const
2056  { return this->do_get(__in, __end, __io, __err, __v); }
2057 
2058 #ifdef _GLIBCXX_USE_LONG_LONG
2059  iter_type
2060  get(iter_type __in, iter_type __end, ios_base& __io,
2061  ios_base::iostate& __err, long long& __v) const
2062  { return this->do_get(__in, __end, __io, __err, __v); }
2063 
2064  iter_type
2065  get(iter_type __in, iter_type __end, ios_base& __io,
2066  ios_base::iostate& __err, unsigned long long& __v) const
2067  { return this->do_get(__in, __end, __io, __err, __v); }
2068 #endif
2069  ///@}
2070 
2071  ///@{
2072  /**
2073  * @brief Numeric parsing.
2074  *
2075  * Parses the input stream into the integral variable @a v. It does so
2076  * by calling num_get::do_get().
2077  *
2078  * The input characters are parsed like the scanf %g specifier. The
2079  * matching type length modifier is also used.
2080  *
2081  * The decimal point character used is numpunct::decimal_point().
2082  * Digit grouping is interpreted according to
2083  * numpunct::grouping() and numpunct::thousands_sep(). If the
2084  * pattern of digit groups isn't consistent, sets err to
2085  * ios_base::failbit.
2086  *
2087  * If parsing the string yields a valid value for @a v, @a v is set.
2088  * Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
2089  * Sets err to ios_base::eofbit if the stream is emptied.
2090  *
2091  * @param __in Start of input stream.
2092  * @param __end End of input stream.
2093  * @param __io Source of locale and flags.
2094  * @param __err Error flags to set.
2095  * @param __v Value to format and insert.
2096  * @return Iterator after reading.
2097  */
2098  iter_type
2099  get(iter_type __in, iter_type __end, ios_base& __io,
2100  ios_base::iostate& __err, float& __v) const
2101  { return this->do_get(__in, __end, __io, __err, __v); }
2102 
2103  iter_type
2104  get(iter_type __in, iter_type __end, ios_base& __io,
2105  ios_base::iostate& __err, double& __v) const
2106  { return this->do_get(__in, __end, __io, __err, __v); }
2107 
2108  iter_type
2109  get(iter_type __in, iter_type __end, ios_base& __io,
2110  ios_base::iostate& __err, long double& __v) const
2111  { return this->do_get(__in, __end, __io, __err, __v); }
2112  ///@}
2113 
2114  /**
2115  * @brief Numeric parsing.
2116  *
2117  * Parses the input stream into the pointer variable @a v. It does so
2118  * by calling num_get::do_get().
2119  *
2120  * The input characters are parsed like the scanf %p specifier.
2121  *
2122  * Digit grouping is interpreted according to
2123  * numpunct::grouping() and numpunct::thousands_sep(). If the
2124  * pattern of digit groups isn't consistent, sets err to
2125  * ios_base::failbit.
2126  *
2127  * Note that the digit grouping effect for pointers is a bit ambiguous
2128  * in the standard and shouldn't be relied on. See DR 344.
2129  *
2130  * If parsing the string yields a valid value for @a v, @a v is set.
2131  * Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
2132  * Sets err to ios_base::eofbit if the stream is emptied.
2133  *
2134  * @param __in Start of input stream.
2135  * @param __end End of input stream.
2136  * @param __io Source of locale and flags.
2137  * @param __err Error flags to set.
2138  * @param __v Value to format and insert.
2139  * @return Iterator after reading.
2140  */
2141  iter_type
2142  get(iter_type __in, iter_type __end, ios_base& __io,
2143  ios_base::iostate& __err, void*& __v) const
2144  { return this->do_get(__in, __end, __io, __err, __v); }
2145 
2146  protected:
2147  /// Destructor.
2148  virtual ~num_get() { }
2149 
2150  _GLIBCXX_DEFAULT_ABI_TAG
2151  iter_type
2152  _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
2153  string&) const;
2154 
2155  template<typename _ValueT>
2156  _GLIBCXX_DEFAULT_ABI_TAG
2157  iter_type
2158  _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
2159  _ValueT&) const;
2160 
2161  template<typename _CharT2>
2162  typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type
2163  _M_find(const _CharT2*, size_t __len, _CharT2 __c) const
2164  {
2165  int __ret = -1;
2166  if (__len <= 10)
2167  {
2168  if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len))
2169  __ret = __c - _CharT2('0');
2170  }
2171  else
2172  {
2173  if (__c >= _CharT2('0') && __c <= _CharT2('9'))
2174  __ret = __c - _CharT2('0');
2175  else if (__c >= _CharT2('a') && __c <= _CharT2('f'))
2176  __ret = 10 + (__c - _CharT2('a'));
2177  else if (__c >= _CharT2('A') && __c <= _CharT2('F'))
2178  __ret = 10 + (__c - _CharT2('A'));
2179  }
2180  return __ret;
2181  }
2182 
2183  template<typename _CharT2>
2184  typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value,
2185  int>::__type
2186  _M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const
2187  {
2188  int __ret = -1;
2189  const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c);
2190  if (__q)
2191  {
2192  __ret = __q - __zero;
2193  if (__ret > 15)
2194  __ret -= 6;
2195  }
2196  return __ret;
2197  }
2198 
2199  ///@{
2200  /**
2201  * @brief Numeric parsing.
2202  *
2203  * Parses the input stream into the variable @a v. This function is a
2204  * hook for derived classes to change the value returned. @see get()
2205  * for more details.
2206  *
2207  * @param __beg Start of input stream.
2208  * @param __end End of input stream.
2209  * @param __io Source of locale and flags.
2210  * @param __err Error flags to set.
2211  * @param __v Value to format and insert.
2212  * @return Iterator after reading.
2213  */
2214  virtual iter_type
2215  do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
2216 
2217  virtual iter_type
2218  do_get(iter_type __beg, iter_type __end, ios_base& __io,
2219  ios_base::iostate& __err, long& __v) const
2220  { return _M_extract_int(__beg, __end, __io, __err, __v); }
2221 
2222  virtual iter_type
2223  do_get(iter_type __beg, iter_type __end, ios_base& __io,
2224  ios_base::iostate& __err, unsigned short& __v) const
2225  { return _M_extract_int(__beg, __end, __io, __err, __v); }
2226 
2227  virtual iter_type
2228  do_get(iter_type __beg, iter_type __end, ios_base& __io,
2229  ios_base::iostate& __err, unsigned int& __v) const
2230  { return _M_extract_int(__beg, __end, __io, __err, __v); }
2231 
2232  virtual iter_type
2233  do_get(iter_type __beg, iter_type __end, ios_base& __io,
2234  ios_base::iostate& __err, unsigned long& __v) const
2235  { return _M_extract_int(__beg, __end, __io, __err, __v); }
2236 
2237 #ifdef _GLIBCXX_USE_LONG_LONG
2238  virtual iter_type
2239  do_get(iter_type __beg, iter_type __end, ios_base& __io,
2240  ios_base::iostate& __err, long long& __v) const
2241  { return _M_extract_int(__beg, __end, __io, __err, __v); }
2242 
2243  virtual iter_type
2244  do_get(iter_type __beg, iter_type __end, ios_base& __io,
2245  ios_base::iostate& __err, unsigned long long& __v) const
2246  { return _M_extract_int(__beg, __end, __io, __err, __v); }
2247 #endif
2248 
2249  virtual iter_type
2250  do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const;
2251 
2252  virtual iter_type
2253  do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
2254  double&) const;
2255 
2256  // XXX GLIBCXX_ABI Deprecated
2257 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
2258  // For __gnu_cxx_ldbl128::num_get and __gnu_cxx_ieee128::num_get
2259  // this entry in the vtable is for a 64-bit "long double" with the
2260  // same format as double. This keeps the vtable layout consistent
2261  // with std::num_get (visible when -mlong-double-64 is used).
2262  virtual iter_type
2263  __do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
2264  double&) const;
2265 #else
2266  virtual iter_type
2267  do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
2268  long double&) const;
2269 #endif
2270 
2271  virtual iter_type
2272  do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const;
2273 
2274  // XXX GLIBCXX_ABI Deprecated
2275 #if defined _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT \
2276  && defined __LONG_DOUBLE_IEEE128__
2277  // For __gnu_cxx_ieee128::num_get this entry in the vtable is for
2278  // the non-IEEE 128-bit "long double" (aka "double double"). This
2279  // is consistent with __gnu_cxx_ldbl128::num_get (-mabi=ibmlongdouble)
2280  virtual iter_type
2281  __do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
2282  __ibm128&) const;
2283 #endif
2284 
2285  // XXX GLIBCXX_ABI Deprecated
2286 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
2287  // For __gnu_cxx_ldbl128::num_get and __gnu_cxx_ieee128::num_get
2288  // this entry in the vtable is for the 128-bit "long double" type.
2289  virtual iter_type
2290  do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
2291  long double&) const;
2292 #endif
2293  ///@}
2294  };
2295 
2296  template<typename _CharT, typename _InIter>
2297  locale::id num_get<_CharT, _InIter>::id;
2298 
2299 
2300  /**
2301  * @brief Primary class template num_put.
2302  * @ingroup locales
2303  *
2304  * This facet encapsulates the code to convert a number to a string. It is
2305  * used by the ostream numeric insertion operators.
2306  *
2307  * The num_put template uses protected virtual functions to provide the
2308  * actual results. The public accessors forward the call to the virtual
2309  * functions. These virtual functions are hooks for developers to
2310  * implement the behavior they require from the num_put facet.
2311  */
2312  template<typename _CharT, typename _OutIter>
2313  class num_put : public locale::facet
2314  {
2315  public:
2316  // Types:
2317  ///@{
2318  /// Public typedefs
2319  typedef _CharT char_type;
2320  typedef _OutIter iter_type;
2321  ///@}
2322 
2323  /// Numpunct facet id.
2324  static locale::id id;
2325 
2326  /**
2327  * @brief Constructor performs initialization.
2328  *
2329  * This is the constructor provided by the standard.
2330  *
2331  * @param __refs Passed to the base facet class.
2332  */
2333  explicit
2334  num_put(size_t __refs = 0) : facet(__refs) { }
2335 
2336  /**
2337  * @brief Numeric formatting.
2338  *
2339  * Formats the boolean @a v and inserts it into a stream. It does so
2340  * by calling num_put::do_put().
2341  *
2342  * If ios_base::boolalpha is set, writes ctype<CharT>::truename() or
2343  * ctype<CharT>::falsename(). Otherwise formats @a v as an int.
2344  *
2345  * @param __s Stream to write to.
2346  * @param __io Source of locale and flags.
2347  * @param __fill Char_type to use for filling.
2348  * @param __v Value to format and insert.
2349  * @return Iterator after writing.
2350  */
2351  iter_type
2352  put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
2353  { return this->do_put(__s, __io, __fill, __v); }
2354 
2355  ///@{
2356  /**
2357  * @brief Numeric formatting.
2358  *
2359  * Formats the integral value @a v and inserts it into a
2360  * stream. It does so by calling num_put::do_put().
2361  *
2362  * Formatting is affected by the flag settings in @a io.
2363  *
2364  * The basic format is affected by the value of io.flags() &
2365  * ios_base::basefield. If equal to ios_base::oct, formats like the
2366  * printf %o specifier. Else if equal to ios_base::hex, formats like
2367  * %x or %X with ios_base::uppercase unset or set respectively.
2368  * Otherwise, formats like %d, %ld, %lld for signed and %u, %lu, %llu
2369  * for unsigned values. Note that if both oct and hex are set, neither
2370  * will take effect.
2371  *
2372  * If ios_base::showpos is set, '+' is output before positive values.
2373  * If ios_base::showbase is set, '0' precedes octal values (except 0)
2374  * and '0[xX]' precedes hex values.
2375  *
2376  * The decimal point character used is numpunct::decimal_point().
2377  * Thousands separators are inserted according to
2378  * numpunct::grouping() and numpunct::thousands_sep().
2379  *
2380  * If io.width() is non-zero, enough @a fill characters are inserted to
2381  * make the result at least that wide. If
2382  * (io.flags() & ios_base::adjustfield) == ios_base::left, result is
2383  * padded at the end. If ios_base::internal, then padding occurs
2384  * immediately after either a '+' or '-' or after '0x' or '0X'.
2385  * Otherwise, padding occurs at the beginning.
2386  *
2387  * @param __s Stream to write to.
2388  * @param __io Source of locale and flags.
2389  * @param __fill Char_type to use for filling.
2390  * @param __v Value to format and insert.
2391  * @return Iterator after writing.
2392  */
2393  iter_type
2394  put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
2395  { return this->do_put(__s, __io, __fill, __v); }
2396 
2397  iter_type
2398  put(iter_type __s, ios_base& __io, char_type __fill,
2399  unsigned long __v) const
2400  { return this->do_put(__s, __io, __fill, __v); }
2401 
2402 #ifdef _GLIBCXX_USE_LONG_LONG
2403  iter_type
2404  put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
2405  { return this->do_put(__s, __io, __fill, __v); }
2406 
2407  iter_type
2408  put(iter_type __s, ios_base& __io, char_type __fill,
2409  unsigned long long __v) const
2410  { return this->do_put(__s, __io, __fill, __v); }
2411 #endif
2412  ///@}
2413 
2414  ///@{
2415  /**
2416  * @brief Numeric formatting.
2417  *
2418  * Formats the floating point value @a v and inserts it into a stream.
2419  * It does so by calling num_put::do_put().
2420  *
2421  * Formatting is affected by the flag settings in @a io.
2422  *
2423  * The basic format is affected by the value of io.flags() &
2424  * ios_base::floatfield. If equal to ios_base::fixed, formats like the
2425  * printf %f specifier. Else if equal to ios_base::scientific, formats
2426  * like %e or %E with ios_base::uppercase unset or set respectively.
2427  * Otherwise, formats like %g or %G depending on uppercase. Note that
2428  * if both fixed and scientific are set, the effect will also be like
2429  * %g or %G.
2430  *
2431  * The output precision is given by io.precision(). This precision is
2432  * capped at numeric_limits::digits10 + 2 (different for double and
2433  * long double). The default precision is 6.
2434  *
2435  * If ios_base::showpos is set, '+' is output before positive values.
2436  * If ios_base::showpoint is set, a decimal point will always be
2437  * output.
2438  *
2439  * The decimal point character used is numpunct::decimal_point().
2440  * Thousands separators are inserted according to
2441  * numpunct::grouping() and numpunct::thousands_sep().
2442  *
2443  * If io.width() is non-zero, enough @a fill characters are inserted to
2444  * make the result at least that wide. If
2445  * (io.flags() & ios_base::adjustfield) == ios_base::left, result is
2446  * padded at the end. If ios_base::internal, then padding occurs
2447  * immediately after either a '+' or '-' or after '0x' or '0X'.
2448  * Otherwise, padding occurs at the beginning.
2449  *
2450  * @param __s Stream to write to.
2451  * @param __io Source of locale and flags.
2452  * @param __fill Char_type to use for filling.
2453  * @param __v Value to format and insert.
2454  * @return Iterator after writing.
2455  */
2456  iter_type
2457  put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
2458  { return this->do_put(__s, __io, __fill, __v); }
2459 
2460  iter_type
2461  put(iter_type __s, ios_base& __io, char_type __fill,
2462  long double __v) const
2463  { return this->do_put(__s, __io, __fill, __v); }
2464  ///@}
2465 
2466  /**
2467  * @brief Numeric formatting.
2468  *
2469  * Formats the pointer value @a v and inserts it into a stream. It
2470  * does so by calling num_put::do_put().
2471  *
2472  * This function formats @a v as an unsigned long with ios_base::hex
2473  * and ios_base::showbase set.
2474  *
2475  * @param __s Stream to write to.
2476  * @param __io Source of locale and flags.
2477  * @param __fill Char_type to use for filling.
2478  * @param __v Value to format and insert.
2479  * @return Iterator after writing.
2480  */
2481  iter_type
2482  put(iter_type __s, ios_base& __io, char_type __fill,
2483  const void* __v) const
2484  { return this->do_put(__s, __io, __fill, __v); }
2485 
2486  protected:
2487  template<typename _ValueT>
2488  iter_type
2489  _M_insert_float(iter_type, ios_base& __io, char_type __fill,
2490  char __mod, _ValueT __v) const;
2491 
2492  void
2493  _M_group_float(const char* __grouping, size_t __grouping_size,
2494  char_type __sep, const char_type* __p, char_type* __new,
2495  char_type* __cs, int& __len) const;
2496 
2497  template<typename _ValueT>
2498  iter_type
2499  _M_insert_int(iter_type, ios_base& __io, char_type __fill,
2500  _ValueT __v) const;
2501 
2502  void
2503  _M_group_int(const char* __grouping, size_t __grouping_size,
2504  char_type __sep, ios_base& __io, char_type* __new,
2505  char_type* __cs, int& __len) const;
2506 
2507  void
2508  _M_pad(char_type __fill, streamsize __w, ios_base& __io,
2509  char_type* __new, const char_type* __cs, int& __len) const;
2510 
2511  /// Destructor.
2512  virtual
2513  ~num_put() { }
2514 
2515  ///@{
2516  /**
2517  * @brief Numeric formatting.
2518  *
2519  * These functions do the work of formatting numeric values and
2520  * inserting them into a stream. This function is a hook for derived
2521  * classes to change the value returned.
2522  *
2523  * @param __s Stream to write to.
2524  * @param __io Source of locale and flags.
2525  * @param __fill Char_type to use for filling.
2526  * @param __v Value to format and insert.
2527  * @return Iterator after writing.
2528  */
2529  virtual iter_type
2530  do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const;
2531 
2532  virtual iter_type
2533  do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
2534  { return _M_insert_int(__s, __io, __fill, __v); }
2535 
2536  virtual iter_type
2537  do_put(iter_type __s, ios_base& __io, char_type __fill,
2538  unsigned long __v) const
2539  { return _M_insert_int(__s, __io, __fill, __v); }
2540 
2541 #ifdef _GLIBCXX_USE_LONG_LONG
2542  virtual iter_type
2543  do_put(iter_type __s, ios_base& __io, char_type __fill,
2544  long long __v) const
2545  { return _M_insert_int(__s, __io, __fill, __v); }
2546 
2547  virtual iter_type
2548  do_put(iter_type __s, ios_base& __io, char_type __fill,
2549  unsigned long long __v) const
2550  { return _M_insert_int(__s, __io, __fill, __v); }
2551 #endif
2552 
2553  virtual iter_type
2554  do_put(iter_type, ios_base&, char_type, double) const;
2555 
2556  // XXX GLIBCXX_ABI Deprecated
2557 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
2558  virtual iter_type
2559  __do_put(iter_type, ios_base&, char_type, double) const;
2560 #else
2561  virtual iter_type
2562  do_put(iter_type, ios_base&, char_type, long double) const;
2563 #endif
2564 
2565  virtual iter_type
2566  do_put(iter_type, ios_base&, char_type, const void*) const;
2567 
2568  // XXX GLIBCXX_ABI Deprecated
2569 #if defined _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT \
2570  && defined __LONG_DOUBLE_IEEE128__
2571  virtual iter_type
2572  __do_put(iter_type, ios_base&, char_type, __ibm128) const;
2573 #endif
2574 
2575  // XXX GLIBCXX_ABI Deprecated
2576 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
2577  virtual iter_type
2578  do_put(iter_type, ios_base&, char_type, long double) const;
2579 #endif
2580  ///@}
2581  };
2582 
2583  template <typename _CharT, typename _OutIter>
2584  locale::id num_put<_CharT, _OutIter>::id;
2585 
2586 _GLIBCXX_END_NAMESPACE_LDBL
2587 
2588  // Subclause convenience interfaces, inlines.
2589  // NB: These are inline because, when used in a loop, some compilers
2590  // can hoist the body out of the loop; then it's just as fast as the
2591  // C is*() function.
2592 
2593  /// Convenience interface to ctype.is(ctype_base::space, __c).
2594  template<typename _CharT>
2595  inline bool
2596  isspace(_CharT __c, const locale& __loc)
2597  { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }
2598 
2599  /// Convenience interface to ctype.is(ctype_base::print, __c).
2600  template<typename _CharT>
2601  inline bool
2602  isprint(_CharT __c, const locale& __loc)
2603  { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }
2604 
2605  /// Convenience interface to ctype.is(ctype_base::cntrl, __c).
2606  template<typename _CharT>
2607  inline bool
2608  iscntrl(_CharT __c, const locale& __loc)
2609  { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }
2610 
2611  /// Convenience interface to ctype.is(ctype_base::upper, __c).
2612  template<typename _CharT>
2613  inline bool
2614  isupper(_CharT __c, const locale& __loc)
2615  { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }
2616 
2617  /// Convenience interface to ctype.is(ctype_base::lower, __c).
2618  template<typename _CharT>
2619  inline bool
2620  islower(_CharT __c, const locale& __loc)
2621  { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }
2622 
2623  /// Convenience interface to ctype.is(ctype_base::alpha, __c).
2624  template<typename _CharT>
2625  inline bool
2626  isalpha(_CharT __c, const locale& __loc)
2627  { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }
2628 
2629  /// Convenience interface to ctype.is(ctype_base::digit, __c).
2630  template<typename _CharT>
2631  inline bool
2632  isdigit(_CharT __c, const locale& __loc)
2633  { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }
2634 
2635  /// Convenience interface to ctype.is(ctype_base::punct, __c).
2636  template<typename _CharT>
2637  inline bool
2638  ispunct(_CharT __c, const locale& __loc)
2639  { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }
2640 
2641  /// Convenience interface to ctype.is(ctype_base::xdigit, __c).
2642  template<typename _CharT>
2643  inline bool
2644  isxdigit(_CharT __c, const locale& __loc)
2645  { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }
2646 
2647  /// Convenience interface to ctype.is(ctype_base::alnum, __c).
2648  template<typename _CharT>
2649  inline bool
2650  isalnum(_CharT __c, const locale& __loc)
2651  { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }
2652 
2653  /// Convenience interface to ctype.is(ctype_base::graph, __c).
2654  template<typename _CharT>
2655  inline bool
2656  isgraph(_CharT __c, const locale& __loc)
2657  { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }
2658 
2659 #if __cplusplus >= 201103L
2660  /// Convenience interface to ctype.is(ctype_base::blank, __c).
2661  template<typename _CharT>
2662  inline bool
2663  isblank(_CharT __c, const locale& __loc)
2664  { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::blank, __c); }
2665 #endif
2666 
2667  /// Convenience interface to ctype.toupper(__c).
2668  template<typename _CharT>
2669  inline _CharT
2670  toupper(_CharT __c, const locale& __loc)
2671  { return use_facet<ctype<_CharT> >(__loc).toupper(__c); }
2672 
2673  /// Convenience interface to ctype.tolower(__c).
2674  template<typename _CharT>
2675  inline _CharT
2676  tolower(_CharT __c, const locale& __loc)
2677  { return use_facet<ctype<_CharT> >(__loc).tolower(__c); }
2678 
2679 _GLIBCXX_END_NAMESPACE_VERSION
2680 } // namespace std
2681 
2682 # include <bits/locale_facets.tcc>
2683 
2684 #endif
iter_type put(iter_type __s, ios_base &__io, char_type __fill, unsigned long __v) const
Numeric formatting.
virtual iter_type do_get(iter_type, iter_type, ios_base &, ios_base::iostate &, bool &) const
Numeric parsing.
char_type tolower(char_type __c) const
Convert to lowercase.
_CharT char_type
Typedef for the template parameter.
virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base &__io, ios_base::iostate &__err, unsigned long &__v) const
Numeric parsing.
static locale::id id
Numpunct facet id.
class ctype_byname [22.2.1.2].
static locale::id id
The facet id for ctype<char>
const char_type * narrow(const char_type *__lo, const char_type *__hi, char __dfault, char *__to) const
Narrow array to char array.
bool isspace(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::space, __c).
iter_type put(iter_type __s, ios_base &__io, char_type __fill, long long __v) const
Numeric formatting.
Primary class template ctype facet.This template class defines classification and conversion function...
_CharT char_type
Public typedefs.
ptrdiff_t streamsize
Integral type for I/O operation counts and buffer sizes.
Definition: postypes.h:98
char_type widen(char __c) const
Widen char.
char_type toupper(char_type __c) const
Convert to uppercase.
num_get(size_t __refs=0)
Constructor performs initialization.
const char_type * tolower(char_type *__lo, const char_type *__hi) const
Convert array to lowercase.
bool isblank(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::blank, __c).
virtual ~num_get()
Destructor.
virtual bool do_is(mask __m, char_type __c) const
Test char_type classification.
Primary class template numpunct.This facet stores several pieces of information related to printing a...
Facet ID class.The ID class provides facets with an index used to identify them. Every facet class mu...
virtual char_type do_toupper(char_type __c) const
Convert to uppercase.
virtual char_type do_tolower(char_type __c) const
Convert to lowercase.
char narrow(char_type __c, char __dfault) const
Narrow char_type to char.
string_type truename() const
Return string representation of bool true.
iter_type put(iter_type __s, ios_base &__io, char_type __fill, long double __v) const
Numeric formatting.
virtual const char_type * do_scan_is(mask __m, const char_type *__lo, const char_type *__hi) const
Find char_type matching mask.
virtual iter_type do_put(iter_type __s, ios_base &__io, char_type __fill, bool __v) const
Numeric formatting.
basic_string< _CharT > string_type
Public typedefs.
string_type falsename() const
Return string representation of bool false.
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
_OutIter iter_type
Public typedefs.
virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base &__io, ios_base::iostate &__err, unsigned short &__v) const
Numeric parsing.
Primary class template num_get.This facet encapsulates the code to parse and return a number from a s...
char_type thousands_sep() const
Return thousands separator character.
virtual const char_type * do_narrow(const char_type *__lo, const char_type *__hi, char __dfault, char *__to) const
Narrow char array to char array.
Localization functionality base class.The facet class is the base class for a localization feature...
bool isalnum(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::alnum, __c).
virtual char_type do_tolower(char_type __c) const =0
Convert to lowercase.
bool isupper(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::upper, __c).
numpunct(size_t __refs=0)
Numpunct constructor.
bool islower(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::lower, __c).
Common base for ctype facet.
virtual iter_type do_put(iter_type __s, ios_base &__io, char_type __fill, unsigned long __v) const
Numeric formatting.
const char_type * scan_not(mask __m, const char_type *__lo, const char_type *__hi) const
Find char_type not matching a mask.
virtual const char * do_widen(const char *__lo, const char *__hi, char_type *__to) const
Widen char array.
string grouping() const
Return grouping specification.
const mask * table() const
Returns a pointer to the mask table provided to the constructor, or the default from classic_table() ...
virtual iter_type do_put(iter_type __s, ios_base &__io, char_type __fill, long __v) const
Numeric formatting.
virtual const char_type * do_scan_is(mask __m, const char_type *__lo, const char_type *__hi) const =0
Find char_type matching mask.
const char * widen(const char *__lo, const char *__hi, char_type *__to) const
Widen array to char_type.
char_type toupper(char_type __c) const
Convert to uppercase.
_Ios_Iostate iostate
This is a bitmask type.
Definition: ios_base.h:416
char narrow(char_type __c, char __dfault) const
Narrow char.
const char_type * narrow(const char_type *__lo, const char_type *__hi, char __dfault, char *__to) const
Narrow char array.
Base class for ctype.
Definition: ctype_base.h:41
_CharT char_type
Public typedefs.
virtual const char_type * do_scan_not(mask __m, const char_type *__lo, const char_type *__hi) const
Find char_type not matching mask.
facet(size_t __refs=0)
Facet constructor.
bool isxdigit(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::xdigit, __c).
virtual char_type do_decimal_point() const
Return decimal point character.
const _CharT * c_str() const noexcept
Return const pointer to null-terminated contents.
bool isdigit(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::digit, __c).
virtual iter_type do_put(iter_type __s, ios_base &__io, char_type __fill, long long __v) const
Numeric formatting.
bool ispunct(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::punct, __c).
virtual char_type do_toupper(char_type __c) const =0
Convert to uppercase.
virtual string do_grouping() const
Return grouping specification.
const char_type * scan_is(mask __m, const char_type *__lo, const char_type *__hi) const
Find char_type matching a mask.
static locale::id id
Numpunct facet id.
num_put(size_t __refs=0)
Constructor performs initialization.
class numpunct_byname [22.2.3.2].
virtual char do_narrow(char_type __c, char __dfault) const
Narrow char.
const char_type * toupper(char_type *__lo, const char_type *__hi) const
Convert array to uppercase.
iter_type put(iter_type __s, ios_base &__io, char_type __fill, bool __v) const
Numeric formatting.
iter_type put(iter_type __s, ios_base &__io, char_type __fill, double __v) const
Numeric formatting.
char_type widen(char __c) const
Widen char to char_type.
bool isgraph(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::graph, __c).
char_type tolower(char_type __c) const
Convert to lowercase.
bool is(mask __m, char_type __c) const
Test char_type classification.
virtual string_type do_falsename() const
Return string representation of bool false.
_CharT char_type
Public typedefs.
Primary class template num_put.This facet encapsulates the code to convert a number to a string...
const char_type * toupper(char_type *__lo, const char_type *__hi) const
Convert array to uppercase.
char char_type
Typedef for the template parameter char.
virtual char_type do_widen(char __c) const =0
Widen char.
virtual char do_narrow(char_type, char __dfault) const
Narrow char_type to char.
char_type decimal_point() const
Return decimal point character.
virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base &__io, ios_base::iostate &__err, unsigned long long &__v) const
Numeric parsing.
virtual const char_type * do_scan_not(mask __m, const char_type *__lo, const char_type *__hi) const =0
Find char_type not matching mask.
bool isalpha(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::alpha, __c).
virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base &__io, ios_base::iostate &__err, long &__v) const
Numeric parsing.
_InIter iter_type
Public typedefs.
bool iscntrl(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::cntrl, __c).
static locale::id id
The facet id for ctype<wchar_t>
virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base &__io, ios_base::iostate &__err, unsigned int &__v) const
Numeric parsing.
const char * widen(const char *__lo, const char *__hi, char_type *__to) const
Widen char array.
numpunct(__c_locale __cloc, size_t __refs=0)
Internal constructor. Not for general use.
_CharT toupper(_CharT __c, const locale &__loc)
Convenience interface to ctype.toupper(__c).
wchar_t char_type
Typedef for the template parameter wchar_t.
virtual ~num_put()
Destructor.
virtual iter_type do_put(iter_type __s, ios_base &__io, char_type __fill, unsigned long long __v) const
Numeric formatting.
virtual char do_narrow(char_type __c, char __dfault) const =0
Narrow char_type to char.
const char_type * tolower(char_type *__lo, const char_type *__hi) const
Convert array to lowercase.
_CharT tolower(_CharT __c, const locale &__loc)
Convenience interface to ctype.tolower(__c).
Container class for localization functionality.The locale class is first a class wrapper for C librar...
virtual string_type do_truename() const
Return string representation of bool true.
iter_type put(iter_type __s, ios_base &__io, char_type __fill, long __v) const
Numeric formatting.
virtual char_type do_widen(char __c) const
Widen char.
static locale::id id
Numpunct facet id.
virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base &__io, ios_base::iostate &__err, long long &__v) const
Numeric parsing.
ISO C++ entities toplevel namespace is std.
iter_type put(iter_type __s, ios_base &__io, char_type __fill, const void *__v) const
Numeric formatting.
virtual ~numpunct()
Destructor.
virtual char_type do_thousands_sep() const
Return thousands separator character.
virtual bool do_is(mask __m, char_type __c) const =0
Test char_type classification.
numpunct(__cache_type *__cache, size_t __refs=0)
Internal constructor. Not for general use.
bool isprint(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::print, __c).
const char_type * is(const char_type *__lo, const char_type *__hi, mask *__vec) const
Return a mask array.
iter_type put(iter_type __s, ios_base &__io, char_type __fill, unsigned long long __v) const
Numeric formatting.
static locale::id id
The facet id for ctype<char_type>