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