File Coverage

/usr/include/c++/5/bits/locale_facets.h
Criterion Covered Total %
statement 0 7 0.0
branch 0 2 0.0
condition n/a
subroutine n/a
pod n/a
total 0 9 0.0


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