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
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 locale_facets.h
28  * This is an internal header file, included by other library headers.
29  * You should not attempt to use it directly.
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 _GLIBCXX_BEGIN_NAMESPACE(std)
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 _Tv and store results.
62  // NB: This is specialized for all required types, there is no
63  // generic definition.
64  template<typename _Tv>
65  void
66  __convert_to_v(const char* __in, _Tv& __out, ios_base::iostate& __err,
67  const __c_locale& __cloc);
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&);
74 
75  template<>
76  void
77  __convert_to_v(const char*, double&, ios_base::iostate&,
78  const __c_locale&);
79 
80  template<>
81  void
82  __convert_to_v(const char*, long double&, ios_base::iostate&,
83  const __c_locale&);
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  // Common base for ctype<_CharT>.
134  /**
135  * @brief Common base for ctype facet
136  *
137  * This template class provides implementations of the public functions
138  * that forward to the protected virtual functions.
139  *
140  * This template also provides abstract stubs for the protected virtual
141  * functions.
142  */
143  template<typename _CharT>
145  {
146  public:
147  // Types:
148  /// Typedef for the template parameter
149  typedef _CharT char_type;
150 
151  /**
152  * @brief Test char_type classification.
153  *
154  * This function finds a mask M for @a c and compares it to mask @a m.
155  * It does so by returning the value of 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) 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) 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) 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,
537  char_type* __dest) const = 0;
538 
539  /**
540  * @brief Narrow char_type to char
541  *
542  * This virtual function converts the argument to char using the
543  * simplest reasonable transformation. If the conversion fails, dfault
544  * is returned instead.
545  *
546  * do_narrow() is a hook for a derived facet to change the behavior of
547  * narrowing. do_narrow() must always return the same result for the
548  * same input.
549  *
550  * Note: this is not what you want for codepage conversions. See
551  * codecvt for that.
552  *
553  * @param c The char_type to convert.
554  * @param dfault Char to return if conversion fails.
555  * @return The converted char.
556  */
557  virtual char
558  do_narrow(char_type, char __dfault) const = 0;
559 
560  /**
561  * @brief Narrow char_type array to char
562  *
563  * This virtual function converts each char_type in the range [lo,hi) to
564  * char using the simplest reasonable transformation and writes the
565  * results to the destination array. For any element in the input that
566  * cannot be 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* __dest) const = 0;
584  };
585 
586  // NB: Generic, mostly useless implementation.
587  /**
588  * @brief Template ctype facet
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* __dest) const;
659  };
660 
661  template<typename _CharT>
662  locale::id ctype<_CharT>::id;
663 
664  // 22.2.1.3 ctype<char> specialization.
665  /**
666  * @brief The ctype<char> specialization.
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) 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) 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* __dest) const
1099  {
1100  __builtin_memcpy(__dest, __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) 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, char* __dest) const
1152  {
1153  __builtin_memcpy(__dest, __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  // 22.2.1.3 ctype<wchar_t> specialization
1164  /**
1165  * @brief The ctype<wchar_t> specialization.
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;
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) 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) 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) 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* __dest) 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, 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* __dest) const;
1458 
1459  // For use at construction time only.
1460  void
1461  _M_initialize_ctype();
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
1508 
1509 // Include host and configuration specific ctype inlines.
1510 #include <bits/ctype_inline.h>
1511 
1512 _GLIBCXX_BEGIN_NAMESPACE(std)
1513 
1514  // 22.2.2 The numeric category.
1515  class __num_base
1516  {
1517  public:
1518  // NB: Code depends on the order of _S_atoms_out elements.
1519  // Below are the indices into _S_atoms_out.
1520  enum
1521  {
1522  _S_ominus,
1523  _S_oplus,
1524  _S_ox,
1525  _S_oX,
1526  _S_odigits,
1527  _S_odigits_end = _S_odigits + 16,
1528  _S_oudigits = _S_odigits_end,
1529  _S_oudigits_end = _S_oudigits + 16,
1530  _S_oe = _S_odigits + 14, // For scientific notation, 'e'
1531  _S_oE = _S_oudigits + 14, // For scientific notation, 'E'
1532  _S_oend = _S_oudigits_end
1533  };
1534 
1535  // A list of valid numeric literals for output. This array
1536  // contains chars that will be passed through the current locale's
1537  // ctype<_CharT>.widen() and then used to render numbers.
1538  // For the standard "C" locale, this is
1539  // "-+xX0123456789abcdef0123456789ABCDEF".
1540  static const char* _S_atoms_out;
1541 
1542  // String literal of acceptable (narrow) input, for num_get.
1543  // "-+xX0123456789abcdefABCDEF"
1544  static const char* _S_atoms_in;
1545 
1546  enum
1547  {
1548  _S_iminus,
1549  _S_iplus,
1550  _S_ix,
1551  _S_iX,
1552  _S_izero,
1553  _S_ie = _S_izero + 14,
1554  _S_iE = _S_izero + 20,
1555  _S_iend = 26
1556  };
1557 
1558  // num_put
1559  // Construct and return valid scanf format for floating point types.
1560  static void
1561  _S_format_float(const ios_base& __io, char* __fptr, char __mod);
1562  };
1563 
1564  template<typename _CharT>
1565  struct __numpunct_cache : public locale::facet
1566  {
1567  const char* _M_grouping;
1568  size_t _M_grouping_size;
1569  bool _M_use_grouping;
1570  const _CharT* _M_truename;
1571  size_t _M_truename_size;
1572  const _CharT* _M_falsename;
1573  size_t _M_falsename_size;
1574  _CharT _M_decimal_point;
1575  _CharT _M_thousands_sep;
1576 
1577  // A list of valid numeric literals for output: in the standard
1578  // "C" locale, this is "-+xX0123456789abcdef0123456789ABCDEF".
1579  // This array contains the chars after having been passed
1580  // through the current locale's ctype<_CharT>.widen().
1581  _CharT _M_atoms_out[__num_base::_S_oend];
1582 
1583  // A list of valid numeric literals for input: in the standard
1584  // "C" locale, this is "-+xX0123456789abcdefABCDEF"
1585  // This array contains the chars after having been passed
1586  // through the current locale's ctype<_CharT>.widen().
1587  _CharT _M_atoms_in[__num_base::_S_iend];
1588 
1589  bool _M_allocated;
1590 
1591  __numpunct_cache(size_t __refs = 0) : facet(__refs),
1592  _M_grouping(NULL), _M_grouping_size(0), _M_use_grouping(false),
1593  _M_truename(NULL), _M_truename_size(0), _M_falsename(NULL),
1594  _M_falsename_size(0), _M_decimal_point(_CharT()),
1595  _M_thousands_sep(_CharT()), _M_allocated(false)
1596  { }
1597 
1598  ~__numpunct_cache();
1599 
1600  void
1601  _M_cache(const locale& __loc);
1602 
1603  private:
1604  __numpunct_cache&
1605  operator=(const __numpunct_cache&);
1606 
1607  explicit
1608  __numpunct_cache(const __numpunct_cache&);
1609  };
1610 
1611  template<typename _CharT>
1612  __numpunct_cache<_CharT>::~__numpunct_cache()
1613  {
1614  if (_M_allocated)
1615  {
1616  delete [] _M_grouping;
1617  delete [] _M_truename;
1618  delete [] _M_falsename;
1619  }
1620  }
1621 
1622  /**
1623  * @brief Numpunct facet.
1624  *
1625  * This facet stores several pieces of information related to printing and
1626  * scanning numbers, such as the decimal point character. It takes a
1627  * template parameter specifying the char type. The numpunct facet is
1628  * used by streams for many I/O operations involving numbers.
1629  *
1630  * The numpunct template uses protected virtual functions to provide the
1631  * actual results. The public accessors forward the call to the virtual
1632  * functions. These virtual functions are hooks for developers to
1633  * implement the behavior they require from a numpunct facet.
1634  */
1635  template<typename _CharT>
1636  class numpunct : public locale::facet
1637  {
1638  public:
1639  // Types:
1640  //@{
1641  /// Public typedefs
1642  typedef _CharT char_type;
1644  //@}
1645  typedef __numpunct_cache<_CharT> __cache_type;
1646 
1647  protected:
1648  __cache_type* _M_data;
1649 
1650  public:
1651  /// Numpunct facet id.
1652  static locale::id id;
1653 
1654  /**
1655  * @brief Numpunct constructor.
1656  *
1657  * @param refs Refcount to pass to the base class.
1658  */
1659  explicit
1660  numpunct(size_t __refs = 0) : facet(__refs), _M_data(NULL)
1661  { _M_initialize_numpunct(); }
1662 
1663  /**
1664  * @brief Internal constructor. Not for general use.
1665  *
1666  * This is a constructor for use by the library itself to set up the
1667  * predefined locale facets.
1668  *
1669  * @param cache __numpunct_cache object.
1670  * @param refs Refcount to pass to the base class.
1671  */
1672  explicit
1673  numpunct(__cache_type* __cache, size_t __refs = 0)
1674  : facet(__refs), _M_data(__cache)
1675  { _M_initialize_numpunct(); }
1676 
1677  /**
1678  * @brief Internal constructor. Not for general use.
1679  *
1680  * This is a constructor for use by the library itself to set up new
1681  * locales.
1682  *
1683  * @param cloc The "C" locale.
1684  * @param refs Refcount to pass to the base class.
1685  */
1686  explicit
1687  numpunct(__c_locale __cloc, size_t __refs = 0)
1688  : facet(__refs), _M_data(NULL)
1689  { _M_initialize_numpunct(__cloc); }
1690 
1691  /**
1692  * @brief Return decimal point character.
1693  *
1694  * This function returns a char_type to use as a decimal point. It
1695  * does so by returning returning
1696  * numpunct<char_type>::do_decimal_point().
1697  *
1698  * @return @a char_type representing a decimal point.
1699  */
1700  char_type
1702  { return this->do_decimal_point(); }
1703 
1704  /**
1705  * @brief Return thousands separator character.
1706  *
1707  * This function returns a char_type to use as a thousands
1708  * separator. It does so by returning returning
1709  * numpunct<char_type>::do_thousands_sep().
1710  *
1711  * @return char_type representing a thousands separator.
1712  */
1713  char_type
1715  { return this->do_thousands_sep(); }
1716 
1717  /**
1718  * @brief Return grouping specification.
1719  *
1720  * This function returns a string representing groupings for the
1721  * integer part of a number. Groupings indicate where thousands
1722  * separators should be inserted in the integer part of a number.
1723  *
1724  * Each char in the return string is interpret as an integer
1725  * rather than a character. These numbers represent the number
1726  * of digits in a group. The first char in the string
1727  * represents the number of digits in the least significant
1728  * group. If a char is negative, it indicates an unlimited
1729  * number of digits for the group. If more chars from the
1730  * string are required to group a number, the last char is used
1731  * repeatedly.
1732  *
1733  * For example, if the grouping() returns "\003\002" and is
1734  * applied to the number 123456789, this corresponds to
1735  * 12,34,56,789. Note that if the string was "32", this would
1736  * put more than 50 digits into the least significant group if
1737  * the character set is ASCII.
1738  *
1739  * The string is returned by calling
1740  * numpunct<char_type>::do_grouping().
1741  *
1742  * @return string representing grouping specification.
1743  */
1744  string
1745  grouping() const
1746  { return this->do_grouping(); }
1747 
1748  /**
1749  * @brief Return string representation of bool true.
1750  *
1751  * This function returns a string_type containing the text
1752  * representation for true bool variables. It does so by calling
1753  * numpunct<char_type>::do_truename().
1754  *
1755  * @return string_type representing printed form of true.
1756  */
1757  string_type
1758  truename() const
1759  { return this->do_truename(); }
1760 
1761  /**
1762  * @brief Return string representation of bool false.
1763  *
1764  * This function returns a string_type containing the text
1765  * representation for false bool variables. It does so by calling
1766  * numpunct<char_type>::do_falsename().
1767  *
1768  * @return string_type representing printed form of false.
1769  */
1770  string_type
1771  falsename() const
1772  { return this->do_falsename(); }
1773 
1774  protected:
1775  /// Destructor.
1776  virtual
1777  ~numpunct();
1778 
1779  /**
1780  * @brief Return decimal point character.
1781  *
1782  * Returns a char_type to use as a decimal point. This function is a
1783  * hook for derived classes to change the value returned.
1784  *
1785  * @return @a char_type representing a decimal point.
1786  */
1787  virtual char_type
1789  { return _M_data->_M_decimal_point; }
1790 
1791  /**
1792  * @brief Return thousands separator character.
1793  *
1794  * Returns a char_type to use as a thousands separator. This function
1795  * is a hook for derived classes to change the value returned.
1796  *
1797  * @return @a char_type representing a thousands separator.
1798  */
1799  virtual char_type
1801  { return _M_data->_M_thousands_sep; }
1802 
1803  /**
1804  * @brief Return grouping specification.
1805  *
1806  * Returns a string representing groupings for the integer part of a
1807  * number. This function is a hook for derived classes to change the
1808  * value returned. @see grouping() for details.
1809  *
1810  * @return String representing grouping specification.
1811  */
1812  virtual string
1813  do_grouping() const
1814  { return _M_data->_M_grouping; }
1815 
1816  /**
1817  * @brief Return string representation of bool true.
1818  *
1819  * Returns a string_type containing the text representation for true
1820  * bool variables. This function is a hook for derived classes to
1821  * change the value returned.
1822  *
1823  * @return string_type representing printed form of true.
1824  */
1825  virtual string_type
1826  do_truename() const
1827  { return _M_data->_M_truename; }
1828 
1829  /**
1830  * @brief Return string representation of bool false.
1831  *
1832  * Returns a string_type containing the text representation for false
1833  * bool variables. This function is a hook for derived classes to
1834  * change the value returned.
1835  *
1836  * @return string_type representing printed form of false.
1837  */
1838  virtual string_type
1840  { return _M_data->_M_falsename; }
1841 
1842  // For use at construction time only.
1843  void
1844  _M_initialize_numpunct(__c_locale __cloc = NULL);
1845  };
1846 
1847  template<typename _CharT>
1848  locale::id numpunct<_CharT>::id;
1849 
1850  template<>
1851  numpunct<char>::~numpunct();
1852 
1853  template<>
1854  void
1855  numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
1856 
1857 #ifdef _GLIBCXX_USE_WCHAR_T
1858  template<>
1859  numpunct<wchar_t>::~numpunct();
1860 
1861  template<>
1862  void
1863  numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);
1864 #endif
1865 
1866  /// class numpunct_byname [22.2.3.2].
1867  template<typename _CharT>
1868  class numpunct_byname : public numpunct<_CharT>
1869  {
1870  public:
1871  typedef _CharT char_type;
1873 
1874  explicit
1875  numpunct_byname(const char* __s, size_t __refs = 0)
1876  : numpunct<_CharT>(__refs)
1877  {
1878  if (__builtin_strcmp(__s, "C") != 0
1879  && __builtin_strcmp(__s, "POSIX") != 0)
1880  {
1881  __c_locale __tmp;
1882  this->_S_create_c_locale(__tmp, __s);
1883  this->_M_initialize_numpunct(__tmp);
1884  this->_S_destroy_c_locale(__tmp);
1885  }
1886  }
1887 
1888  protected:
1889  virtual
1890  ~numpunct_byname() { }
1891  };
1892 
1893 _GLIBCXX_BEGIN_LDBL_NAMESPACE
1894 
1895  /**
1896  * @brief Facet for parsing number strings.
1897  *
1898  * This facet encapsulates the code to parse and return a number
1899  * from a string. It is used by the istream numeric extraction
1900  * operators.
1901  *
1902  * The num_get template uses protected virtual functions to provide the
1903  * actual results. The public accessors forward the call to the virtual
1904  * functions. These virtual functions are hooks for developers to
1905  * implement the behavior they require from the num_get facet.
1906  */
1907  template<typename _CharT, typename _InIter>
1908  class num_get : public locale::facet
1909  {
1910  public:
1911  // Types:
1912  //@{
1913  /// Public typedefs
1914  typedef _CharT char_type;
1915  typedef _InIter iter_type;
1916  //@}
1917 
1918  /// Numpunct facet id.
1919  static locale::id id;
1920 
1921  /**
1922  * @brief Constructor performs initialization.
1923  *
1924  * This is the constructor provided by the standard.
1925  *
1926  * @param refs Passed to the base facet class.
1927  */
1928  explicit
1929  num_get(size_t __refs = 0) : facet(__refs) { }
1930 
1931  /**
1932  * @brief Numeric parsing.
1933  *
1934  * Parses the input stream into the bool @a v. It does so by calling
1935  * num_get::do_get().
1936  *
1937  * If ios_base::boolalpha is set, attempts to read
1938  * ctype<CharT>::truename() or ctype<CharT>::falsename(). Sets
1939  * @a v to true or false if successful. Sets err to
1940  * ios_base::failbit if reading the string fails. Sets err to
1941  * ios_base::eofbit if the stream is emptied.
1942  *
1943  * If ios_base::boolalpha is not set, proceeds as with reading a long,
1944  * except if the value is 1, sets @a v to true, if the value is 0, sets
1945  * @a v to false, and otherwise set err to ios_base::failbit.
1946  *
1947  * @param in Start of input stream.
1948  * @param end End of input stream.
1949  * @param io Source of locale and flags.
1950  * @param err Error flags to set.
1951  * @param v Value to format and insert.
1952  * @return Iterator after reading.
1953  */
1954  iter_type
1955  get(iter_type __in, iter_type __end, ios_base& __io,
1956  ios_base::iostate& __err, bool& __v) const
1957  { return this->do_get(__in, __end, __io, __err, __v); }
1958 
1959  //@{
1960  /**
1961  * @brief Numeric parsing.
1962  *
1963  * Parses the input stream into the integral variable @a v. It does so
1964  * by calling num_get::do_get().
1965  *
1966  * Parsing is affected by the flag settings in @a io.
1967  *
1968  * The basic parse is affected by the value of io.flags() &
1969  * ios_base::basefield. If equal to ios_base::oct, parses like the
1970  * scanf %o specifier. Else if equal to ios_base::hex, parses like %X
1971  * specifier. Else if basefield equal to 0, parses like the %i
1972  * specifier. Otherwise, parses like %d for signed and %u for unsigned
1973  * types. The matching type length modifier is also used.
1974  *
1975  * Digit grouping is interpreted according to numpunct::grouping() and
1976  * numpunct::thousands_sep(). If the pattern of digit groups isn't
1977  * consistent, sets err to ios_base::failbit.
1978  *
1979  * If parsing the string yields a valid value for @a v, @a v is set.
1980  * Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
1981  * Sets err to ios_base::eofbit if the stream is emptied.
1982  *
1983  * @param in Start of input stream.
1984  * @param end End of input stream.
1985  * @param io Source of locale and flags.
1986  * @param err Error flags to set.
1987  * @param v Value to format and insert.
1988  * @return Iterator after reading.
1989  */
1990  iter_type
1991  get(iter_type __in, iter_type __end, ios_base& __io,
1992  ios_base::iostate& __err, long& __v) const
1993  { return this->do_get(__in, __end, __io, __err, __v); }
1994 
1995  iter_type
1996  get(iter_type __in, iter_type __end, ios_base& __io,
1997  ios_base::iostate& __err, unsigned short& __v) const
1998  { return this->do_get(__in, __end, __io, __err, __v); }
1999 
2000  iter_type
2001  get(iter_type __in, iter_type __end, ios_base& __io,
2002  ios_base::iostate& __err, unsigned int& __v) const
2003  { return this->do_get(__in, __end, __io, __err, __v); }
2004 
2005  iter_type
2006  get(iter_type __in, iter_type __end, ios_base& __io,
2007  ios_base::iostate& __err, unsigned long& __v) const
2008  { return this->do_get(__in, __end, __io, __err, __v); }
2009 
2010 #ifdef _GLIBCXX_USE_LONG_LONG
2011  iter_type
2012  get(iter_type __in, iter_type __end, ios_base& __io,
2013  ios_base::iostate& __err, long long& __v) const
2014  { return this->do_get(__in, __end, __io, __err, __v); }
2015 
2016  iter_type
2017  get(iter_type __in, iter_type __end, ios_base& __io,
2018  ios_base::iostate& __err, unsigned long long& __v) const
2019  { return this->do_get(__in, __end, __io, __err, __v); }
2020 #endif
2021  //@}
2022 
2023  //@{
2024  /**
2025  * @brief Numeric parsing.
2026  *
2027  * Parses the input stream into the integral variable @a v. It does so
2028  * by calling num_get::do_get().
2029  *
2030  * The input characters are parsed like the scanf %g specifier. The
2031  * matching type length modifier is also used.
2032  *
2033  * The decimal point character used is numpunct::decimal_point().
2034  * Digit grouping is interpreted according to numpunct::grouping() and
2035  * numpunct::thousands_sep(). If the pattern of digit groups isn't
2036  * consistent, sets err to ios_base::failbit.
2037  *
2038  * If parsing the string yields a valid value for @a v, @a v is set.
2039  * Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
2040  * Sets err to ios_base::eofbit if the stream is emptied.
2041  *
2042  * @param in Start of input stream.
2043  * @param end End of input stream.
2044  * @param io Source of locale and flags.
2045  * @param err Error flags to set.
2046  * @param v Value to format and insert.
2047  * @return Iterator after reading.
2048  */
2049  iter_type
2050  get(iter_type __in, iter_type __end, ios_base& __io,
2051  ios_base::iostate& __err, float& __v) const
2052  { return this->do_get(__in, __end, __io, __err, __v); }
2053 
2054  iter_type
2055  get(iter_type __in, iter_type __end, ios_base& __io,
2056  ios_base::iostate& __err, double& __v) const
2057  { return this->do_get(__in, __end, __io, __err, __v); }
2058 
2059  iter_type
2060  get(iter_type __in, iter_type __end, ios_base& __io,
2061  ios_base::iostate& __err, long double& __v) const
2062  { return this->do_get(__in, __end, __io, __err, __v); }
2063  //@}
2064 
2065  /**
2066  * @brief Numeric parsing.
2067  *
2068  * Parses the input stream into the pointer variable @a v. It does so
2069  * by calling num_get::do_get().
2070  *
2071  * The input characters are parsed like the scanf %p specifier.
2072  *
2073  * Digit grouping is interpreted according to numpunct::grouping() and
2074  * numpunct::thousands_sep(). If the pattern of digit groups isn't
2075  * consistent, sets err to ios_base::failbit.
2076  *
2077  * Note that the digit grouping effect for pointers is a bit ambiguous
2078  * in the standard and shouldn't be relied on. See DR 344.
2079  *
2080  * If parsing the string yields a valid value for @a v, @a v is set.
2081  * Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
2082  * Sets err to ios_base::eofbit if the stream is emptied.
2083  *
2084  * @param in Start of input stream.
2085  * @param end End of input stream.
2086  * @param io Source of locale and flags.
2087  * @param err Error flags to set.
2088  * @param v Value to format and insert.
2089  * @return Iterator after reading.
2090  */
2091  iter_type
2092  get(iter_type __in, iter_type __end, ios_base& __io,
2093  ios_base::iostate& __err, void*& __v) const
2094  { return this->do_get(__in, __end, __io, __err, __v); }
2095 
2096  protected:
2097  /// Destructor.
2098  virtual ~num_get() { }
2099 
2100  iter_type
2101  _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
2102  string&) const;
2103 
2104  template<typename _ValueT>
2105  iter_type
2106  _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
2107  _ValueT&) const;
2108 
2109  template<typename _CharT2>
2110  typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type
2111  _M_find(const _CharT2*, size_t __len, _CharT2 __c) const
2112  {
2113  int __ret = -1;
2114  if (__len <= 10)
2115  {
2116  if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len))
2117  __ret = __c - _CharT2('0');
2118  }
2119  else
2120  {
2121  if (__c >= _CharT2('0') && __c <= _CharT2('9'))
2122  __ret = __c - _CharT2('0');
2123  else if (__c >= _CharT2('a') && __c <= _CharT2('f'))
2124  __ret = 10 + (__c - _CharT2('a'));
2125  else if (__c >= _CharT2('A') && __c <= _CharT2('F'))
2126  __ret = 10 + (__c - _CharT2('A'));
2127  }
2128  return __ret;
2129  }
2130 
2131  template<typename _CharT2>
2132  typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value,
2133  int>::__type
2134  _M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const
2135  {
2136  int __ret = -1;
2137  const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c);
2138  if (__q)
2139  {
2140  __ret = __q - __zero;
2141  if (__ret > 15)
2142  __ret -= 6;
2143  }
2144  return __ret;
2145  }
2146 
2147  //@{
2148  /**
2149  * @brief Numeric parsing.
2150  *
2151  * Parses the input stream into the variable @a v. This function is a
2152  * hook for derived classes to change the value returned. @see get()
2153  * for more details.
2154  *
2155  * @param in Start of input stream.
2156  * @param end End of input stream.
2157  * @param io Source of locale and flags.
2158  * @param err Error flags to set.
2159  * @param v Value to format and insert.
2160  * @return Iterator after reading.
2161  */
2162  virtual iter_type
2163  do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
2164 
2165  virtual iter_type
2166  do_get(iter_type __beg, iter_type __end, ios_base& __io,
2167  ios_base::iostate& __err, long& __v) const
2168  { return _M_extract_int(__beg, __end, __io, __err, __v); }
2169 
2170  virtual iter_type
2171  do_get(iter_type __beg, iter_type __end, ios_base& __io,
2172  ios_base::iostate& __err, unsigned short& __v) const
2173  { return _M_extract_int(__beg, __end, __io, __err, __v); }
2174 
2175  virtual iter_type
2176  do_get(iter_type __beg, iter_type __end, ios_base& __io,
2177  ios_base::iostate& __err, unsigned int& __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 long& __v) const
2183  { return _M_extract_int(__beg, __end, __io, __err, __v); }
2184 
2185 #ifdef _GLIBCXX_USE_LONG_LONG
2186  virtual iter_type
2187  do_get(iter_type __beg, iter_type __end, ios_base& __io,
2188  ios_base::iostate& __err, long long& __v) const
2189  { return _M_extract_int(__beg, __end, __io, __err, __v); }
2190 
2191  virtual iter_type
2192  do_get(iter_type __beg, iter_type __end, ios_base& __io,
2193  ios_base::iostate& __err, unsigned long long& __v) const
2194  { return _M_extract_int(__beg, __end, __io, __err, __v); }
2195 #endif
2196 
2197  virtual iter_type
2198  do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2199  float&) const;
2200 
2201  virtual iter_type
2202  do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2203  double&) const;
2204 
2205  // XXX GLIBCXX_ABI Deprecated
2206 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
2207  virtual iter_type
2208  __do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2209  double&) const;
2210 #else
2211  virtual iter_type
2212  do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2213  long double&) const;
2214 #endif
2215 
2216  virtual iter_type
2217  do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2218  void*&) const;
2219 
2220  // XXX GLIBCXX_ABI Deprecated
2221 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
2222  virtual iter_type
2223  do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
2224  long double&) const;
2225 #endif
2226  //@}
2227  };
2228 
2229  template<typename _CharT, typename _InIter>
2230  locale::id num_get<_CharT, _InIter>::id;
2231 
2232 
2233  /**
2234  * @brief Facet for converting numbers to strings.
2235  *
2236  * This facet encapsulates the code to convert a number to a string. It is
2237  * used by the ostream numeric insertion operators.
2238  *
2239  * The num_put template uses protected virtual functions to provide the
2240  * actual results. The public accessors forward the call to the virtual
2241  * functions. These virtual functions are hooks for developers to
2242  * implement the behavior they require from the num_put facet.
2243  */
2244  template<typename _CharT, typename _OutIter>
2245  class num_put : public locale::facet
2246  {
2247  public:
2248  // Types:
2249  //@{
2250  /// Public typedefs
2251  typedef _CharT char_type;
2252  typedef _OutIter iter_type;
2253  //@}
2254 
2255  /// Numpunct facet id.
2256  static locale::id id;
2257 
2258  /**
2259  * @brief Constructor performs initialization.
2260  *
2261  * This is the constructor provided by the standard.
2262  *
2263  * @param refs Passed to the base facet class.
2264  */
2265  explicit
2266  num_put(size_t __refs = 0) : facet(__refs) { }
2267 
2268  /**
2269  * @brief Numeric formatting.
2270  *
2271  * Formats the boolean @a v and inserts it into a stream. It does so
2272  * by calling num_put::do_put().
2273  *
2274  * If ios_base::boolalpha is set, writes ctype<CharT>::truename() or
2275  * ctype<CharT>::falsename(). Otherwise formats @a v as an int.
2276  *
2277  * @param s Stream to write to.
2278  * @param io Source of locale and flags.
2279  * @param fill Char_type to use for filling.
2280  * @param v Value to format and insert.
2281  * @return Iterator after writing.
2282  */
2283  iter_type
2284  put(iter_type __s, ios_base& __f, char_type __fill, bool __v) const
2285  { return this->do_put(__s, __f, __fill, __v); }
2286 
2287  //@{
2288  /**
2289  * @brief Numeric formatting.
2290  *
2291  * Formats the integral value @a v and inserts it into a
2292  * stream. It does so by calling num_put::do_put().
2293  *
2294  * Formatting is affected by the flag settings in @a io.
2295  *
2296  * The basic format is affected by the value of io.flags() &
2297  * ios_base::basefield. If equal to ios_base::oct, formats like the
2298  * printf %o specifier. Else if equal to ios_base::hex, formats like
2299  * %x or %X with ios_base::uppercase unset or set respectively.
2300  * Otherwise, formats like %d, %ld, %lld for signed and %u, %lu, %llu
2301  * for unsigned values. Note that if both oct and hex are set, neither
2302  * will take effect.
2303  *
2304  * If ios_base::showpos is set, '+' is output before positive values.
2305  * If ios_base::showbase is set, '0' precedes octal values (except 0)
2306  * and '0[xX]' precedes hex values.
2307  *
2308  * Thousands separators are inserted according to numpunct::grouping()
2309  * and numpunct::thousands_sep(). The decimal point character used is
2310  * numpunct::decimal_point().
2311  *
2312  * If io.width() is non-zero, enough @a fill characters are inserted to
2313  * make the result at least that wide. If
2314  * (io.flags() & ios_base::adjustfield) == ios_base::left, result is
2315  * padded at the end. If ios_base::internal, then padding occurs
2316  * immediately after either a '+' or '-' or after '0x' or '0X'.
2317  * Otherwise, padding occurs at the beginning.
2318  *
2319  * @param s Stream to write to.
2320  * @param io Source of locale and flags.
2321  * @param fill Char_type to use for filling.
2322  * @param v Value to format and insert.
2323  * @return Iterator after writing.
2324  */
2325  iter_type
2326  put(iter_type __s, ios_base& __f, char_type __fill, long __v) const
2327  { return this->do_put(__s, __f, __fill, __v); }
2328 
2329  iter_type
2330  put(iter_type __s, ios_base& __f, char_type __fill,
2331  unsigned long __v) const
2332  { return this->do_put(__s, __f, __fill, __v); }
2333 
2334 #ifdef _GLIBCXX_USE_LONG_LONG
2335  iter_type
2336  put(iter_type __s, ios_base& __f, char_type __fill, long long __v) const
2337  { return this->do_put(__s, __f, __fill, __v); }
2338 
2339  iter_type
2340  put(iter_type __s, ios_base& __f, char_type __fill,
2341  unsigned long long __v) const
2342  { return this->do_put(__s, __f, __fill, __v); }
2343 #endif
2344  //@}
2345 
2346  //@{
2347  /**
2348  * @brief Numeric formatting.
2349  *
2350  * Formats the floating point value @a v and inserts it into a stream.
2351  * It does so by calling num_put::do_put().
2352  *
2353  * Formatting is affected by the flag settings in @a io.
2354  *
2355  * The basic format is affected by the value of io.flags() &
2356  * ios_base::floatfield. If equal to ios_base::fixed, formats like the
2357  * printf %f specifier. Else if equal to ios_base::scientific, formats
2358  * like %e or %E with ios_base::uppercase unset or set respectively.
2359  * Otherwise, formats like %g or %G depending on uppercase. Note that
2360  * if both fixed and scientific are set, the effect will also be like
2361  * %g or %G.
2362  *
2363  * The output precision is given by io.precision(). This precision is
2364  * capped at numeric_limits::digits10 + 2 (different for double and
2365  * long double). The default precision is 6.
2366  *
2367  * If ios_base::showpos is set, '+' is output before positive values.
2368  * If ios_base::showpoint is set, a decimal point will always be
2369  * output.
2370  *
2371  * Thousands separators are inserted according to numpunct::grouping()
2372  * and numpunct::thousands_sep(). The decimal point character used is
2373  * numpunct::decimal_point().
2374  *
2375  * If io.width() is non-zero, enough @a fill characters are inserted to
2376  * make the result at least that wide. If
2377  * (io.flags() & ios_base::adjustfield) == ios_base::left, result is
2378  * padded at the end. If ios_base::internal, then padding occurs
2379  * immediately after either a '+' or '-' or after '0x' or '0X'.
2380  * Otherwise, padding occurs at the beginning.
2381  *
2382  * @param s Stream to write to.
2383  * @param io Source of locale and flags.
2384  * @param fill Char_type to use for filling.
2385  * @param v Value to format and insert.
2386  * @return Iterator after writing.
2387  */
2388  iter_type
2389  put(iter_type __s, ios_base& __f, char_type __fill, double __v) const
2390  { return this->do_put(__s, __f, __fill, __v); }
2391 
2392  iter_type
2393  put(iter_type __s, ios_base& __f, char_type __fill,
2394  long double __v) const
2395  { return this->do_put(__s, __f, __fill, __v); }
2396  //@}
2397 
2398  /**
2399  * @brief Numeric formatting.
2400  *
2401  * Formats the pointer value @a v and inserts it into a stream. It
2402  * does so by calling num_put::do_put().
2403  *
2404  * This function formats @a v as an unsigned long with ios_base::hex
2405  * and ios_base::showbase set.
2406  *
2407  * @param s Stream to write to.
2408  * @param io Source of locale and flags.
2409  * @param fill Char_type to use for filling.
2410  * @param v Value to format and insert.
2411  * @return Iterator after writing.
2412  */
2413  iter_type
2414  put(iter_type __s, ios_base& __f, char_type __fill,
2415  const void* __v) const
2416  { return this->do_put(__s, __f, __fill, __v); }
2417 
2418  protected:
2419  template<typename _ValueT>
2420  iter_type
2421  _M_insert_float(iter_type, ios_base& __io, char_type __fill,
2422  char __mod, _ValueT __v) const;
2423 
2424  void
2425  _M_group_float(const char* __grouping, size_t __grouping_size,
2426  char_type __sep, const char_type* __p, char_type* __new,
2427  char_type* __cs, int& __len) const;
2428 
2429  template<typename _ValueT>
2430  iter_type
2431  _M_insert_int(iter_type, ios_base& __io, char_type __fill,
2432  _ValueT __v) const;
2433 
2434  void
2435  _M_group_int(const char* __grouping, size_t __grouping_size,
2436  char_type __sep, ios_base& __io, char_type* __new,
2437  char_type* __cs, int& __len) const;
2438 
2439  void
2440  _M_pad(char_type __fill, streamsize __w, ios_base& __io,
2441  char_type* __new, const char_type* __cs, int& __len) const;
2442 
2443  /// Destructor.
2444  virtual
2445  ~num_put() { };
2446 
2447  //@{
2448  /**
2449  * @brief Numeric formatting.
2450  *
2451  * These functions do the work of formatting numeric values and
2452  * inserting them into a stream. This function is a hook for derived
2453  * classes to change the value returned.
2454  *
2455  * @param s Stream to write to.
2456  * @param io Source of locale and flags.
2457  * @param fill Char_type to use for filling.
2458  * @param v Value to format and insert.
2459  * @return Iterator after writing.
2460  */
2461  virtual iter_type
2462  do_put(iter_type, ios_base&, char_type __fill, bool __v) const;
2463 
2464  virtual iter_type
2465  do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
2466  { return _M_insert_int(__s, __io, __fill, __v); }
2467 
2468  virtual iter_type
2469  do_put(iter_type __s, ios_base& __io, char_type __fill,
2470  unsigned long __v) const
2471  { return _M_insert_int(__s, __io, __fill, __v); }
2472 
2473 #ifdef _GLIBCXX_USE_LONG_LONG
2474  virtual iter_type
2475  do_put(iter_type __s, ios_base& __io, char_type __fill,
2476  long long __v) const
2477  { return _M_insert_int(__s, __io, __fill, __v); }
2478 
2479  virtual iter_type
2480  do_put(iter_type __s, ios_base& __io, char_type __fill,
2481  unsigned long long __v) const
2482  { return _M_insert_int(__s, __io, __fill, __v); }
2483 #endif
2484 
2485  virtual iter_type
2486  do_put(iter_type, ios_base&, char_type __fill, double __v) const;
2487 
2488  // XXX GLIBCXX_ABI Deprecated
2489 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
2490  virtual iter_type
2491  __do_put(iter_type, ios_base&, char_type __fill, double __v) const;
2492 #else
2493  virtual iter_type
2494  do_put(iter_type, ios_base&, char_type __fill, long double __v) const;
2495 #endif
2496 
2497  virtual iter_type
2498  do_put(iter_type, ios_base&, char_type __fill, const void* __v) const;
2499 
2500  // XXX GLIBCXX_ABI Deprecated
2501 #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
2502  virtual iter_type
2503  do_put(iter_type, ios_base&, char_type __fill, long double __v) const;
2504 #endif
2505  //@}
2506  };
2507 
2508  template <typename _CharT, typename _OutIter>
2509  locale::id num_put<_CharT, _OutIter>::id;
2510 
2511 _GLIBCXX_END_LDBL_NAMESPACE
2512 
2513  // Subclause convenience interfaces, inlines.
2514  // NB: These are inline because, when used in a loop, some compilers
2515  // can hoist the body out of the loop; then it's just as fast as the
2516  // C is*() function.
2517 
2518  /// Convenience interface to ctype.is(ctype_base::space, __c).
2519  template<typename _CharT>
2520  inline bool
2521  isspace(_CharT __c, const locale& __loc)
2522  { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }
2523 
2524  /// Convenience interface to ctype.is(ctype_base::print, __c).
2525  template<typename _CharT>
2526  inline bool
2527  isprint(_CharT __c, const locale& __loc)
2528  { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }
2529 
2530  /// Convenience interface to ctype.is(ctype_base::cntrl, __c).
2531  template<typename _CharT>
2532  inline bool
2533  iscntrl(_CharT __c, const locale& __loc)
2534  { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }
2535 
2536  /// Convenience interface to ctype.is(ctype_base::upper, __c).
2537  template<typename _CharT>
2538  inline bool
2539  isupper(_CharT __c, const locale& __loc)
2540  { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }
2541 
2542  /// Convenience interface to ctype.is(ctype_base::lower, __c).
2543  template<typename _CharT>
2544  inline bool
2545  islower(_CharT __c, const locale& __loc)
2546  { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }
2547 
2548  /// Convenience interface to ctype.is(ctype_base::alpha, __c).
2549  template<typename _CharT>
2550  inline bool
2551  isalpha(_CharT __c, const locale& __loc)
2552  { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }
2553 
2554  /// Convenience interface to ctype.is(ctype_base::digit, __c).
2555  template<typename _CharT>
2556  inline bool
2557  isdigit(_CharT __c, const locale& __loc)
2558  { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }
2559 
2560  /// Convenience interface to ctype.is(ctype_base::punct, __c).
2561  template<typename _CharT>
2562  inline bool
2563  ispunct(_CharT __c, const locale& __loc)
2564  { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }
2565 
2566  /// Convenience interface to ctype.is(ctype_base::xdigit, __c).
2567  template<typename _CharT>
2568  inline bool
2569  isxdigit(_CharT __c, const locale& __loc)
2570  { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }
2571 
2572  /// Convenience interface to ctype.is(ctype_base::alnum, __c).
2573  template<typename _CharT>
2574  inline bool
2575  isalnum(_CharT __c, const locale& __loc)
2576  { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }
2577 
2578  /// Convenience interface to ctype.is(ctype_base::graph, __c).
2579  template<typename _CharT>
2580  inline bool
2581  isgraph(_CharT __c, const locale& __loc)
2582  { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }
2583 
2584  /// Convenience interface to ctype.toupper(__c).
2585  template<typename _CharT>
2586  inline _CharT
2587  toupper(_CharT __c, const locale& __loc)
2588  { return use_facet<ctype<_CharT> >(__loc).toupper(__c); }
2589 
2590  /// Convenience interface to ctype.tolower(__c).
2591  template<typename _CharT>
2592  inline _CharT
2593  tolower(_CharT __c, const locale& __loc)
2594  { return use_facet<ctype<_CharT> >(__loc).tolower(__c); }
2595 
2596 _GLIBCXX_END_NAMESPACE
2597 
2598 #ifndef _GLIBCXX_EXPORT_TEMPLATE
2599 # include <bits/locale_facets.tcc>
2600 #endif
2601 
2602 #endif
_CharT char_type
Public typedefs.
bool islower(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::lower, __c).
_OutIter iter_type
Public typedefs.
ptrdiff_t streamsize
Integral type for I/O operation counts and buffer sizes.
Definition: postypes.h:98
char_type tolower(char_type __c) const
Convert to lowercase.
iter_type put(iter_type __s, ios_base &__f, char_type __fill, long long __v) const
Numeric formatting.
const char_type * tolower(char_type *__lo, const char_type *__hi) const
Convert array to lowercase.
iter_type put(iter_type __s, ios_base &__f, char_type __fill, double __v) const
Numeric formatting.
string grouping() const
Return grouping specification.
const char * widen(const char *__lo, const char *__hi, char_type *__to) const
Widen char array.
Facet ID class.
virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base &__io, ios_base::iostate &__err, unsigned int &__v) const
Numeric parsing.
basic_string< _CharT > string_type
Public typedefs.
char_type decimal_point() const
Return decimal point character.
virtual string do_grouping() const
Return grouping specification.
const char_type * toupper(char_type *__lo, const char_type *__hi) const
Convert array to uppercase.
virtual const char * do_widen(const char *__lo, const char *__hi, char_type *__dest) const
Widen char array.
const mask * table() const
Returns a pointer to the mask table provided to the constructor, or the default from classic_table() ...
_CharT char_type
Public typedefs.
iter_type put(iter_type __s, ios_base &__f, char_type __fill, unsigned long long __v) const
Numeric formatting.
const char_type * is(const char_type *__lo, const char_type *__hi, mask *__vec) const
Return a mask array.
bool ispunct(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::punct, __c).
class ctype_byname [22.2.1.2].
virtual string_type do_falsename() const
Return string representation of bool false.
string_type truename() const
Return string representation of bool true.
numpunct(__c_locale __cloc, size_t __refs=0)
Internal constructor. Not for general use.
char_type toupper(char_type __c) const
Convert to uppercase.
char narrow(char_type __c, char __dfault) const
Narrow char.
_CharT char_type
Public typedefs.
num_get(size_t __refs=0)
Constructor performs initialization.
const char_type * narrow(const char_type *__lo, const char_type *__hi, char __dfault, char *__to) const
Narrow array to char array.
string_type falsename() const
Return string representation of bool false.
static locale::id id
Numpunct facet id.
iter_type put(iter_type __s, ios_base &__f, char_type __fill, bool __v) const
Numeric formatting.
Localization functionality base class.
virtual string_type do_truename() const
Return string representation of bool true.
The base of the I/O class hierarchy.This class defines everything that can be defined about I/O that ...
Definition: ios_base.h:207
bool isprint(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::print, __c).
_GLIBCXX_END_LDBL_NAMESPACE bool isspace(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::space, __c).
wchar_t char_type
Typedef for the template parameter wchar_t.
const char_type * tolower(char_type *__lo, const char_type *__hi) const
Convert array to lowercase.
num_put(size_t __refs=0)
Constructor performs initialization.
static locale::id id
The facet id for ctype
bool isdigit(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::digit, __c).
bool iscntrl(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::cntrl, __c).
virtual char_type do_thousands_sep() const
Return thousands separator character.
Base class for ctype.
Definition: ctype_base.h:40
static locale::id id
The facet id for ctype
virtual iter_type do_put(iter_type __s, ios_base &__io, char_type __fill, unsigned long __v) const
Numeric formatting.
const char * widen(const char *__lo, const char *__hi, char_type *__to) const
Widen array to char_type.
char narrow(char_type __c, char __dfault) const
Narrow char_type to char.
_CharT char_type
Typedef for the template parameter.
class numpunct_byname [22.2.3.2].
bool isgraph(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::graph, __c).
const char_type * scan_not(mask __m, const char_type *__lo, const char_type *__hi) const
Find char_type not matching a mask.
char_type widen(char __c) const
Widen char.
bool isxdigit(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::xdigit, __c).
virtual const char_type * do_narrow(const char_type *__lo, const char_type *__hi, char, char *__dest) const
Narrow char array to char array.
bool is(mask __m, char_type __c) const
Test char_type classification.
char_type widen(char __c) const
Widen char to char_type.
_CharT tolower(_CharT __c, const locale &__loc)
Convenience interface to ctype.tolower(__c).
static locale::id id
The facet id for ctype
virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base &__io, ios_base::iostate &__err, unsigned long &__v) const
Numeric parsing.
iter_type put(iter_type __s, ios_base &__f, char_type __fill, unsigned long __v) const
Numeric formatting.
virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base &__io, ios_base::iostate &__err, unsigned long long &__v) const
Numeric parsing.
virtual iter_type do_put(iter_type __s, ios_base &__io, char_type __fill, unsigned long long __v) const
Numeric formatting.
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, long __v) const
Numeric formatting.
_CharT toupper(_CharT __c, const locale &__loc)
Convenience interface to ctype.toupper(__c).
iter_type put(iter_type __s, ios_base &__f, char_type __fill, long double __v) const
Numeric formatting.
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.
Container class for localization functionality.
iter_type put(iter_type __s, ios_base &__f, char_type __fill, long __v) const
Numeric formatting.
virtual iter_type do_put(iter_type __s, ios_base &__io, char_type __fill, long long __v) const
Numeric formatting.
virtual char do_narrow(char_type __c, char) const
Narrow char.
virtual ~num_put()
Destructor.
bool isalpha(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::alpha, __c).
Facet for converting numbers to strings.
Common base for ctype facet.
Template ctype facet.
virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base &__io, ios_base::iostate &__err, unsigned short &__v) const
Numeric parsing.
char_type tolower(char_type __c) const
Convert to lowercase.
virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base &__io, ios_base::iostate &__err, long long &__v) const
Numeric parsing.
static locale::id id
Numpunct facet id.
Numpunct facet.
virtual ~num_get()
Destructor.
iter_type put(iter_type __s, ios_base &__f, char_type __fill, const void *__v) const
Numeric formatting.
numpunct(size_t __refs=0)
Numpunct constructor.
char_type toupper(char_type __c) const
Convert to uppercase.
bool isupper(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::upper, __c).
_InIter iter_type
Public typedefs.
char char_type
Typedef for the template parameter char.
const char_type * narrow(const char_type *__lo, const char_type *__hi, char __dfault, char *__to) const
Narrow char array.
static locale::id id
Numpunct facet id.
numpunct(__cache_type *__cache, size_t __refs=0)
Internal constructor. Not for general use.
char_type thousands_sep() const
Return thousands separator character.
bool isalnum(_CharT __c, const locale &__loc)
Convenience interface to ctype.is(ctype_base::alnum, __c).
Facet for parsing number strings.
Managing sequences of characters and character-like objects.
Definition: basic_string.h:104
const char_type * scan_is(mask __m, const char_type *__lo, const char_type *__hi) const
Find char_type matching a mask.