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