2001-08-03 Daniel Berlin <dan@cgsoftware.com>
[official-gcc.git] / libstdc++-v3 / src / locale.cc
blobdfd49d1626fb596c1596b1034d686b275a2a8bad
1 // Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
2 //
3 // This file is part of the GNU ISO C++ Library. This library is free
4 // software; you can redistribute it and/or modify it under the
5 // terms of the GNU General Public License as published by the
6 // Free Software Foundation; either version 2, or (at your option)
7 // any later version.
9 // This library is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 // GNU General Public License for more details.
14 // You should have received a copy of the GNU General Public License along
15 // with this library; see the file COPYING. If not, write to the Free
16 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
17 // USA.
19 // As a special exception, you may use this file as part of a free software
20 // library without restriction. Specifically, if other files instantiate
21 // templates or use macros or inline functions from this file, or you compile
22 // this file and link it with other files to produce an executable, this
23 // file does not by itself cause the resulting executable to be covered by
24 // the GNU General Public License. This exception does not however
25 // invalidate any other reasons why the executable file might be covered by
26 // the GNU General Public License.
28 #include <bits/std_clocale.h>
29 #include <bits/std_cstring.h>
30 #include <bits/std_cassert.h>
31 #include <bits/std_cctype.h>
32 #include <bits/std_limits.h>
33 #include <exception>
34 #include <bits/std_stdexcept.h>
35 #include <bits/std_locale.h>
36 #include <bits/std_istream.h>
37 #include <bits/std_ostream.h>
38 #include <bits/std_vector.h>
39 #include <bits/std_memory.h> // for auto_ptr
40 #ifdef _GLIBCPP_USE_WCHAR_T
41 # include <bits/std_cwctype.h> // for towupper, etc.
42 #endif
44 namespace std
46 // Defined in globals.cc.
47 extern locale::_Impl locale_impl_c;
48 extern locale locale_c;
50 // Definitions for static const data members of locale.
51 const locale::category locale::none;
52 const locale::category locale::ctype;
53 const locale::category locale::numeric;
54 const locale::category locale::collate;
55 const locale::category locale::time;
56 const locale::category locale::monetary;
57 const locale::category locale::messages;
58 const locale::category locale::all;
60 locale::_Impl* locale::_S_classic;
61 locale::_Impl* locale::_S_global;
62 const size_t locale::_S_num_categories;
63 const size_t locale::_S_num_facets;
65 // Definitions for locale::id of standard facets.
66 locale::id ctype<char>::id;
67 locale::id codecvt<char, char, mbstate_t>::id;
69 #ifdef _GLIBCPP_USE_WCHAR_T
70 locale::id ctype<wchar_t>::id;
71 locale::id codecvt<wchar_t, char, mbstate_t>::id;
72 #endif
74 // Definitions for static const data members of locale::id
75 size_t locale::id::_S_highwater; // init'd to 0 by linker
77 // Definitions for static const data members of locale::_Impl
78 const locale::id* const
79 locale::_Impl::_S_id_ctype[] =
81 &std::ctype<char>::id,
82 &codecvt<char, char, mbstate_t>::id,
83 #ifdef _GLIBCPP_USE_WCHAR_T
84 &std::ctype<wchar_t>::id,
85 &codecvt<wchar_t, char, mbstate_t>::id,
86 #endif
90 const locale::id* const
91 locale::_Impl::_S_id_numeric[] =
93 &num_get<char>::id,
94 &num_put<char>::id,
95 &numpunct<char>::id,
96 #ifdef _GLIBCPP_USE_WCHAR_T
97 &num_get<wchar_t>::id,
98 &num_put<wchar_t>::id,
99 &numpunct<wchar_t>::id,
100 #endif
104 const locale::id* const
105 locale::_Impl::_S_id_collate[] =
107 &std::collate<char>::id,
108 #ifdef _GLIBCPP_USE_WCHAR_T
109 &std::collate<wchar_t>::id,
110 #endif
114 const locale::id* const
115 locale::_Impl::_S_id_time[] =
117 &time_get<char>::id,
118 &time_put<char>::id,
119 #ifdef _GLIBCPP_USE_WCHAR_T
120 &time_get<wchar_t>::id,
121 &time_put<wchar_t>::id,
122 #endif
126 const locale::id* const
127 locale::_Impl::_S_id_monetary[] =
129 &money_get<char>::id,
130 &money_put<char>::id,
131 &moneypunct<char, false>::id,
132 &moneypunct<char, true >::id,
133 #ifdef _GLIBCPP_USE_WCHAR_T
134 &money_get<wchar_t>::id,
135 &money_put<wchar_t>::id,
136 &moneypunct<wchar_t, false>::id,
137 &moneypunct<wchar_t, true >::id,
138 #endif
142 const locale::id* const
143 locale::_Impl::_S_id_messages[] =
145 &std::messages<char>::id,
146 #ifdef _GLIBCPP_USE_WCHAR_T
147 &std::messages<wchar_t>::id,
148 #endif
152 const locale::id* const* const
153 locale::_Impl::_S_facet_categories[] =
155 // Order must match the decl order in class locale.
156 locale::_Impl::_S_id_ctype,
157 locale::_Impl::_S_id_numeric,
158 locale::_Impl::_S_id_collate,
159 locale::_Impl::_S_id_time,
160 locale::_Impl::_S_id_monetary,
161 locale::_Impl::_S_id_messages,
165 // Construct and return valid pattern consisting of some combination of:
166 // space none symbol sign value
167 money_base::pattern
168 money_base::_S_construct_pattern(char __preceeds, char __space, char __posn)
170 pattern __ret;
172 // This insanely complicated routine attempts to construct a valid
173 // pattern for use with monyepunct. A couple of invariants:
175 // if (__preceeds) symbol -> value
176 // else value -> symbol
178 // if (__space) space
179 // else none
181 // none == never first
182 // space never first or last
184 // Any elegant implementations of this are welcome.
185 switch (__posn)
187 case 1:
188 // 1 The sign precedes the value and symbol.
189 if (__space)
191 // Pattern starts with sign.
192 if (__preceeds)
194 __ret.field[1] = symbol;
195 __ret.field[2] = space;
196 __ret.field[3] = value;
198 else
200 __ret.field[1] = value;
201 __ret.field[2] = space;
202 __ret.field[3] = symbol;
204 __ret.field[0] = sign;
206 else
208 // Pattern starts with sign and ends with none.
209 if (__preceeds)
211 __ret.field[1] = symbol;
212 __ret.field[2] = value;
214 else
216 __ret.field[1] = value;
217 __ret.field[2] = symbol;
219 __ret.field[0] = sign;
220 __ret.field[3] = none;
222 break;
223 case 2:
224 // 2 The sign follows the value and symbol.
225 if (__space)
227 // Pattern either ends with sign.
228 if (__preceeds)
230 __ret.field[0] = symbol;
231 __ret.field[1] = space;
232 __ret.field[2] = value;
234 else
236 __ret.field[0] = value;
237 __ret.field[1] = space;
238 __ret.field[2] = symbol;
240 __ret.field[3] = sign;
242 else
244 // Pattern ends with sign then none.
245 if (__preceeds)
247 __ret.field[0] = symbol;
248 __ret.field[1] = value;
250 else
252 __ret.field[0] = value;
253 __ret.field[1] = symbol;
255 __ret.field[2] = sign;
256 __ret.field[3] = none;
258 break;
259 case 3:
260 // 3 The sign immediately precedes the symbol.
261 if (__space)
263 // Have space.
264 if (__preceeds)
266 __ret.field[0] = sign;
267 __ret.field[1] = symbol;
268 __ret.field[2] = space;
269 __ret.field[3] = value;
271 else
273 __ret.field[0] = value;
274 __ret.field[1] = space;
275 __ret.field[2] = sign;
276 __ret.field[3] = symbol;
279 else
281 // Have none.
282 if (__preceeds)
284 __ret.field[0] = sign;
285 __ret.field[1] = symbol;
286 __ret.field[2] = value;
288 else
290 __ret.field[0] = value;
291 __ret.field[1] = sign;
292 __ret.field[2] = symbol;
294 __ret.field[3] = none;
296 break;
297 case 4:
298 // 4 The sign immediately follows the symbol.
299 if (__space)
301 // Have space.
302 if (__preceeds)
304 __ret.field[0] = symbol;
305 __ret.field[1] = sign;
306 __ret.field[2] = space;
307 __ret.field[3] = value;
309 else
311 __ret.field[0] = value;
312 __ret.field[1] = space;
313 __ret.field[2] = symbol;
314 __ret.field[3] = sign;
317 else
319 // Have none.
320 if (__preceeds)
322 __ret.field[0] = symbol;
323 __ret.field[1] = sign;
324 __ret.field[2] = value;
326 else
328 __ret.field[0] = value;
329 __ret.field[1] = symbol;
330 __ret.field[2] = sign;
332 __ret.field[3] = none;
334 break;
335 default:
338 return __ret;
341 locale::~locale() throw()
342 { _M_impl->_M_remove_reference(); }
344 void
345 locale::_M_coalesce(const locale& __base, const locale& __add,
346 category __cat)
348 __cat = _S_normalize_category(__cat);
349 _M_impl = new _Impl(*__base._M_impl, 1);
351 try
352 { _M_impl->_M_replace_categories(__add._M_impl, __cat); }
353 catch (...)
355 _M_impl->_M_remove_reference();
356 __throw_exception_again;
360 locale::locale() throw()
362 _S_initialize();
363 (_M_impl = _S_global)->_M_add_reference();
364 } // XXX MT
366 locale::locale(const locale& __other) throw()
367 { (_M_impl = __other._M_impl)->_M_add_reference(); }
369 // This is used to initialize global and classic locales, and
370 // assumes that the _Impl objects are constructed correctly.
371 locale::locale(_Impl* __ip) throw() : _M_impl(__ip)
374 locale::locale(const char* __s)
376 if (__s)
378 _S_initialize();
379 if (strcmp(__s, "C") == 0 || strcmp(__s, "POSIX") == 0)
380 (_M_impl = _S_classic)->_M_add_reference();
381 else
382 _M_impl = new _Impl(__s, 1);
384 else
385 __throw_runtime_error("attempt to create locale from NULL name");
388 locale::locale(const locale& __base, const char* __s, category __cat)
390 // NB: There are complicated, yet more efficient ways to do
391 // this. Building up locales on a per-category way is tedious, so
392 // let's do it this way until people complain.
393 locale __add(__s);
394 _M_coalesce(__base, __add, __cat);
397 locale::locale(const locale& __base, const locale& __add, category __cat)
398 { _M_coalesce(__base, __add, __cat); }
400 bool
401 locale::operator==(const locale& __rhs) const throw()
403 string __name = this->name();
404 return (_M_impl == __rhs._M_impl
405 || (__name != "*" && __name == __rhs.name()));
408 const locale&
409 locale::operator=(const locale& __other) throw()
411 __other._M_impl->_M_add_reference();
412 _M_impl->_M_remove_reference();
413 _M_impl = __other._M_impl;
414 return *this;
417 locale
418 locale::global(const locale& __other)
420 // XXX MT
421 _S_initialize();
422 _Impl* __old = _S_global;
423 __other._M_impl->_M_add_reference();
424 _S_global = __other._M_impl;
425 if (_S_global->_M_check_same_name() && _S_global->_M_names[0] != "*")
426 setlocale(LC_ALL, __other.name().c_str());
428 // Reference count sanity check: one reference removed for the
429 // subsition of __other locale, one added by return-by-value. Net
430 // difference: zero. When the returned locale object's destrutor
431 // is called, then the reference count is decremented and possibly
432 // destroyed.
433 return locale(__old);
436 string
437 locale::name() const
439 string __ret;
440 // Need some kind of separator character. This one was pretty much
441 // arbitrarily chosen as to not conflict with glibc locales: the
442 // exact formatting is not set in stone.
443 const char __separator = '|';
445 if (_M_impl->_M_check_same_name())
446 __ret = _M_impl->_M_names[0];
447 else
449 for (size_t i = 0; i < _S_num_categories; ++i)
450 __ret += __separator + _M_impl->_M_names[i];
452 return __ret;
455 locale const&
456 locale::classic()
458 // XXX MT
459 if (!_S_classic)
461 try
463 // 26 Standard facets, 2 references.
464 // One reference for _M_classic, one for _M_global
465 _S_classic = new (&locale_impl_c) _Impl("C", 2);
466 _S_global = _S_classic;
467 new (&locale_c) locale(_S_classic);
469 catch(...)
471 // Just call destructor, so that locale_impl_c's memory is
472 // not deallocated via a call to delete.
473 if (_S_classic)
474 _S_classic->~_Impl();
475 _S_classic = _S_global = 0;
476 __throw_exception_again;
479 return locale_c;
482 locale::category
483 locale::_S_normalize_category(category __cat)
485 int __ret = 0;
486 if (__cat == none || (__cat & all) && !(__cat & ~all))
487 __ret = __cat;
488 else
490 // NB: May be a C-style "LC_ALL" category; convert.
491 switch (__cat)
493 case LC_COLLATE:
494 __ret = collate;
495 break;
496 case LC_CTYPE:
497 __ret = ctype;
498 break;
499 case LC_MONETARY:
500 __ret = monetary;
501 break;
502 case LC_NUMERIC:
503 __ret = numeric;
504 break;
505 case LC_TIME:
506 __ret = time;
507 break;
508 #ifdef _GLIBCPP_HAVE_LC_MESSAGES
509 case LC_MESSAGES:
510 __ret = messages;
511 break;
512 #endif
513 case LC_ALL:
514 __ret = all;
515 break;
516 default:
517 __throw_runtime_error("bad locale category");
520 return __ret;
523 locale::facet::
524 facet(size_t __refs) throw() : _M_references(__refs)
527 void
528 locale::facet::
529 _M_add_reference() throw()
530 { ++_M_references; } // XXX MT
532 void
533 locale::facet::
534 _M_remove_reference() throw()
536 if (_M_references-- == 0)
538 try
539 { delete this; }
540 catch (...)
545 // Definitions for static const data members of ctype_base.
546 const ctype_base::mask ctype_base::space;
547 const ctype_base::mask ctype_base::print;
548 const ctype_base::mask ctype_base::cntrl;
549 const ctype_base::mask ctype_base::upper;
550 const ctype_base::mask ctype_base::lower;
551 const ctype_base::mask ctype_base::alpha;
552 const ctype_base::mask ctype_base::digit;
553 const ctype_base::mask ctype_base::punct;
554 const ctype_base::mask ctype_base::xdigit;
555 const ctype_base::mask ctype_base::alnum;
556 const ctype_base::mask ctype_base::graph;
558 // Platform-specific initialization code for ctype tables.
559 #include <bits/ctype_noninline.h>
561 const size_t ctype<char>::table_size;
563 ctype<char>::~ctype()
564 { if (_M_del) delete[] this->table(); }
566 // These are dummy placeholders as these virtual functions are never called.
567 bool
568 ctype<char>::do_is(mask, char_type) const
569 { return false; }
571 const char*
572 ctype<char>::do_is(const char_type* __c, const char_type*, mask*) const
573 { return __c; }
575 const char*
576 ctype<char>::do_scan_is(mask, const char_type* __c, const char_type*) const
577 { return __c; }
579 const char*
580 ctype<char>::do_scan_not(mask, const char_type* __c, const char_type*) const
581 { return __c; }
583 char
584 ctype<char>::do_widen(char __c) const
585 { return __c; }
587 const char*
588 ctype<char>::do_widen(const char* __lo, const char* __hi, char* __dest) const
590 memcpy(__dest, __lo, __hi - __lo);
591 return __hi;
594 char
595 ctype<char>::do_narrow(char __c, char /*__dfault*/) const
596 { return __c; }
598 const char*
599 ctype<char>::do_narrow(const char* __lo, const char* __hi,
600 char /*__dfault*/, char* __dest) const
602 memcpy(__dest, __lo, __hi - __lo);
603 return __hi;
606 template<>
607 ctype_byname<char>::ctype_byname(const char* /*__s*/, size_t __refs)
608 : ctype<char>(new mask[table_size], true, __refs)
611 // Definitions for static const data members of money_base
612 const money_base::pattern
613 money_base::_S_default_pattern = {{symbol, sign, none, value}};
615 template<>
616 _Format_cache<char>::_Format_cache()
617 : _M_valid(true),
618 _M_decimal_point('.'), _M_thousands_sep(','),
619 _M_truename("true"), _M_falsename("false"), _M_use_grouping(false)
622 #ifdef _GLIBCPP_USE_WCHAR_T
623 template<>
624 _Format_cache<wchar_t>::_Format_cache()
625 : _M_valid(true),
626 _M_decimal_point(L'.'), _M_thousands_sep(L','),
627 _M_truename(L"true"), _M_falsename(L"false"), _M_use_grouping(false)
629 #endif
631 template<>
632 const ctype<char>&
633 use_facet<ctype<char> >(const locale& __loc)
635 size_t __i = ctype<char>::id._M_index;
636 const locale::_Impl* __tmp = __loc._M_impl;
637 return static_cast<const ctype<char>&>(* (*(__tmp->_M_facets))[__i]);
640 #ifdef _GLIBCPP_USE_WCHAR_T
641 template<>
642 const ctype<wchar_t>&
643 use_facet<ctype<wchar_t> >(const locale& __loc)
645 size_t __i = ctype<wchar_t>::id._M_index;
646 const locale::_Impl* __tmp = __loc._M_impl;
647 return static_cast<const ctype<wchar_t>&>(* (*(__tmp->_M_facets))[__i]);
649 #endif
651 template<>
652 void
653 num_get<char, istreambuf_iterator<char> >::
654 _M_extract(istreambuf_iterator<char> __beg,
655 istreambuf_iterator<char> __end, ios_base& __io,
656 ios_base::iostate& __err, char* __xtrc, int& __base,
657 bool __fp) const
659 typedef _Format_cache<char> __cache_type;
661 // Prepare for possible failure
662 __xtrc[0] = '\0';
664 // Stage 1: determine a conversion specifier.
665 ios_base::fmtflags __basefield = __io.flags() & ios_base::basefield;
666 if (__basefield == ios_base::dec)
667 __base = 10;
668 else if (__basefield == ios_base::oct)
669 __base = 8;
670 else if (__basefield == ios_base::hex)
671 __base = 16;
672 else
673 __base = 0;
674 // As far as I can tell, bases other than 10 are not available for
675 // floating point types
676 if (__fp)
677 __base = 10;
679 // Stage 2: extract characters.
680 __cache_type const* __fmt = __cache_type::_S_get(__io);
682 // Fail quickly if !__valid
683 if (__beg == __end)
685 __err |= (ios_base::eofbit | ios_base::failbit);
686 return;
689 // Acceptable formats for numbers here are based on 22.2.3.1
690 string __grp;
691 int __sep_pos = 0;
692 int __pos = 0;
693 const char* __lits = __fmt->_S_literals;
694 char __c = *__beg;
696 // Check first for sign
697 bool __testsign = false;
698 if ((__c == __lits[__cache_type::_S_minus])
699 || (__c == __lits[__cache_type::_S_plus]))
701 __testsign = true;
702 __xtrc[__pos++] = __c;
703 ++__beg;
704 __c = * __beg;
706 // Whitespace may follow a sign
707 while ((__beg != __end) && (isspace(__c)))
709 ++__beg;
710 __c = *__beg;
713 // There had better be more to come...
714 if (__beg == __end)
716 __xtrc[__pos] = '\0';
717 __err |= (ios_base::eofbit | ios_base::failbit);
718 return;
722 // Now check if first character is a zero.
723 bool __testzero = false;
724 if (__c == __lits[__cache_type::_S_digits])
726 __testzero = true;
727 ++__beg;
728 __c = *__beg;
730 // We have to check for __beg == __end here. If so,
731 // a plain '0' (possibly with a sign) can be got rid of now
732 if (__beg == __end)
734 __xtrc[__pos++] = __lits[__cache_type::_S_digits];
735 __xtrc[__pos] = '\0';
736 __err |= ios_base::eofbit;
737 return;
740 // Figure out base for integer types only
741 // Based on Table 55 of 22.2.2.1.2
742 if (!__fp && __base != 10 && __base != 8)
744 // Here, __base == 0 or 16
745 if ((__c == __lits[__cache_type::_S_x])
746 || (__c == __lits[__cache_type::_S_X]))
748 ++__beg;
749 __c = *__beg;
750 __base = 16;
751 __testzero = false; // "0x" is not a leading zero
753 else if (__base == 0)
754 __base = 8;
757 // Remove any more leading zeros
758 while (__beg != __end)
760 if (__c == __lits[__cache_type::_S_digits])
762 ++__beg;
763 __c = *__beg;
764 __testzero = true;
766 else
767 break;
770 else if (__base == 0) // 1st character is not zero
771 __base = 10;
773 // We now seek "units", i.e. digits and thousands separators.
774 // We may need to know if anything is found here. A leading zero
775 // (removed by now) would count.
776 bool __testunits = __testzero;
777 while (__beg != __end)
779 const char* __p = strchr(__lits, __c);
781 // NB: strchr returns true for __c == 0x0
782 if (__p && __c
783 &&((__p >= &__lits[__cache_type::_S_digits]
784 && __p < &__lits[__cache_type::_S_digits + __base])
785 || (__p >= &__lits[__cache_type::_S_udigits]
786 && __p < &__lits[__cache_type::_S_udigits + __base])))
788 // Try first for acceptable digit; record it if found.
789 __xtrc[__pos++] = __c;
790 ++__sep_pos;
791 __testunits = true;
792 ++__beg;
793 __c = *__beg;
795 else if (__c == __fmt->_M_thousands_sep && __fmt->_M_use_grouping)
797 // NB: Thousands separator at the beginning of a string
798 // is a no-no, as is two consecutive thousands
799 // separators.
800 if (__sep_pos)
802 __grp += static_cast<char>(__sep_pos);
803 __sep_pos = 0;
804 ++__beg;
805 __c = *__beg;
807 else
809 __err |= ios_base::failbit;
810 break;
813 else
814 // Not a valid input item.
815 break;
818 // Digit grouping is checked. If _M_groupings() doesn't
819 // match, then get very very upset, and set failbit.
820 if (__fmt->_M_use_grouping && !__grp.empty())
822 // Add the ending grouping
823 __grp += static_cast<char>(__sep_pos);
825 // __grp is parsed L to R
826 // 1,222,444 == __grp of "/1/3/3"
827 // __fmt->_M_grouping is parsed R to L
828 // 1,222,444 == __fmt->_M_grouping of "/3" == "/3/3/3"
829 int __i = 0;
830 int __j = 0;
831 const int __len = __fmt->_M_grouping.size();
832 int __n = __grp.size();
833 bool __test = true;
835 // Parsed number groupings have to match the
836 // numpunct::grouping string exactly, starting at the
837 // right-most point of the parsed sequence of elements ...
838 while (__test && __i < __n - 1)
839 for (__j = 0; __test && __j < __len && __i < __n - 1; ++__j,++__i)
840 __test &= __fmt->_M_grouping[__j] == __grp[__n - __i - 1];
841 // ... but the last parsed grouping can be <= numpunct
842 // grouping.
843 __j == __len ? __j = 0 : __j;
844 __test &= __fmt->_M_grouping[__j] >= __grp[__n - __i - 1];
846 if (!__test)
848 __err |= ios_base::failbit;
849 __xtrc[__pos] = '\0';
850 if (__beg == __end)
851 __err |= ios_base::eofbit;
852 return;
856 // If there was nothing but zeros, put one in the output string
857 if (__testzero && (__pos == 0 || (__pos == 1 && __testsign)))
858 __xtrc[__pos++] = __lits[__cache_type::_S_digits];
860 // That's it for integer types. Remaining code is for floating point
861 if (__fp && __beg != __end)
863 // Check first for decimal point. There MUST be one if
864 // __testunits is false.
865 bool __testdec = false; // Is there a decimal point
866 // with digits following it?
867 if (__c == __fmt->_M_decimal_point)
869 __xtrc[__pos++] = '.';
870 ++__beg;
871 __c = *__beg;
873 // Now we get any digits after the decimal point
874 // There MUST be some if __testunits is false.
875 while (__beg != __end)
877 const char* __p = strchr(__lits, __c);
878 if ((__p >= &__lits[__cache_type::_S_digits]
879 && __p < &__lits[__cache_type::_S_digits + __base])
880 || (__p >= &__lits[__cache_type::_S_udigits]
881 && __p < &__lits[__cache_type::_S_udigits + __base]))
883 __xtrc[__pos++] = __c;
884 ++__beg;
885 __c = *__beg;
886 __testdec = true;
888 else
889 break;
892 if (!__testunits && !__testdec) // Ill formed
894 __err |= ios_base::failbit;
895 __xtrc[__pos] = '\0';
896 if (__beg == __end)
897 __err |= ios_base::eofbit;
898 return;
901 // Now we may find an exponent
902 if (__beg != __end)
904 if ((__c == __lits[__cache_type::_S_ee])
905 || (__c == __lits[__cache_type::_S_Ee]))
907 __xtrc[__pos++] = __c;
908 ++__beg;
909 __c = *__beg;
911 // Now there may be a sign
912 if (__beg != __end)
914 if ((__c == __lits[__cache_type::_S_minus])
915 || (__c == __lits[__cache_type::_S_plus]))
917 __xtrc[__pos++] = __c;
918 ++__beg;
919 __c = *__beg;
920 // whitespace may follow a sign
921 while ((__beg != __end) && (isspace(__c)))
923 ++__beg;
924 __c = *__beg;
928 // And now there must be some digits
929 if (__beg == __end)
931 __xtrc[__pos] = '\0';
932 __err |= (ios_base::eofbit | ios_base::failbit);
933 return;
935 while (__beg != __end)
937 const char* __p = strchr(__lits, __c);
938 if ((__p >= &__lits[__cache_type::_S_digits]
939 && __p < &__lits[__cache_type::_S_digits + __base])
940 || (__p >= &__lits[__cache_type::_S_udigits]
941 && __p < &__lits[__cache_type::_S_udigits + __base]))
943 __xtrc[__pos++] = __c;
944 ++__beg;
945 __c = *__beg;
947 else
948 break;
952 // Finally, that's it for floating point
955 // Finish up
956 __xtrc[__pos] = '\0';
957 if (__beg == __end)
958 __err |= ios_base::eofbit;
961 // The following code uses sprintf() to convert floating point
962 // values for insertion into a stream. The current implementation
963 // replicates the code in _S_pad_numeric() (in _S_output_float()) in
964 // order to prevent having to create a "wide" buffer in addition to
965 // the "narrow" buffer passed to sprintf(). An optimization would be
966 // to replace sprintf() with code that works directly on a wide
967 // buffer and then use _S_pad_numeric() to do the padding. It would
968 // be good to replace sprintf() anyway to avoid accidental buffer
969 // overruns and to gain back the efficiency that C++ provides by
970 // knowing up front the type of the values to insert. This
971 // implementation follows the C++ standard fairly directly as
972 // outlined in 22.2.2.2 [lib.locale.num.put]
973 bool
974 __build_float_format(ios_base& __io, char* __fptr, char __modifier,
975 streamsize __prec)
977 bool __incl_prec = false;
978 ios_base::fmtflags __flags = __io.flags();
979 *__fptr++ = '%';
980 // [22.2.2.2.2] Table 60
981 if (__flags & ios_base::showpos)
982 *__fptr++ = '+';
983 if (__flags & ios_base::showpoint)
984 *__fptr++ = '#';
985 // As per [22.2.2.2.2.11]
986 if (__flags & ios_base::fixed || __prec > 0)
988 *__fptr++ = '.';
989 *__fptr++ = '*';
990 __incl_prec = true;
992 if (__modifier)
993 *__fptr++ = __modifier;
994 ios_base::fmtflags __fltfield = __flags & ios_base::floatfield;
995 // [22.2.2.2.2] Table 58
996 if (__fltfield == ios_base::fixed)
997 *__fptr++ = 'f';
998 else if (__fltfield == ios_base::scientific)
999 *__fptr++ = (__flags & ios_base::uppercase) ? 'E' : 'e';
1000 else
1001 *__fptr++ = (__flags & ios_base::uppercase) ? 'G' : 'g';
1002 *__fptr = '\0';
1003 return __incl_prec;
1006 template <>
1007 collate<char>::collate(size_t __refs)
1008 : locale::facet(__refs) { }
1010 template<>
1011 collate<char>::~collate() { }
1013 template<>
1014 int
1015 collate<char>::do_compare(const char* __lo1, const char* __hi1,
1016 const char* __lo2, const char* __hi2) const
1018 for (; __lo1 < __hi1 && __lo2 < __hi2; ++__lo1, ++__lo2)
1019 if (*__lo1 != *__lo2)
1020 return (*__lo1 < *__lo2) ? -1 : 1;
1021 if (__lo1 < __hi1)
1022 return 1;
1023 else if (__lo2 < __hi2)
1024 return -1;
1025 else
1026 return 0;
1029 template<>
1030 string
1031 collate<char>::
1032 do_transform(const char* __lo, const char* __hi) const
1033 { return string(__lo, __hi - __lo); }
1035 template<>
1036 long
1037 collate<char>::
1038 do_hash(const char* __lo, const char* __hi) const
1040 unsigned long __val = 0xdeadbeef;
1041 for (; __lo < __hi; ++__lo)
1042 __val = *__lo ^ ((__val << 7) &
1043 (__val >> (numeric_limits<unsigned long>::digits - 1)));
1044 return __val;
1047 template<>
1048 collate_byname<char>::collate_byname(const char* /*__s*/, size_t __refs)
1049 : collate<char>(__refs) { }
1051 template<>
1052 moneypunct_byname<char, false>::moneypunct_byname(const char* /*__s*/,
1053 size_t __refs)
1054 : moneypunct<char, false>(__refs) { }
1056 template<>
1057 moneypunct_byname<char, true>::moneypunct_byname(const char* /*__s*/,
1058 size_t __refs)
1059 : moneypunct<char, true>(__refs) { }
1061 template<>
1062 messages_byname<char>::
1063 messages_byname(const char* /*__s*/, size_t __refs)
1064 : messages<char>(__refs) { }
1066 #ifdef _GLIBCPP_USE_WCHAR_T
1067 ctype<wchar_t>::__wmask_type
1068 ctype<wchar_t>::_M_convert_to_wmask(const mask __m) const
1070 __wmask_type __ret;
1071 switch (__m)
1073 case space:
1074 __ret = wctype("space");
1075 break;
1076 case print:
1077 __ret = wctype("print");
1078 break;
1079 case cntrl:
1080 __ret = wctype("cntrl");
1081 break;
1082 case upper:
1083 __ret = wctype("upper");
1084 break;
1085 case lower:
1086 __ret = wctype("lower");
1087 break;
1088 case alpha:
1089 __ret = wctype("alpha");
1090 break;
1091 case digit:
1092 __ret = wctype("digit");
1093 break;
1094 case punct:
1095 __ret = wctype("punct");
1096 break;
1097 case xdigit:
1098 __ret = wctype("xdigit");
1099 break;
1100 case alnum:
1101 __ret = wctype("alnum");
1102 break;
1103 case graph:
1104 __ret = wctype("graph");
1105 break;
1106 default:
1107 __ret = 0;
1109 return __ret;
1112 ctype<wchar_t>::~ctype() { }
1114 // NB: These ctype<wchar_t> methods are not configuration-specific,
1115 // unlike the ctype<char> bits.
1116 ctype<wchar_t>::ctype(size_t __refs) : __ctype_abstract_base<wchar_t>(__refs)
1119 wchar_t
1120 ctype<wchar_t>::do_toupper(wchar_t __c) const
1121 { return towupper(__c); }
1123 const wchar_t*
1124 ctype<wchar_t>::do_toupper(wchar_t* __lo, const wchar_t* __hi) const
1126 while (__lo < __hi)
1128 *__lo = towupper(*__lo);
1129 ++__lo;
1131 return __hi;
1134 wchar_t
1135 ctype<wchar_t>::do_tolower(wchar_t __c) const
1136 { return towlower(__c); }
1138 const wchar_t*
1139 ctype<wchar_t>::do_tolower(wchar_t* __lo, const wchar_t* __hi) const
1141 while (__lo < __hi)
1143 *__lo = towlower(*__lo);
1144 ++__lo;
1146 return __hi;
1149 bool
1150 ctype<wchar_t>::
1151 do_is(mask __m, char_type __c) const
1152 { return static_cast<bool>(iswctype(__c, _M_convert_to_wmask(__m))); }
1154 const wchar_t*
1155 ctype<wchar_t>::
1156 do_is(const wchar_t* __lo, const wchar_t* __hi, mask* __m) const
1158 while (__lo < __hi && !this->is(*__m, *__lo))
1159 ++__lo;
1160 return __lo;
1163 const wchar_t*
1164 ctype<wchar_t>::
1165 do_scan_is(mask __m, const wchar_t* __lo, const wchar_t* __hi) const
1167 while (__lo < __hi && !this->is(__m, *__lo))
1168 ++__lo;
1169 return __lo;
1172 const wchar_t*
1173 ctype<wchar_t>::
1174 do_scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
1176 while (__lo < __hi && this->is(__m, *__lo) != 0)
1177 ++__lo;
1178 return __lo;
1181 wchar_t
1182 ctype<wchar_t>::
1183 do_widen(char __c) const
1184 { return btowc(__c); }
1186 const char*
1187 ctype<wchar_t>::
1188 do_widen(const char* __lo, const char* __hi, wchar_t* __dest) const
1190 mbstate_t __state;
1191 memset(static_cast<void*>(&__state), 0, sizeof(mbstate_t));
1192 mbsrtowcs(__dest, &__lo, __hi - __lo, &__state);
1193 return __hi;
1196 char
1197 ctype<wchar_t>::
1198 do_narrow(wchar_t __wc, char __dfault) const
1200 int __c = wctob(__wc);
1201 return (__c == EOF ? __dfault : static_cast<char>(__c));
1204 const wchar_t*
1205 ctype<wchar_t>::
1206 do_narrow(const wchar_t* __lo, const wchar_t* __hi, char __dfault,
1207 char* __dest) const
1209 mbstate_t __state;
1210 memset(static_cast<void*>(&__state), 0, sizeof(mbstate_t));
1211 size_t __len = __hi - __lo;
1212 size_t __conv = wcsrtombs(__dest, &__lo, __len, &__state);
1213 if (__conv == __len)
1214 *__dest = __dfault;
1215 return __hi;
1218 template<>
1219 ctype_byname<wchar_t>::
1220 ctype_byname(const char* /*__s*/, size_t __refs)
1221 : ctype<wchar_t>(__refs) { }
1223 template<>
1224 collate<wchar_t>::
1225 collate(size_t __refs): locale::facet(__refs) { }
1227 template<>
1228 collate<wchar_t>::
1229 ~collate() { }
1231 template<>
1232 int
1233 collate<wchar_t>::
1234 do_compare(const wchar_t* /*__lo1*/, const wchar_t* /*__hi1*/,
1235 const wchar_t* /*__lo2*/, const wchar_t* /*__hi2*/) const
1237 return 0; // XXX not done
1240 template<>
1241 wstring collate<wchar_t>::
1242 do_transform(const wchar_t* /*__lo*/, const wchar_t* /*__hi*/) const
1244 return wstring(); // XXX not done
1247 template<>
1248 long collate<wchar_t>::
1249 do_hash(const wchar_t* /*__lo*/, const wchar_t* /*__hi*/) const
1251 return 0; // XXX not done
1254 template<>
1255 collate_byname<wchar_t>::
1256 collate_byname(const char* /*__s*/, size_t __refs)
1257 : collate<wchar_t> (__refs) { }
1259 template<>
1260 messages_byname<wchar_t>::
1261 messages_byname(const char* /*__s*/, size_t __refs)
1262 : messages<wchar_t> (__refs) { }
1263 #endif // _GLIBCPP_USE_WCHAR_T
1264 } // namespace std