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>
48 #include <bits/streambuf_iterator.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>
153  class __ctype_abstract_base : public locale::facet, public ctype_base
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;
1680  typedef basic_string<_CharT> string_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
1739  decimal_point() const
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
1752  thousands_sep() const
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
1826  do_decimal_point() const
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
1838  do_thousands_sep() const
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
1877  do_falsename() const
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<>
1889  numpunct<char>::~numpunct();
1890 
1891  template<>
1892  void
1893  numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
1894 
1895 #ifdef _GLIBCXX_USE_WCHAR_T
1896  template<>
1897  numpunct<wchar_t>::~numpunct();
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;
1910  typedef basic_string<_CharT> string_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
std::numpunct::decimal_point
char_type decimal_point() const
Return decimal point character.
Definition: locale_facets.h:1739
std::__ctype_abstract_base::is
const char_type * is(const char_type *__lo, const char_type *__hi, mask *__vec) const
Return a mask array.
Definition: locale_facets.h:189
std::ctype< char >::do_widen
virtual const char * do_widen(const char *__lo, const char *__hi, char_type *__to) const
Widen char array.
Definition: locale_facets.h:1110
std::numpunct::truename
string_type truename() const
Return string representation of bool true.
Definition: locale_facets.h:1796
std::ctype< wchar_t >::id
static locale::id id
The facet id for ctype<wchar_t>
Definition: locale_facets.h:1212
std::isalpha
bool isalpha(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::alpha, __c).
Definition: locale_facets.h:2626
std::isspace
bool isspace(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::space, __c).
Definition: locale_facets.h:2596
std::locale::id
Facet ID class.
Definition: locale_classes.h:486
std::numpunct::do_truename
virtual string_type do_truename() const
Return string representation of bool true.
Definition: locale_facets.h:1864
std::__ctype_abstract_base
Common base for ctype facet.
Definition: locale_facets.h:154
std::__ctype_abstract_base::do_widen
virtual const char * do_widen(const char *__lo, const char *__hi, char_type *__to) const =0
Widen char array.
std::numpunct::do_falsename
virtual string_type do_falsename() const
Return string representation of bool false.
Definition: locale_facets.h:1877
std::ctype< char >::tolower
const char_type * tolower(char_type *__lo, const char_type *__hi) const
Convert array to lowercase.
Definition: locale_facets.h:855
std::__ctype_abstract_base::narrow
const char_type * narrow(const char_type *__lo, const char_type *__hi, char __dfault, char *__to) const
Narrow array to char array.
Definition: locale_facets.h:356
std::ctype::do_scan_not
virtual const char_type * do_scan_not(mask __m, const char_type *__lo, const char_type *__hi) const
Find char_type not matching mask.
std::__ctype_abstract_base::tolower
char_type tolower(char_type __c) const
Convert to lowercase.
Definition: locale_facets.h:264
std::toupper
_CharT toupper(_CharT __c, const locale &__loc)
Convenience interface to ctype.toupper(__c).
Definition: locale_facets.h:2670
std::ctype< wchar_t >::do_is
virtual bool do_is(mask __m, char_type __c) const
Test wchar_t classification.
std::numpunct::do_decimal_point
virtual char_type do_decimal_point() const
Return decimal point character.
Definition: locale_facets.h:1826
std::ctype::do_scan_is
virtual const char_type * do_scan_is(mask __m, const char_type *__lo, const char_type *__hi) const
Find char_type matching mask.
std::__ctype_abstract_base::do_scan_not
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.
std::streamsize
ptrdiff_t streamsize
Integral type for I/O operation counts and buffer sizes.
Definition: postypes.h:98
std::tolower
_CharT tolower(_CharT __c, const locale &__loc)
Convenience interface to ctype.tolower(__c).
Definition: locale_facets.h:2676
std::__ctype_abstract_base::do_widen
virtual char_type do_widen(char __c) const =0
Widen char.
locale_facets.tcc
std::isalnum
bool isalnum(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::alnum, __c).
Definition: locale_facets.h:2650
std::__ctype_abstract_base::is
bool is(mask __m, char_type __c) const
Test char_type classification.
Definition: locale_facets.h:172
std::num_put::~num_put
virtual ~num_put()
Destructor.
Definition: locale_facets.h:2513
std::__ctype_abstract_base::scan_is
const char_type * scan_is(mask __m, const char_type *__lo, const char_type *__hi) const
Find char_type matching a mask.
Definition: locale_facets.h:205
std::ctype< wchar_t >::do_widen
virtual const char * do_widen(const char *__lo, const char *__hi, char_type *__to) const
Widen char array to wchar_t array.
streambuf_iterator.h
std::num_get::char_type
_CharT char_type
Public typedefs.
Definition: locale_facets.h:1961
std::ctype< wchar_t >::ctype
ctype(__c_locale __cloc, size_t __refs=0)
Constructor performs static initialization.
std::ctype< char >::narrow
const char_type * narrow(const char_type *__lo, const char_type *__hi, char __dfault, char *__to) const
Narrow char array.
Definition: locale_facets.h:967
cpp_type_traits.h
std::__ctype_abstract_base::do_tolower
virtual const char_type * do_tolower(char_type *__lo, const char_type *__hi) const =0
Convert array to lowercase.
std::numpunct::thousands_sep
char_type thousands_sep() const
Return thousands separator character.
Definition: locale_facets.h:1752
std::numpunct::do_grouping
virtual string do_grouping() const
Return grouping specification.
Definition: locale_facets.h:1851
iosfwd
std::ctype_byname
class ctype_byname [22.2.1.2].
Definition: locale_facets.h:1482
std::ctype< wchar_t >::do_scan_not
virtual const char_type * do_scan_not(mask __m, const char_type *__lo, const char_type *__hi) const
Find wchar_t not matching mask.
type_traits.h
std::ctype< wchar_t >::char_type
wchar_t char_type
Typedef for the template parameter wchar_t.
Definition: locale_facets.h:1194
std::num_put::num_put
num_put(size_t __refs=0)
Constructor performs initialization.
Definition: locale_facets.h:2334
std
ISO C++ entities toplevel namespace is std.
std::basic_string< _CharT >
std::ctype< wchar_t >::do_tolower
virtual const char_type * do_tolower(char_type *__lo, const char_type *__hi) const
Convert array to lowercase.
std::ctype::id
static locale::id id
The facet id for ctype<char_type>
Definition: locale_facets.h:623
std::__ctype_abstract_base::tolower
const char_type * tolower(char_type *__lo, const char_type *__hi) const
Convert array to lowercase.
Definition: locale_facets.h:279
std::ctype< wchar_t >::do_scan_is
virtual const char_type * do_scan_is(mask __m, const char_type *__lo, const char_type *__hi) const
Find wchar_t matching mask.
std::ctype< char >::ctype
ctype(const mask *__table=0, bool __del=false, size_t __refs=0)
Constructor performs initialization.
std::numpunct::do_thousands_sep
virtual char_type do_thousands_sep() const
Return thousands separator character.
Definition: locale_facets.h:1838
std::ctype::do_widen
virtual char_type do_widen(char __c) const
Widen char.
std::num_put::char_type
_CharT char_type
Public typedefs.
Definition: locale_facets.h:2319
std::__ctype_abstract_base::do_is
virtual const char_type * do_is(const char_type *__lo, const char_type *__hi, mask *__vec) const =0
Return a mask array.
std::num_get::get
iter_type get(iter_type __in, iter_type __end, ios_base &__io, ios_base::iostate &__err, bool &__v) const
Numeric parsing.
Definition: locale_facets.h:2002
std::ctype< char >::toupper
const char_type * toupper(char_type *__lo, const char_type *__hi) const
Convert array to uppercase.
Definition: locale_facets.h:822
std::ios_base::iostate
_Ios_Iostate iostate
This is a bitmask type.
Definition: ios_base.h:416
std::isgraph
bool isgraph(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::graph, __c).
Definition: locale_facets.h:2656
std::isupper
bool isupper(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::upper, __c).
Definition: locale_facets.h:2614
std::__ctype_abstract_base::do_scan_is
virtual const char_type * do_scan_is(mask __m, const char_type *__lo, const char_type *__hi) const =0
Find char_type matching mask.
ios_base.h
std::numpunct::~numpunct
virtual ~numpunct()
Destructor.
std::isxdigit
bool isxdigit(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::xdigit, __c).
Definition: locale_facets.h:2644
std::__ctype_abstract_base::do_toupper
virtual char_type do_toupper(char_type __c) const =0
Convert to uppercase.
std::ctype< char >::id
static locale::id id
The facet id for ctype<char>
Definition: locale_facets.h:706
std::ctype::do_widen
virtual const char * do_widen(const char *__lo, const char *__hi, char_type *__dest) const
Widen char array.
std::basic_string::c_str
const _CharT * c_str() const noexcept
Return const pointer to null-terminated contents.
Definition: basic_string.h:5242
std::ctype< wchar_t >::do_toupper
virtual const char_type * do_toupper(char_type *__lo, const char_type *__hi) const
Convert array to uppercase.
std::ctype
Primary class template ctype facet.
Definition: locale_facets.h:616
std::numpunct::numpunct
numpunct(size_t __refs=0)
Numpunct constructor.
Definition: locale_facets.h:1697
std::ctype::do_toupper
virtual char_type do_toupper(char_type __c) const
Convert to uppercase.
std::ctype< wchar_t >::do_widen
virtual char_type do_widen(char __c) const
Widen char to wchar_t.
std::__ctype_abstract_base::do_narrow
virtual char do_narrow(char_type __c, char __dfault) const =0
Narrow char_type to char.
std::numpunct::char_type
_CharT char_type
Public typedefs.
Definition: locale_facets.h:1679
std::numpunct::grouping
string grouping() const
Return grouping specification.
Definition: locale_facets.h:1783
std::num_put::put
iter_type put(iter_type __s, ios_base &__io, char_type __fill, long __v) const
Numeric formatting.
Definition: locale_facets.h:2394
cctype
std::islower
bool islower(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::lower, __c).
Definition: locale_facets.h:2620
std::num_get::get
iter_type get(iter_type __in, iter_type __end, ios_base &__io, ios_base::iostate &__err, long &__v) const
Numeric parsing.
Definition: locale_facets.h:2039
std::num_get::get
iter_type get(iter_type __in, iter_type __end, ios_base &__io, ios_base::iostate &__err, float &__v) const
Numeric parsing.
Definition: locale_facets.h:2099
std::numpunct::numpunct
numpunct(__c_locale __cloc, size_t __refs=0)
Internal constructor. Not for general use.
Definition: locale_facets.h:1725
std::ctype< char >::toupper
char_type toupper(char_type __c) const
Convert to uppercase.
Definition: locale_facets.h:805
std::__ctype_abstract_base::widen
const char * widen(const char *__lo, const char *__hi, char_type *__to) const
Widen array to char_type.
Definition: locale_facets.h:315
std::num_get::id
static locale::id id
Numpunct facet id.
Definition: locale_facets.h:1966
std::ispunct
bool ispunct(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::punct, __c).
Definition: locale_facets.h:2638
std::ctype::do_tolower
virtual const char_type * do_tolower(char_type *__lo, const char_type *__hi) const
Convert array to lowercase.
std::ctype< char >::char_type
char char_type
Typedef for the template parameter char.
Definition: locale_facets.h:689
std::numpunct_byname
class numpunct_byname [22.2.3.2].
Definition: locale_facets.h:1907
std::__ctype_abstract_base::do_is
virtual bool do_is(mask __m, char_type __c) const =0
Test char_type classification.
std::ctype< char >::widen
const char * widen(const char *__lo, const char *__hi, char_type *__to) const
Widen char array.
Definition: locale_facets.h:902
std::__ctype_abstract_base::widen
char_type widen(char __c) const
Widen char to char_type.
Definition: locale_facets.h:296
streambuf
std::ctype< wchar_t >::ctype
ctype(size_t __refs=0)
Constructor performs initialization.
std::ctype::do_narrow
virtual char do_narrow(char_type, char __dfault) const
Narrow char_type to char.
std::ctype< char >::classic_table
static const mask * classic_table()
Returns a pointer to the C locale mask table.
std::ctype::do_is
virtual const char_type * do_is(const char_type *__lo, const char_type *__hi, mask *__vec) const
Return a mask array.
std::ctype< char >::table
const mask * table() const
Returns a pointer to the mask table provided to the constructor, or the default from classic_table() ...
Definition: locale_facets.h:986
std::ctype< char >::narrow
char narrow(char_type __c, char __dfault) const
Narrow char.
Definition: locale_facets.h:934
cwctype
ctype_base.h
std::ctype< wchar_t >::do_narrow
virtual const char_type * do_narrow(const char_type *__lo, const char_type *__hi, char __dfault, char *__to) const
Narrow wchar_t array to char array.
std::__ctype_abstract_base::char_type
_CharT char_type
Typedef for the template parameter.
Definition: locale_facets.h:158
std::__ctype_abstract_base::toupper
char_type toupper(char_type __c) const
Convert to uppercase.
Definition: locale_facets.h:235
std::__ctype_abstract_base::toupper
const char_type * toupper(char_type *__lo, const char_type *__hi) const
Convert array to uppercase.
Definition: locale_facets.h:250
std::ctype::do_tolower
virtual char_type do_tolower(char_type __c) const
Convert to lowercase.
std::num_put::id
static locale::id id
Numpunct facet id.
Definition: locale_facets.h:2324
std::numpunct::id
static locale::id id
Numpunct facet id.
Definition: locale_facets.h:1689
std::ctype< wchar_t >::do_tolower
virtual char_type do_tolower(char_type __c) const
Convert to lowercase.
std::ctype< char >::do_narrow
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.
Definition: locale_facets.h:1163
std::numpunct::falsename
string_type falsename() const
Return string representation of bool false.
Definition: locale_facets.h:1809
std::num_get::~num_get
virtual ~num_get()
Destructor.
Definition: locale_facets.h:2148
std::ctype::do_toupper
virtual const char_type * do_toupper(char_type *__lo, const char_type *__hi) const
Convert array to uppercase.
std::isdigit
bool isdigit(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::digit, __c).
Definition: locale_facets.h:2632
std::num_put::put
iter_type put(iter_type __s, ios_base &__io, char_type __fill, double __v) const
Numeric formatting.
Definition: locale_facets.h:2457
std::ctype< wchar_t >::do_narrow
virtual char do_narrow(char_type __c, char __dfault) const
Narrow wchar_t to char.
std::locale::facet
Localization functionality base class.
Definition: locale_classes.h:374
std::__ctype_abstract_base::do_narrow
virtual const char_type * do_narrow(const char_type *__lo, const char_type *__hi, char __dfault, char *__to) const =0
Narrow char_type array to char.
std::num_put::put
iter_type put(iter_type __s, ios_base &__io, char_type __fill, const void *__v) const
Numeric formatting.
Definition: locale_facets.h:2482
std::ctype< wchar_t >::do_toupper
virtual char_type do_toupper(char_type __c) const
Convert to uppercase.
std::ctype< char >::do_narrow
virtual char do_narrow(char_type __c, char __dfault) const
Narrow char.
Definition: locale_facets.h:1137
std::ctype< char >::widen
char_type widen(char __c) const
Widen char.
Definition: locale_facets.h:875
std::__ctype_abstract_base::do_toupper
virtual const char_type * do_toupper(char_type *__lo, const char_type *__hi) const =0
Convert array to uppercase.
std::num_put::do_put
virtual iter_type do_put(iter_type __s, ios_base &__io, char_type __fill, bool __v) const
Numeric formatting.
Definition: locale_facets.tcc:1124
std::ctype< wchar_t >::~ctype
virtual ~ctype()
Destructor.
std::ctype< wchar_t >::do_is
virtual const char_type * do_is(const char_type *__lo, const char_type *__hi, mask *__vec) const
Return a mask array.
std::__ctype_abstract_base::do_tolower
virtual char_type do_tolower(char_type __c) const =0
Convert to lowercase.
std::ctype< char >::tolower
char_type tolower(char_type __c) const
Convert to lowercase.
Definition: locale_facets.h:838
std::ctype::do_is
virtual bool do_is(mask __m, char_type __c) const
Test char_type classification.
std::num_put::put
iter_type put(iter_type __s, ios_base &__io, char_type __fill, bool __v) const
Numeric formatting.
Definition: locale_facets.h:2352
ctype_inline.h
std::num_put
Primary class template num_put.
Definition: locale_facets.h:2314
std::num_get::num_get
num_get(size_t __refs=0)
Constructor performs initialization.
Definition: locale_facets.h:1976
std::locale::facet::facet
facet(size_t __refs=0)
Facet constructor.
Definition: locale_classes.h:405
std::iscntrl
bool iscntrl(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::cntrl, __c).
Definition: locale_facets.h:2608
std::num_get::get
iter_type get(iter_type __in, iter_type __end, ios_base &__io, ios_base::iostate &__err, void *&__v) const
Numeric parsing.
Definition: locale_facets.h:2142
std::num_get::do_get
virtual iter_type do_get(iter_type, iter_type, ios_base &, ios_base::iostate &, bool &) const
Numeric parsing.
Definition: locale_facets.tcc:595
std::isblank
bool isblank(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::blank, __c).
Definition: locale_facets.h:2663
std::numpunct
Primary class template numpunct.
Definition: locale_facets.h:1674
std::locale
Container class for localization functionality.
Definition: locale_classes.h:63
std::ctype< char >::ctype
ctype(__c_locale __cloc, const mask *__table=0, bool __del=false, size_t __refs=0)
Constructor performs static initialization.
std::ctype::do_narrow
virtual const char_type * do_narrow(const char_type *__lo, const char_type *__hi, char __dfault, char *__to) const
Narrow char_type array to char.
std::isprint
bool isprint(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::print, __c).
Definition: locale_facets.h:2602
std::numpunct::numpunct
numpunct(__cache_type *__cache, size_t __refs=0)
Internal constructor. Not for general use.
Definition: locale_facets.h:1711
numeric_traits.h
operator=
auto_ptr & operator=(auto_ptr &__a)
auto_ptr assignment operator.
Definition: auto_ptr.h:47
std::__ctype_abstract_base::narrow
char narrow(char_type __c, char __dfault) const
Narrow char_type to char.
Definition: locale_facets.h:334
std::num_get
Primary class template num_get.
Definition: locale_facets.h:1956
std::ios_base
The base of the I/O class hierarchy.
Definition: ios_base.h:229
std::ctype_base
Base class for ctype.
Definition: ctype_base.h:42
std::__ctype_abstract_base::scan_not
const char_type * scan_not(mask __m, const char_type *__lo, const char_type *__hi) const
Find char_type not matching a mask.
Definition: locale_facets.h:221