00001 
00002 
00003 
00004 
00005 
00006 
00007 
00008 
00009 
00010 
00011 
00012 
00013 
00014 
00015 
00016 
00017 
00018 
00019 
00020 
00021 
00022 
00023 
00024 
00025 
00026 
00027 
00028 
00029 
00030 
00031 
00032 
00033 #ifndef _CPP_BITS_LOCFACETS_TCC
00034 #define _CPP_BITS_LOCFACETS_TCC 1
00035 
00036 #pragma GCC system_header
00037 
00038 #include <cerrno>
00039 #include <clocale>   
00040 #include <cstdlib>   
00041 #include <cmath>     
00042 #include <cctype>    
00043 #include <limits>    
00044 #include <bits/streambuf_iterator.h>
00045 #include <typeinfo>  
00046 
00047 namespace std
00048 {
00049   template<typename _Facet>
00050     locale
00051     locale::combine(const locale& __other) const
00052     {
00053       _Impl* __tmp = new _Impl(*_M_impl, 1);
00054       __tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
00055       return locale(__tmp);
00056     }
00057 
00058   template<typename _CharT, typename _Traits, typename _Alloc>
00059     bool
00060     locale::operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
00061                        const basic_string<_CharT, _Traits, _Alloc>& __s2) const
00062     {
00063       typedef std::collate<_CharT> __collate_type;
00064       const __collate_type& __collate = use_facet<__collate_type>(*this);
00065       return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
00066                 __s2.data(), __s2.data() + __s2.length()) < 0);
00067     }
00068 
00069   template<typename _Facet>
00070     const _Facet&
00071     use_facet(const locale& __loc)
00072     {
00073       size_t __i = _Facet::id._M_id();
00074       locale::facet** __facets = __loc._M_impl->_M_facets;
00075       if (!(__i < __loc._M_impl->_M_facets_size && __facets[__i]))
00076         __throw_bad_cast();
00077       return static_cast<const _Facet&>(*__facets[__i]);
00078     }
00079 
00080   template<typename _Facet>
00081     bool
00082     has_facet(const locale& __loc) throw()
00083     {
00084       size_t __i = _Facet::id._M_id();
00085       locale::facet** __facets = __loc._M_impl->_M_facets;
00086       return (__i < __loc._M_impl->_M_facets_size && __facets[__i]);
00087     }
00088 
00089 
00090   
00091   template<typename _CharT, typename _InIter>
00092     _InIter
00093     num_get<_CharT, _InIter>::
00094     _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,
00095              ios_base::iostate& __err, string& __xtrc) const
00096     {
00097       const locale __loc = __io.getloc();
00098       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
00099       const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
00100 
00101       
00102       const char_type __plus = __ctype.widen('+');
00103       const char_type __minus = __ctype.widen('-');
00104       int __pos = 0;
00105       char_type  __c = *__beg;
00106       if ((__c == __plus || __c == __minus) && __beg != __end)
00107     {
00108       __xtrc += __ctype.narrow(__c, char());
00109       ++__pos;
00110       __c = *(++__beg);
00111     }
00112 
00113       
00114       const char_type __zero = __ctype.widen(_S_atoms[_M_zero]);
00115       bool __found_zero = false;
00116       while (__c == __zero && __beg != __end)
00117     {
00118       __c = *(++__beg);
00119       __found_zero = true;
00120     }
00121       if (__found_zero)
00122     {
00123       __xtrc += _S_atoms[_M_zero];
00124       ++__pos;
00125     }
00126 
00127       
00128       const size_t __len = _M_E - _M_zero + 1;
00129       char_type  __watoms[__len];
00130       __ctype.widen(_S_atoms, _S_atoms + __len, __watoms);
00131       bool __found_dec = false;
00132       bool __found_sci = false;
00133       const char_type __dec = __np.decimal_point();
00134 
00135       string __found_grouping;
00136       const string __grouping = __np.grouping();
00137       bool __check_grouping = __grouping.size();
00138       int __sep_pos = 0;
00139       const char_type __sep = __np.thousands_sep();
00140 
00141       while (__beg != __end)
00142         {
00143       
00144       typedef char_traits<_CharT>   __traits_type;
00145           const char_type* __p = __traits_type::find(__watoms, 10,  __c);
00146 
00147           
00148           if (__p && __c)
00149         {
00150           
00151           ++__pos;
00152           __xtrc += _S_atoms[__p - __watoms];
00153           ++__sep_pos;
00154           __c = *(++__beg);
00155         }
00156           else if (__c == __sep && __check_grouping && !__found_dec)
00157         {
00158               
00159               
00160               if (__sep_pos)
00161                 {
00162                   __found_grouping += static_cast<char>(__sep_pos);
00163                   __sep_pos = 0;
00164           __c = *(++__beg);
00165                 }
00166               else
00167         {
00168           __err |= ios_base::failbit;
00169           break;
00170         }
00171             }
00172       else if (__c == __dec && !__found_dec)
00173         {
00174           
00175           
00176           
00177           if (__found_grouping.size())
00178         __found_grouping += static_cast<char>(__sep_pos);
00179           ++__pos;
00180           __xtrc += '.';
00181           __c = *(++__beg);
00182           __found_dec = true;
00183         }
00184       else if ((__c == __watoms[_M_e] || __c == __watoms[_M_E]) 
00185            && !__found_sci && __pos)
00186         {
00187           
00188           ++__pos;
00189           __xtrc += __ctype.narrow(__c, char());
00190           __c = *(++__beg);
00191 
00192           
00193           if (__c == __plus || __c == __minus)
00194         {
00195           ++__pos;
00196           __xtrc += __ctype.narrow(__c, char());
00197           __c = *(++__beg);
00198         }
00199           __found_sci = true;
00200         }
00201       else
00202         
00203         break;
00204         }
00205 
00206       
00207       
00208       if (__check_grouping && __found_grouping.size())
00209         {
00210           
00211       if (!__found_dec)
00212         __found_grouping += static_cast<char>(__sep_pos);
00213           if (!__verify_grouping(__grouping, __found_grouping))
00214         __err |= ios_base::failbit;
00215         }
00216 
00217       
00218       __xtrc += char();
00219       if (__beg == __end)
00220         __err |= ios_base::eofbit;
00221       return __beg;
00222     }
00223 
00224   
00225   template<typename _CharT, typename _InIter>
00226     _InIter
00227     num_get<_CharT, _InIter>::
00228     _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
00229            ios_base::iostate& __err, string& __xtrc, int& __base) const
00230     {
00231       const locale __loc = __io.getloc();
00232       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
00233       const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
00234  
00235       
00236       ios_base::fmtflags __basefield = __io.flags() & ios_base::basefield;
00237       if (__basefield == ios_base::oct)
00238         __base = 8;
00239       else if (__basefield == ios_base::hex)
00240         __base = 16;
00241       else
00242     __base = 10;
00243 
00244      
00245       int __pos = 0;
00246       char_type  __c = *__beg;
00247       if ((__c == __ctype.widen('+') || __c == __ctype.widen('-'))
00248       && __beg != __end)
00249     {
00250       __xtrc += __ctype.narrow(__c, char());
00251       ++__pos;
00252       __c = *(++__beg);
00253     }
00254 
00255       
00256       const char_type __zero = __ctype.widen(_S_atoms[_M_zero]);
00257       const char_type __x = __ctype.widen('x');
00258       const char_type __X = __ctype.widen('X');
00259       if (__base == 10)
00260     {
00261       bool __found_zero = false;
00262       while (__c == __zero && __beg != __end)
00263         {
00264           __c = *(++__beg);
00265           __found_zero = true;
00266         }
00267       if (__found_zero)
00268         {
00269           __xtrc += _S_atoms[_M_zero];
00270           ++__pos;
00271           if (__basefield == 0)
00272         {         
00273           if ((__c == __x || __c == __X) && __beg != __end)
00274             {
00275               __xtrc += __ctype.narrow(__c, char());
00276               ++__pos;
00277               __c = *(++__beg);
00278               __base = 16;
00279             }
00280           else 
00281             __base = 8;
00282         }
00283         }
00284     }
00285       else if (__base == 16)
00286     {
00287       if (__c == __zero && __beg != __end)
00288         {
00289           __xtrc += _S_atoms[_M_zero];
00290           ++__pos;
00291           __c = *(++__beg); 
00292           if  ((__c == __x || __c == __X) && __beg != __end)
00293         {
00294           __xtrc += __ctype.narrow(__c, char());
00295           ++__pos;
00296           __c = *(++__beg);
00297         }
00298         }
00299     }
00300 
00301       
00302       
00303       size_t __len;
00304       if (__base == 16)
00305     __len = _M_size;
00306       else
00307     __len = __base;
00308 
00309       
00310       char_type __watoms[_M_size];
00311       __ctype.widen(_S_atoms, _S_atoms + __len, __watoms);
00312       string __found_grouping;
00313       const string __grouping = __np.grouping();
00314       bool __check_grouping = __grouping.size();
00315       int __sep_pos = 0;
00316       const char_type __sep = __np.thousands_sep();
00317       while (__beg != __end)
00318         {
00319       typedef char_traits<_CharT>   __traits_type;
00320           const char_type* __p = __traits_type::find(__watoms, __len,  __c);
00321 
00322           
00323           if (__p && __c)
00324         {
00325           
00326           __xtrc += _S_atoms[__p - __watoms];
00327           ++__pos;
00328           ++__sep_pos;
00329           __c = *(++__beg);
00330         }
00331           else if (__c == __sep && __check_grouping)
00332         {
00333               
00334               
00335               if (__sep_pos)
00336                 {
00337                   __found_grouping += static_cast<char>(__sep_pos);
00338                   __sep_pos = 0;
00339           __c = *(++__beg);
00340                 }
00341               else
00342         {
00343           __err |= ios_base::failbit;
00344           break;
00345         }
00346             }
00347       else
00348         
00349         break;
00350         }
00351 
00352       
00353       
00354       if (__check_grouping && __found_grouping.size())
00355         {
00356           
00357           __found_grouping += static_cast<char>(__sep_pos);
00358           if (!__verify_grouping(__grouping, __found_grouping))
00359         __err |= ios_base::failbit;
00360         }
00361 
00362       
00363       __xtrc += char();
00364       if (__beg == __end)
00365         __err |= ios_base::eofbit;
00366       return __beg;
00367     }
00368 
00369 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
00370   
00371   template<typename _CharT, typename _InIter>
00372     _InIter
00373     num_get<_CharT, _InIter>::
00374     do_get(iter_type __beg, iter_type __end, ios_base& __io,
00375            ios_base::iostate& __err, bool& __v) const
00376     {
00377       
00378       if (!(__io.flags() & ios_base::boolalpha))
00379         {
00380           
00381           
00382           string __xtrc;
00383           int __base;
00384           __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, __base);
00385 
00386       unsigned long __ul; 
00387       __convert_to_v(__xtrc.c_str(), __ul, __err, _S_c_locale, __base);
00388       if (!(__err & ios_base::failbit) && __ul <= 1)
00389         __v = __ul;
00390       else 
00391             __err |= ios_base::failbit;
00392         }
00393 
00394       
00395       else
00396         {
00397       typedef basic_string<_CharT> __string_type;
00398           locale __loc = __io.getloc();
00399       const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc); 
00400       const __string_type __true = __np.truename();
00401       const __string_type __false = __np.falsename();
00402           const char_type* __trues = __true.c_str();
00403           const char_type* __falses = __false.c_str();
00404           const size_t __truen =  __true.size() - 1;
00405           const size_t __falsen =  __false.size() - 1;
00406 
00407           for (size_t __n = 0; __beg != __end; ++__n)
00408             {
00409               char_type __c = *__beg++;
00410               bool __testf = __n <= __falsen ? __c == __falses[__n] : false;
00411               bool __testt = __n <= __truen ? __c == __trues[__n] : false;
00412               if (!(__testf || __testt))
00413                 {
00414                   __err |= ios_base::failbit;
00415                   break;
00416                 }
00417               else if (__testf && __n == __falsen)
00418                 {
00419                   __v = 0;
00420                   break;
00421                 }
00422               else if (__testt && __n == __truen)
00423                 {
00424                   __v = 1;
00425                   break;
00426                 }
00427             }
00428           if (__beg == __end)
00429             __err |= ios_base::eofbit;
00430         }
00431       return __beg;
00432     }
00433 #endif
00434 
00435   template<typename _CharT, typename _InIter>
00436     _InIter
00437     num_get<_CharT, _InIter>::
00438     do_get(iter_type __beg, iter_type __end, ios_base& __io,
00439            ios_base::iostate& __err, long& __v) const
00440     {
00441       string __xtrc;
00442       int __base;
00443       __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, __base);
00444       __convert_to_v(__xtrc.c_str(), __v, __err, _S_c_locale, __base);
00445       return __beg;
00446     }
00447 
00448   template<typename _CharT, typename _InIter>
00449     _InIter
00450     num_get<_CharT, _InIter>::
00451     do_get(iter_type __beg, iter_type __end, ios_base& __io,
00452            ios_base::iostate& __err, unsigned short& __v) const
00453     {
00454       string __xtrc;
00455       int __base;
00456       __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, __base);
00457       unsigned long __ul;
00458       __convert_to_v(__xtrc.c_str(), __ul, __err, _S_c_locale, __base);
00459       if (!(__err & ios_base::failbit) 
00460       && __ul <= numeric_limits<unsigned short>::max())
00461     __v = static_cast<unsigned short>(__ul);
00462       else 
00463     __err |= ios_base::failbit;
00464       return __beg;
00465     }
00466 
00467   template<typename _CharT, typename _InIter>
00468     _InIter
00469     num_get<_CharT, _InIter>::
00470     do_get(iter_type __beg, iter_type __end, ios_base& __io,
00471            ios_base::iostate& __err, unsigned int& __v) const
00472     {
00473       string __xtrc;
00474       int __base;
00475       __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, __base);
00476       unsigned long __ul;
00477       __convert_to_v(__xtrc.c_str(), __ul, __err, _S_c_locale, __base);
00478       if (!(__err & ios_base::failbit) 
00479       && __ul <= numeric_limits<unsigned int>::max())
00480     __v = static_cast<unsigned int>(__ul);
00481       else 
00482     __err |= ios_base::failbit;
00483       return __beg;
00484     }
00485 
00486   template<typename _CharT, typename _InIter>
00487     _InIter
00488     num_get<_CharT, _InIter>::
00489     do_get(iter_type __beg, iter_type __end, ios_base& __io,
00490            ios_base::iostate& __err, unsigned long& __v) const
00491     {
00492       string __xtrc;
00493       int __base;
00494       __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, __base);
00495       __convert_to_v(__xtrc.c_str(), __v, __err, _S_c_locale, __base);
00496       return __beg;
00497     }
00498 
00499 #ifdef _GLIBCPP_USE_LONG_LONG
00500   template<typename _CharT, typename _InIter>
00501     _InIter
00502     num_get<_CharT, _InIter>::
00503     do_get(iter_type __beg, iter_type __end, ios_base& __io,
00504            ios_base::iostate& __err, long long& __v) const
00505     {
00506       string __xtrc;
00507       int __base;
00508       __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, __base);
00509       __convert_to_v(__xtrc.c_str(), __v, __err, _S_c_locale, __base);
00510       return __beg;
00511     }
00512 
00513   template<typename _CharT, typename _InIter>
00514     _InIter
00515     num_get<_CharT, _InIter>::
00516     do_get(iter_type __beg, iter_type __end, ios_base& __io,
00517            ios_base::iostate& __err, unsigned long long& __v) const
00518     {
00519       string __xtrc;
00520       int __base;
00521       __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, __base);
00522       __convert_to_v(__xtrc.c_str(), __v, __err, _S_c_locale, __base);
00523       return __beg;
00524     }
00525 #endif
00526 
00527   template<typename _CharT, typename _InIter>
00528     _InIter
00529     num_get<_CharT, _InIter>::
00530     do_get(iter_type __beg, iter_type __end, ios_base& __io, 
00531        ios_base::iostate& __err, float& __v) const
00532     {
00533       string __xtrc;
00534       __xtrc.reserve(32);
00535       __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
00536       __convert_to_v(__xtrc.c_str(), __v, __err, _S_c_locale);
00537       return __beg;
00538     }
00539 
00540   template<typename _CharT, typename _InIter>
00541     _InIter
00542     num_get<_CharT, _InIter>::
00543     do_get(iter_type __beg, iter_type __end, ios_base& __io,
00544            ios_base::iostate& __err, double& __v) const
00545     {
00546       string __xtrc;
00547       __xtrc.reserve(32);
00548       __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
00549       __convert_to_v(__xtrc.c_str(), __v, __err, _S_c_locale);
00550       return __beg;
00551     }
00552 
00553   template<typename _CharT, typename _InIter>
00554     _InIter
00555     num_get<_CharT, _InIter>::
00556     do_get(iter_type __beg, iter_type __end, ios_base& __io,
00557            ios_base::iostate& __err, long double& __v) const
00558     {
00559       string __xtrc;
00560       __xtrc.reserve(32);
00561       __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
00562       __convert_to_v(__xtrc.c_str(), __v, __err, _S_c_locale);
00563       return __beg;
00564     }
00565 
00566   template<typename _CharT, typename _InIter>
00567     _InIter
00568     num_get<_CharT, _InIter>::
00569     do_get(iter_type __beg, iter_type __end, ios_base& __io,
00570            ios_base::iostate& __err, void*& __v) const
00571     {
00572       
00573       typedef ios_base::fmtflags        fmtflags;
00574       fmtflags __fmt = __io.flags();
00575       fmtflags __fmtmask = ~(ios_base::showpos | ios_base::basefield
00576                              | ios_base::uppercase | ios_base::internal);
00577       __io.flags(__fmt & __fmtmask | (ios_base::hex | ios_base::showbase));
00578 
00579       string __xtrc;
00580       int __base;
00581       __beg = _M_extract_int(__beg, __end, __io, __err, __xtrc, __base);
00582 
00583       
00584       __io.flags(__fmt);
00585 
00586       unsigned long __ul;
00587       __convert_to_v(__xtrc.c_str(), __ul, __err, _S_c_locale, __base);
00588       if (!(__err & ios_base::failbit))
00589     __v = reinterpret_cast<void*>(__ul);
00590       else 
00591     __err |= ios_base::failbit;
00592       return __beg;
00593     }
00594 
00595   
00596   
00597   
00598   
00599   
00600   
00601   
00602   
00603   
00604   template<typename _CharT, typename _OutIter>
00605     template<typename _ValueT>
00606       _OutIter
00607       num_put<_CharT, _OutIter>::
00608       _M_convert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
00609                _ValueT __v) const
00610       {
00611     
00612     
00613     const int __max_digits = numeric_limits<_ValueT>::digits10 + 1;
00614     streamsize __prec = __io.precision();
00615 
00616     if (__prec > static_cast<streamsize>(__max_digits))
00617       __prec = static_cast<streamsize>(__max_digits);
00618 
00619     
00620     char __fbuf[16];
00621 
00622     
00623     int __len;
00624 #ifdef _GLIBCPP_USE_C99
00625     
00626     
00627     int __cs_size = __max_digits * 3;
00628     char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
00629 
00630     const bool __fp = _S_format_float(__io, __fbuf, __mod, __prec);
00631     if (__fp)
00632       __len = __convert_from_v(__cs, __cs_size, __fbuf, __v, 
00633                    _S_c_locale, __prec);
00634     else
00635       __len = __convert_from_v(__cs, __cs_size, __fbuf, __v, _S_c_locale);
00636 
00637     
00638     if (__len >= __cs_size)
00639       {
00640         __cs_size = __len + 1; 
00641         __cs = static_cast<char*>(__builtin_alloca(__cs_size));
00642         if (__fp)
00643           __len = __convert_from_v(__cs, __cs_size, __fbuf, __v, 
00644                        _S_c_locale, __prec);
00645         else
00646           __len = __convert_from_v(__cs, __cs_size, __fbuf, __v, 
00647                        _S_c_locale);
00648       }
00649 #else
00650     
00651     const bool __fixed = __io.flags() & ios_base::fixed;
00652     const int __max_exp = numeric_limits<_ValueT>::max_exponent10;
00653     
00654     
00655     
00656     
00657     
00658     const int __cs_size = __fixed ? __max_exp + __max_digits + 4 
00659                                   : __max_digits * 3;
00660     char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
00661 
00662     if (_S_format_float(__io, __fbuf, __mod, __prec))
00663       __len = __convert_from_v(__cs, 0, __fbuf, __v, _S_c_locale, __prec);
00664     else
00665       __len = __convert_from_v(__cs, 0, __fbuf, __v, _S_c_locale);
00666 #endif
00667     return _M_widen_float(__s, __io, __fill, __cs, __len);
00668       }
00669 
00670   template<typename _CharT, typename _OutIter>
00671     template<typename _ValueT>
00672       _OutIter
00673       num_put<_CharT, _OutIter>::
00674       _M_convert_int(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
00675              char __modl, _ValueT __v) const
00676       {
00677     
00678 
00679     
00680     char __fbuf[16];
00681     _S_format_int(__io, __fbuf, __mod, __modl);
00682 #ifdef _GLIBCPP_USE_C99
00683     
00684     int __cs_size = 64;
00685     char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
00686     int __len = __convert_from_v(__cs, __cs_size, __fbuf, __v, 
00687                      _S_c_locale);
00688     
00689     if (__len >= __cs_size)
00690       {
00691         __cs_size = __len + 1;
00692         __cs = static_cast<char*>(__builtin_alloca(__cs_size));
00693         __len = __convert_from_v(__cs, __cs_size, __fbuf, __v, 
00694                      _S_c_locale);
00695       }
00696 #else
00697     
00698     
00699     char __cs[128];
00700     int __len = __convert_from_v(__cs, 0, __fbuf, __v, _S_c_locale);
00701 #endif
00702     return _M_widen_int(__s, __io, __fill, __cs, __len);
00703       }
00704 
00705   template<typename _CharT, typename _OutIter>
00706     _OutIter
00707     num_put<_CharT, _OutIter>::
00708     _M_widen_float(_OutIter __s, ios_base& __io, _CharT __fill, char* __cs, 
00709            int __len) const
00710     {
00711       
00712       
00713       const locale __loc = __io.getloc();
00714       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
00715       _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) 
00716                                * __len));
00717       
00718       
00719       _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) 
00720                                 * __len * 2));
00721       __ctype.widen(__cs, __cs + __len, __ws);
00722       
00723       
00724       const _CharT* __p;
00725       const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
00726       if (__p = char_traits<_CharT>::find(__ws, __len, __ctype.widen('.')))
00727     __ws[__p - __ws] = __np.decimal_point();
00728 
00729 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
00730 
00731       
00732       const string __grouping = __np.grouping();
00733       ios_base::fmtflags __basefield = __io.flags() & ios_base::basefield;
00734       if (__grouping.size())
00735     {
00736       _CharT* __p2;
00737       int __declen = __p ? __p - __ws : __len;
00738       __p2 = __add_grouping(__ws2, __np.thousands_sep(), 
00739                 __grouping.c_str(),
00740                 __grouping.c_str() + __grouping.size(),
00741                 __ws, __ws + __declen);
00742       int __newlen = __p2 - __ws2;
00743     
00744       
00745       if (__p)
00746         {
00747           char_traits<_CharT>::copy(__p2, __p, __len - __declen);
00748           __newlen += __len - __declen;
00749         }    
00750 
00751       
00752       __ws = __ws2;
00753       __len = __newlen;
00754     }
00755 #endif
00756       return _M_insert(__s, __io, __fill, __ws, __len);
00757     }
00758 
00759   template<typename _CharT, typename _OutIter>
00760     _OutIter
00761     num_put<_CharT, _OutIter>::
00762     _M_widen_int(_OutIter __s, ios_base& __io, _CharT __fill, char* __cs, 
00763          int __len) const
00764     {
00765       
00766       
00767       const locale __loc = __io.getloc();
00768       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
00769       _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) 
00770                                * __len));
00771       
00772       
00773       _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) 
00774                                 * __len * 2));
00775       __ctype.widen(__cs, __cs + __len, __ws);
00776 
00777       
00778       const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
00779       const string __grouping = __np.grouping();
00780       const ios_base::fmtflags __basefield = __io.flags() & ios_base::basefield;
00781       if (__grouping.size())
00782     {
00783       
00784       
00785       
00786       streamsize __off = 0;
00787       if (__io.flags() & ios_base::showbase)
00788         if (__basefield == ios_base::oct)
00789           {
00790         __off = 1;
00791         *__ws2 = *__ws;
00792           }
00793         else if (__basefield == ios_base::hex)
00794           {
00795         __off = 2;
00796         *__ws2 = *__ws;
00797         *(__ws2 + 1) = *(__ws + 1);
00798           }
00799       _CharT* __p;
00800       __p = __add_grouping(__ws2 + __off, __np.thousands_sep(), 
00801                    __grouping.c_str(),
00802                    __grouping.c_str() + __grouping.size(),
00803                    __ws + __off, __ws + __len);
00804       __len = __p - __ws2;
00805       
00806       __ws = __ws2;
00807     }
00808       return _M_insert(__s, __io, __fill, __ws, __len);
00809     }
00810 
00811   
00812   
00813   template<typename _CharT, typename _OutIter>
00814     _OutIter
00815     num_put<_CharT, _OutIter>::
00816     _M_insert(_OutIter __s, ios_base& __io, _CharT __fill, const _CharT* __ws, 
00817           int __len) const
00818     {
00819       
00820       streamsize __w = __io.width();
00821       _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) 
00822                                 * __w));
00823       if (__w > static_cast<streamsize>(__len))
00824     {
00825       __pad(__io, __fill, __ws2, __ws, __w, __len, true);
00826       __len = static_cast<int>(__w);
00827       
00828       __ws = __ws2;
00829     }
00830       __io.width(0);
00831 
00832       
00833       
00834       for (int __j = 0; __j < __len; ++__j, ++__s)
00835     *__s = __ws[__j];
00836       return __s;
00837     }
00838 
00839   template<typename _CharT, typename _OutIter>
00840     _OutIter
00841     num_put<_CharT, _OutIter>::
00842     do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
00843     {
00844       ios_base::fmtflags __flags = __io.flags();
00845       if ((__flags & ios_base::boolalpha) == 0)
00846         {
00847           unsigned long __uv = __v;
00848           __s = _M_convert_int(__s, __io, __fill, 'u', char_type(), __uv);
00849         }
00850       else
00851         {
00852       typedef basic_string<_CharT> __string_type;
00853           locale __loc = __io.getloc();
00854       const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc); 
00855       __string_type __name;
00856           if (__v)
00857         __name = __np.truename();
00858           else
00859         __name = __np.falsename();
00860       __s = _M_insert(__s, __io, __fill, __name.c_str(), __name.size()); 
00861     }
00862       return __s;
00863     }
00864 
00865   template<typename _CharT, typename _OutIter>
00866     _OutIter
00867     num_put<_CharT, _OutIter>::
00868     do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
00869     { return _M_convert_int(__s, __io, __fill, 'd', char_type(), __v); }
00870 
00871   template<typename _CharT, typename _OutIter>
00872     _OutIter
00873     num_put<_CharT, _OutIter>::
00874     do_put(iter_type __s, ios_base& __io, char_type __fill,
00875            unsigned long __v) const
00876     { return _M_convert_int(__s, __io, __fill, 'u', char_type(), __v); }
00877 
00878 #ifdef _GLIBCPP_USE_LONG_LONG
00879   template<typename _CharT, typename _OutIter>
00880     _OutIter
00881     num_put<_CharT, _OutIter>::
00882     do_put(iter_type __s, ios_base& __b, char_type __fill, long long __v) const
00883     { return _M_convert_int(__s, __b, __fill, 'd', 'l', __v); }
00884 
00885   template<typename _CharT, typename _OutIter>
00886     _OutIter
00887     num_put<_CharT, _OutIter>::
00888     do_put(iter_type __s, ios_base& __io, char_type __fill,
00889            unsigned long long __v) const
00890     { return _M_convert_int(__s, __io, __fill, 'u', 'l', __v); }
00891 #endif
00892 
00893   template<typename _CharT, typename _OutIter>
00894     _OutIter
00895     num_put<_CharT, _OutIter>::
00896     do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
00897     { return _M_convert_float(__s, __io, __fill, char_type(), __v); }
00898 
00899   template<typename _CharT, typename _OutIter>
00900     _OutIter
00901     num_put<_CharT, _OutIter>::
00902     do_put(iter_type __s, ios_base& __io, char_type __fill, 
00903        long double __v) const
00904     { return _M_convert_float(__s, __io, __fill, 'L', __v); }
00905 
00906   template<typename _CharT, typename _OutIter>
00907     _OutIter
00908     num_put<_CharT, _OutIter>::
00909     do_put(iter_type __s, ios_base& __io, char_type __fill,
00910            const void* __v) const
00911     {
00912       ios_base::fmtflags __flags = __io.flags();
00913       ios_base::fmtflags __fmt = ~(ios_base::showpos | ios_base::basefield
00914                    | ios_base::uppercase | ios_base::internal);
00915       __io.flags(__flags & __fmt | (ios_base::hex | ios_base::showbase));
00916       try 
00917     {
00918       __s = _M_convert_int(__s, __io, __fill, 'u', char_type(),
00919                    reinterpret_cast<unsigned long>(__v));
00920       __io.flags(__flags);
00921     }
00922       catch (...) 
00923     {
00924       __io.flags(__flags);
00925       __throw_exception_again;
00926     }
00927       return __s;
00928     }
00929 
00930 
00931   template<typename _CharT, typename _InIter>
00932     _InIter
00933     money_get<_CharT, _InIter>::
00934     do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io, 
00935        ios_base::iostate& __err, long double& __units) const
00936     { 
00937       string_type __str;
00938       __beg = this->do_get(__beg, __end, __intl, __io, __err, __str); 
00939 
00940       const int __n = numeric_limits<long double>::digits10;
00941       char* __cs = static_cast<char*>(__builtin_alloca(__n));
00942       const locale __loc = __io.getloc();
00943       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc); 
00944       const _CharT* __wcs = __str.c_str();
00945       __ctype.narrow(__wcs, __wcs + __str.size() + 1, char(), __cs);      
00946       __convert_to_v(__cs, __units, __err, _S_c_locale);
00947       return __beg;
00948     }
00949 
00950   template<typename _CharT, typename _InIter>
00951     _InIter
00952     money_get<_CharT, _InIter>::
00953     do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io, 
00954        ios_base::iostate& __err, string_type& __units) const
00955     { 
00956       
00957       typedef moneypunct<_CharT, true>      __money_true;
00958       typedef moneypunct<_CharT, false>     __money_false;
00959       typedef money_base::part          part;
00960       typedef typename string_type::size_type   size_type;
00961 
00962       const locale __loc = __io.getloc();
00963       const __money_true& __mpt = use_facet<__money_true>(__loc); 
00964       const __money_false& __mpf = use_facet<__money_false>(__loc); 
00965       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc); 
00966 
00967       const money_base::pattern __p = __intl ? __mpt.neg_format() 
00968                          : __mpf.neg_format();
00969 
00970       const string_type __pos_sign =__intl ? __mpt.positive_sign() 
00971                        : __mpf.positive_sign();
00972       const string_type __neg_sign =__intl ? __mpt.negative_sign() 
00973                        : __mpf.negative_sign();
00974       const char_type __d = __intl ? __mpt.decimal_point() 
00975                            : __mpf.decimal_point();
00976       const char_type __sep = __intl ? __mpt.thousands_sep() 
00977                          : __mpf.thousands_sep();
00978 
00979       const string __grouping = __intl ? __mpt.grouping() : __mpf.grouping();
00980 
00981       
00982       string_type __sign;
00983       
00984       string __grouping_tmp; 
00985       
00986       int __sep_pos = 0;
00987       
00988       bool __testvalid = true;
00989       
00990       bool __testdecfound = false; 
00991 
00992       
00993       string_type __temp_units;
00994 
00995       char_type __c = *__beg;
00996       char_type __eof = static_cast<char_type>(char_traits<char_type>::eof());
00997       for (int __i = 0; __beg != __end && __i < 4 && __testvalid; ++__i)
00998     {
00999       part __which = static_cast<part>(__p.field[__i]);
01000       switch (__which)
01001         {
01002         case money_base::symbol:
01003           if (__io.flags() & ios_base::showbase 
01004               || __i < 2 || __sign.size() > 1
01005               || ((static_cast<part>(__p.field[3]) != money_base::none)
01006               && __i == 2)) 
01007             {
01008               
01009               
01010               
01011               
01012               
01013               const string_type __symbol = __intl ? __mpt.curr_symbol()
01014                                  : __mpf.curr_symbol();
01015               size_type __len = __symbol.size();
01016               size_type __j = 0;
01017               while (__beg != __end 
01018                  && __j < __len && __symbol[__j] == __c)
01019             {
01020               __c = *(++__beg);
01021               ++__j;
01022             }
01023               
01024               
01025               if (__j != __len && (__io.flags() & ios_base::showbase))
01026             __testvalid = false;
01027             }
01028           break;
01029         case money_base::sign:          
01030           
01031           if (__pos_sign.size() && __neg_sign.size())
01032           {
01033             
01034             if (__c == __pos_sign[0])
01035               {
01036             __sign = __pos_sign;
01037             __c = *(++__beg);
01038               }
01039             else if (__c == __neg_sign[0])
01040               {
01041             __sign = __neg_sign;
01042             __c = *(++__beg);
01043               }
01044             else
01045               __testvalid = false;
01046           }
01047           else if (__pos_sign.size() && __c == __pos_sign[0])
01048             {
01049               __sign = __pos_sign;
01050               __c = *(++__beg);
01051             }
01052           else if (__neg_sign.size() && __c == __neg_sign[0])
01053             {
01054               __sign = __neg_sign;
01055               __c = *(++__beg);
01056             }
01057           break;
01058         case money_base::value:
01059           
01060           
01061           while (__beg != __end 
01062              && (__ctype.is(ctype_base::digit, __c) 
01063                  || (__c == __d && !__testdecfound)
01064                  || __c == __sep))
01065             {
01066               if (__c == __d)
01067             {
01068               __grouping_tmp += static_cast<char>(__sep_pos);
01069               __sep_pos = 0;
01070               __testdecfound = true;
01071             }
01072               else if (__c == __sep)
01073             {
01074               if (__grouping.size())
01075                 {
01076                   
01077                   __grouping_tmp += static_cast<char>(__sep_pos);
01078                   __sep_pos = 0;
01079                 }
01080               else
01081                 {
01082                   __testvalid = false;
01083                   break;
01084                 }
01085             }
01086               else
01087             {
01088               __temp_units += __c;
01089               ++__sep_pos;
01090             }
01091               __c = *(++__beg);
01092             }
01093           break;
01094         case money_base::space:
01095         case money_base::none:
01096           
01097           if (__i != 3)
01098             while (__beg != __end 
01099                && __ctype.is(ctype_base::space, __c))
01100               __c = *(++__beg);
01101           break;
01102         }
01103     }
01104 
01105       
01106       if (__sign.size() > 1)
01107     {
01108       size_type __len = __sign.size();
01109       size_type __i = 1;
01110       for (; __c != __eof && __i < __len; ++__i)
01111         while (__beg != __end && __c != __sign[__i])
01112           __c = *(++__beg);
01113       
01114       if (__i != __len)
01115         __testvalid = false;
01116     }
01117 
01118       
01119       while (__temp_units[0] == __ctype.widen('0'))
01120     __temp_units.erase(__temp_units.begin());
01121 
01122       if (__sign.size() && __sign == __neg_sign)
01123     __temp_units.insert(__temp_units.begin(), __ctype.widen('-'));
01124 
01125       
01126       if (__grouping.size() && __grouping_tmp.size())
01127     {
01128       if (!__verify_grouping(__grouping, __grouping_tmp))
01129         __testvalid = false;
01130     }
01131 
01132       
01133       if (__c == __eof)
01134     __err |= ios_base::eofbit;
01135 
01136       
01137       if (!__testvalid || !__temp_units.size())
01138     __err |= ios_base::failbit;
01139       else
01140     
01141     __temp_units.swap(__units);
01142 
01143       return __beg; 
01144     }
01145 
01146   template<typename _CharT, typename _OutIter>
01147     _OutIter
01148     money_put<_CharT, _OutIter>::
01149     do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
01150        long double __units) const
01151     { 
01152       const locale __loc = __io.getloc();
01153       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
01154 #ifdef _GLIBCPP_USE_C99
01155       
01156       int __cs_size = 64;
01157       char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
01158       int __len = __convert_from_v(__cs, __cs_size, "%.01Lf", __units, 
01159                    _S_c_locale);
01160       
01161       if (__len >= __cs_size)
01162     {
01163       __cs_size = __len + 1;
01164       __cs = static_cast<char*>(__builtin_alloca(__cs_size));
01165       __len = __convert_from_v(__cs, __cs_size, "%.01Lf", __units, 
01166                    _S_c_locale);
01167     }
01168 #else
01169       
01170       
01171       const int __cs_size = numeric_limits<long double>::max_exponent10 + 5;
01172       char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
01173       int __len = __convert_from_v(__cs, 0, "%.01Lf", __units, _S_c_locale);
01174 #endif
01175       _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __cs_size));
01176       __ctype.widen(__cs, __cs + __len, __ws);
01177       string_type __digits(__ws);
01178       return this->do_put(__s, __intl, __io, __fill, __digits); 
01179     }
01180 
01181   template<typename _CharT, typename _OutIter>
01182     _OutIter
01183     money_put<_CharT, _OutIter>::
01184     do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
01185        const string_type& __digits) const
01186     { 
01187       typedef typename string_type::size_type   size_type;
01188       typedef money_base::part          part;
01189 
01190       const locale __loc = __io.getloc();
01191       const size_type __width = static_cast<size_type>(__io.width());
01192 
01193       
01194       typedef moneypunct<_CharT, true> __money_true;
01195       typedef moneypunct<_CharT, false> __money_false;
01196       const __money_true& __mpt = use_facet<__money_true>(__loc); 
01197       const __money_false& __mpf = use_facet<__money_false>(__loc); 
01198       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc); 
01199 
01200       
01201       
01202       const char_type* __beg = __digits.data();
01203       const char_type* __end = __beg + __digits.size();
01204       money_base::pattern __p;
01205       string_type __sign;
01206       if (*__beg != __ctype.widen('-'))
01207     {
01208       __p = __intl ? __mpt.pos_format() : __mpf.pos_format();
01209       __sign =__intl ? __mpt.positive_sign() : __mpf.positive_sign();
01210     }
01211       else
01212     {
01213       __p = __intl ? __mpt.neg_format() : __mpf.neg_format();
01214       __sign =__intl ? __mpt.negative_sign() : __mpf.negative_sign();
01215       ++__beg;
01216     }
01217       
01218       
01219       __end = __ctype.scan_not(ctype_base::digit, __beg, __end);
01220       if (__beg != __end)
01221     {
01222       
01223       
01224       
01225       string_type __res;
01226       string_type __value;
01227       const string_type __symbol = __intl ? __mpt.curr_symbol() 
01228                               : __mpf.curr_symbol();
01229 
01230       
01231       const int __frac = __intl ? __mpt.frac_digits() 
01232                         : __mpf.frac_digits();
01233       if (__frac > 0)
01234         {
01235           const char_type __d = __intl ? __mpt.decimal_point() 
01236                        : __mpf.decimal_point();
01237           if (__end - __beg >= __frac)
01238         {
01239           __value = string_type(__end - __frac, __end);
01240           __value.insert(__value.begin(), __d);
01241           __end -= __frac;
01242         }
01243           else
01244         {
01245           
01246           __value = string_type(__beg, __end);
01247           int __paddec = __frac - (__end - __beg);
01248           char_type __zero = __ctype.widen('0');
01249           __value.insert(__value.begin(), __paddec, __zero);
01250           __value.insert(__value.begin(), __d);
01251           __beg = __end;
01252         }
01253         }
01254 
01255       
01256       
01257       if (__beg != __end)
01258         {
01259           const string __grouping = __intl ? __mpt.grouping() 
01260                            : __mpf.grouping();
01261           if (__grouping.size())
01262         {
01263           const char_type __sep = __intl ? __mpt.thousands_sep() 
01264                                  : __mpf.thousands_sep();
01265           const char* __gbeg = __grouping.c_str();
01266           const char* __gend = __gbeg + __grouping.size();
01267           const int __n = (__end - __beg) * 2;
01268           _CharT* __ws2 =
01269             static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __n));
01270           _CharT* __ws_end = __add_grouping(__ws2, __sep, __gbeg, 
01271                             __gend, __beg, __end);
01272           __value.insert(0, __ws2, __ws_end - __ws2);
01273         }
01274           else
01275         __value.insert(0, string_type(__beg, __end));
01276         }
01277 
01278       
01279       ios_base::fmtflags __f = __io.flags() & ios_base::adjustfield;
01280       size_type __len = __value.size() + __sign.size();
01281       __len += (__io.flags() & ios_base::showbase) ? __symbol.size() : 0;
01282       bool __testipad = __f == ios_base::internal && __len < __width;
01283 
01284       
01285       for (int __i = 0; __i < 4; ++__i)
01286         {
01287           part __which = static_cast<part>(__p.field[__i]);
01288           switch (__which)
01289         {
01290         case money_base::symbol:
01291           if (__io.flags() & ios_base::showbase)
01292             __res += __symbol;
01293           break;
01294         case money_base::sign:          
01295           
01296           
01297           
01298           if (__sign.size())
01299             __res += __sign[0];
01300           break;
01301         case money_base::value:
01302           __res += __value;
01303           break;
01304         case money_base::space:
01305           
01306           
01307           
01308           if (__testipad)
01309             __res += string_type(__width - __len, __fill);
01310           else
01311             __res += __ctype.widen(__fill);
01312           break;
01313         case money_base::none:
01314           if (__testipad)
01315             __res += string_type(__width - __len, __fill);
01316           break;
01317         }
01318         }
01319 
01320       
01321       if (__sign.size() > 1)
01322         __res += string_type(__sign.begin() + 1, __sign.end());
01323 
01324       
01325       __len = __res.size();
01326       if (__width > __len)
01327         {
01328           if (__f == ios_base::left)
01329         
01330         __res.append(__width - __len, __fill);
01331           else
01332         
01333         __res.insert(0, string_type(__width - __len, __fill));
01334           __len = __width;
01335         }
01336 
01337       
01338       for (size_type __j = 0; __j < __len; ++__j, ++__s)
01339         *__s = __res[__j];
01340     }
01341       __io.width(0);
01342       return __s; 
01343     }
01344 
01345 
01346   
01347   
01348   
01349   template<typename _CharT, typename _InIter>
01350     time_base::dateorder
01351     time_get<_CharT, _InIter>::do_date_order() const
01352     { return time_base::no_order; }
01353 
01354   template<typename _CharT, typename _InIter>
01355     void
01356     time_get<_CharT, _InIter>::
01357     _M_extract_via_format(iter_type& __beg, iter_type& __end, ios_base& __io,
01358               ios_base::iostate& __err, tm* __tm, 
01359               const _CharT* __format) const
01360     {  
01361       locale __loc = __io.getloc();
01362       __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
01363       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc); 
01364       size_t __len = char_traits<_CharT>::length(__format);
01365 
01366       for (size_t __i = 0; __beg != __end && __i < __len && !__err; ++__i)
01367     {
01368       char __c = __format[__i];
01369       if (__c == '%')
01370         {
01371           
01372           __c = __format[++__i];
01373           char __mod = 0;
01374           int __mem = 0; 
01375           if (__c == 'E' || __c == 'O')
01376         {
01377           __mod = __c;
01378           __c = __format[++__i];
01379         }
01380           switch (__c)
01381         {
01382           const char* __cs;
01383           _CharT __wcs[10];
01384         case 'a':
01385           
01386           const char_type*  __days1[7];
01387           __tp._M_days_abbreviated(__days1);
01388           _M_extract_name(__beg, __end, __tm->tm_wday, __days1, 7, 
01389                   __err);
01390           break;
01391         case 'A':
01392           
01393           const char_type*  __days2[7];
01394           __tp._M_days(__days2);
01395           _M_extract_name(__beg, __end, __tm->tm_wday, __days2, 7, 
01396                   __err);
01397           break;
01398         case 'h':
01399         case 'b':
01400           
01401           const char_type*  __months1[12];
01402           __tp._M_months_abbreviated(__months1);
01403           _M_extract_name(__beg, __end, __tm->tm_mon, __months1, 12, 
01404                   __err);
01405           break;
01406         case 'B':
01407           
01408           const char_type*  __months2[12];
01409           __tp._M_months(__months2);
01410           _M_extract_name(__beg, __end, __tm->tm_mon, __months2, 12, 
01411                   __err);
01412           break;
01413         case 'c':
01414           
01415           const char_type*  __dt[2];
01416           __tp._M_date_time_formats(__dt);
01417           _M_extract_via_format(__beg, __end, __io, __err, __tm, 
01418                     __dt[0]);
01419           break;
01420         case 'd':
01421           
01422           _M_extract_num(__beg, __end, __tm->tm_mday, 1, 31, 2, 
01423                  __ctype, __err);
01424           break;
01425         case 'D':
01426           
01427           __cs = "%m/%d/%y";
01428           __ctype.widen(__cs, __cs + 9, __wcs);
01429           _M_extract_via_format(__beg, __end, __io, __err, __tm, 
01430                     __wcs);
01431           break;
01432         case 'H':
01433           
01434           _M_extract_num(__beg, __end, __tm->tm_hour, 0, 23, 2,
01435                  __ctype, __err);
01436           break;
01437         case 'I':
01438           
01439           _M_extract_num(__beg, __end, __tm->tm_hour, 1, 12, 2, 
01440                  __ctype, __err);
01441           break;
01442         case 'm':
01443           
01444           _M_extract_num(__beg, __end, __mem, 1, 12, 2, __ctype, 
01445                  __err);
01446           if (!__err)
01447             __tm->tm_mon = __mem - 1;
01448           break;
01449         case 'M':
01450           
01451           _M_extract_num(__beg, __end, __tm->tm_min, 0, 59, 2,
01452                  __ctype, __err);
01453           break;
01454         case 'n':
01455           if (__ctype.narrow(*__beg, 0) == '\n')
01456             ++__beg;
01457           else
01458             __err |= ios_base::failbit;
01459           break;
01460         case 'R':
01461           
01462           __cs = "%H:%M";
01463           __ctype.widen(__cs, __cs + 6, __wcs);
01464           _M_extract_via_format(__beg, __end, __io, __err, __tm, 
01465                     __wcs);
01466           break;
01467         case 'S':
01468           
01469           _M_extract_num(__beg, __end, __tm->tm_sec, 0, 59, 2,
01470                  __ctype, __err);
01471           break;
01472         case 't':
01473           if (__ctype.narrow(*__beg, 0) == '\t')
01474             ++__beg;
01475           else
01476         __err |= ios_base::failbit;
01477           break;
01478         case 'T':
01479           
01480           __cs = "%H:%M:%S";
01481           __ctype.widen(__cs, __cs + 9, __wcs);
01482           _M_extract_via_format(__beg, __end, __io, __err, __tm, 
01483                     __wcs);
01484           break;
01485         case 'x':
01486           
01487           const char_type*  __dates[2];
01488           __tp._M_date_formats(__dates);
01489           _M_extract_via_format(__beg, __end, __io, __err, __tm, 
01490                     __dates[0]);
01491           break;
01492         case 'X':
01493           
01494           const char_type*  __times[2];
01495           __tp._M_time_formats(__times);
01496           _M_extract_via_format(__beg, __end, __io, __err, __tm, 
01497                     __times[0]);
01498           break;
01499         case 'y':
01500           
01501           _M_extract_num(__beg, __end, __tm->tm_year, 0, 99, 2, 
01502                  __ctype, __err);
01503           break;
01504         case 'Y':
01505           
01506           _M_extract_num(__beg, __end, __mem, 0, 
01507                  numeric_limits<int>::max(), 4, 
01508                  __ctype, __err);
01509           if (!__err)
01510             __tm->tm_year = __mem - 1900;
01511           break;
01512         case 'Z':
01513           
01514           if (__ctype.is(ctype_base::upper, *__beg))
01515             {
01516               int __tmp;
01517               _M_extract_name(__beg, __end, __tmp, 
01518                       __timepunct<_CharT>::_S_timezones, 
01519                       14, __err);
01520               
01521               
01522               char_type __c = *__beg;
01523               if (!__err && __tmp == 0 
01524               && (__c == __ctype.widen('-') 
01525                   || __c == __ctype.widen('+')))
01526             {
01527               _M_extract_num(__beg, __end, __tmp, 0, 23, 2,
01528                       __ctype, __err);
01529               _M_extract_num(__beg, __end, __tmp, 0, 59, 2,
01530                       __ctype, __err);
01531             }       
01532               }
01533               else
01534             __err |= ios_base::failbit;
01535               break;
01536             default:
01537               
01538               __err |= ios_base::failbit;
01539             }
01540         }
01541           else
01542         {
01543           
01544           if (__c == __ctype.narrow(*__beg, 0))
01545             ++__beg;
01546           else
01547             __err |= ios_base::failbit;
01548         }
01549     }
01550     }
01551 
01552   template<typename _CharT, typename _InIter>
01553     void
01554     time_get<_CharT, _InIter>::
01555     _M_extract_num(iter_type& __beg, iter_type& __end, int& __member,
01556            int __min, int __max, size_t __len, 
01557            const ctype<_CharT>& __ctype, 
01558            ios_base::iostate& __err) const
01559     {
01560       size_t __i = 0;
01561       string __digits;
01562       bool __testvalid = true;
01563       char_type __c = *__beg;
01564       while (__beg != __end && __i < __len 
01565          && __ctype.is(ctype_base::digit, __c)) 
01566     {
01567       __digits += __ctype.narrow(__c, 0);
01568       __c = *(++__beg);
01569       ++__i;
01570     }
01571       if (__i == __len)
01572     {
01573       int __value = atoi(__digits.c_str());
01574       if (__min <= __value && __value <= __max)
01575         __member = __value;
01576       else
01577         __testvalid = false;
01578     }
01579       else
01580     __testvalid = false;
01581       if (!__testvalid)
01582     __err |= ios_base::failbit;
01583     }
01584 
01585   
01586   
01587   template<typename _CharT, typename _InIter>
01588     void
01589     time_get<_CharT, _InIter>::
01590     _M_extract_name(iter_type& __beg, iter_type& __end, int& __member,
01591             const _CharT** __names, size_t __indexlen, 
01592             ios_base::iostate& __err) const
01593     {
01594       typedef char_traits<char_type> __traits_type;
01595       int* __matches = static_cast<int*>(__builtin_alloca(sizeof(int) * __indexlen));
01596       size_t __nmatches = 0;
01597       size_t __pos = 0;
01598       bool __testvalid = true;
01599       const char_type* __name;
01600 
01601       char_type __c = *__beg;
01602       
01603       for (size_t __i1 = 0; __i1 < __indexlen; ++__i1)
01604     if (__c == __names[__i1][0])
01605       __matches[__nmatches++] = __i1;
01606       
01607       while(__nmatches > 1)
01608     {
01609       
01610       size_t __minlen = 10;
01611       for (size_t __i2 = 0; __i2 < __nmatches; ++__i2)
01612         __minlen = min(__minlen, 
01613                __traits_type::length(__names[__matches[__i2]]));
01614       
01615       if (__pos < __minlen && __beg != __end)
01616         {
01617           ++__pos;
01618           __c = *(++__beg);
01619           for (size_t __i3 = 0; __i3 < __nmatches; ++__i3)
01620         {
01621           __name = __names[__matches[__i3]];
01622           if (__name[__pos] != __c)
01623             __matches[__i3] = __matches[--__nmatches];
01624         }
01625         }
01626       else
01627         break;
01628     }
01629 
01630       if (__nmatches == 1)
01631     {
01632       
01633       __name = __names[__matches[0]];
01634       const size_t __len = __traits_type::length(__name);
01635       while (__pos < __len && __beg != __end && __name[__pos] == *__beg)
01636         ++__beg, ++__pos;
01637 
01638       if (__len == __pos)
01639         __member = __matches[0];
01640       else
01641         __testvalid = false;
01642     }
01643       else
01644     __testvalid = false;
01645       if (!__testvalid)
01646     __err |= ios_base::failbit;
01647     }
01648 
01649   template<typename _CharT, typename _InIter>
01650     _InIter
01651     time_get<_CharT, _InIter>::
01652     do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
01653         ios_base::iostate& __err, tm* __tm) const
01654     {
01655       _CharT __wcs[3];
01656       const char* __cs = "%X";
01657       locale __loc = __io.getloc();
01658       ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
01659       __ctype.widen(__cs, __cs + 3, __wcs);
01660       _M_extract_via_format(__beg, __end, __io, __err, __tm, __wcs);
01661       if (__beg == __end)
01662     __err |= ios_base::eofbit;
01663       return __beg;
01664     }
01665 
01666   template<typename _CharT, typename _InIter>
01667     _InIter
01668     time_get<_CharT, _InIter>::
01669     do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
01670         ios_base::iostate& __err, tm* __tm) const
01671     {
01672       _CharT __wcs[3];
01673       const char* __cs = "%x";
01674       locale __loc = __io.getloc();
01675       ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
01676       __ctype.widen(__cs, __cs + 3, __wcs);
01677       _M_extract_via_format(__beg, __end, __io, __err, __tm, __wcs);
01678       if (__beg == __end)
01679     __err |= ios_base::eofbit;
01680       return __beg;
01681     }
01682 
01683   template<typename _CharT, typename _InIter>
01684     _InIter
01685     time_get<_CharT, _InIter>::
01686     do_get_weekday(iter_type __beg, iter_type __end, ios_base& __io, 
01687            ios_base::iostate& __err, tm* __tm) const
01688     {
01689       typedef char_traits<char_type> __traits_type;
01690       locale __loc = __io.getloc();
01691       __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
01692       const char_type*  __days[7];
01693       __tp._M_days_abbreviated(__days);
01694       int __tmpwday;
01695       _M_extract_name(__beg, __end, __tmpwday, __days, 7, __err);
01696 
01697       
01698       
01699       
01700       
01701       
01702       
01703       if (!__err)
01704     {
01705       size_t __pos = __traits_type::length(__days[__tmpwday]);
01706       __tp._M_days(__days);
01707       const char_type* __name = __days[__tmpwday];
01708       if (__name[__pos] == *__beg)
01709         {
01710           
01711           const size_t __len = __traits_type::length(__name);
01712           while (__pos < __len && __beg != __end 
01713              && __name[__pos] == *__beg)
01714         ++__beg, ++__pos;
01715           if (__len != __pos)
01716         __err |= ios_base::failbit;
01717         }
01718       if (!__err)
01719         __tm->tm_wday = __tmpwday;
01720     }
01721       if (__beg == __end)
01722     __err |= ios_base::eofbit;
01723       return __beg;
01724      }
01725 
01726   template<typename _CharT, typename _InIter>
01727     _InIter
01728     time_get<_CharT, _InIter>::
01729     do_get_monthname(iter_type __beg, iter_type __end,
01730                      ios_base& __io, ios_base::iostate& __err, tm* __tm) const
01731     {
01732       typedef char_traits<char_type> __traits_type;
01733       locale __loc = __io.getloc();
01734       __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
01735       const char_type*  __months[12];
01736       __tp._M_months_abbreviated(__months);
01737       int __tmpmon;
01738       _M_extract_name(__beg, __end, __tmpmon, __months, 12, __err);
01739 
01740       
01741       
01742       
01743       
01744       
01745       
01746       if (!__err)
01747     {
01748       size_t __pos = __traits_type::length(__months[__tmpmon]);
01749       __tp._M_months(__months);
01750       const char_type* __name = __months[__tmpmon];
01751       if (__name[__pos] == *__beg)
01752         {
01753           
01754           const size_t __len = __traits_type::length(__name);
01755           while (__pos < __len && __beg != __end 
01756              && __name[__pos] == *__beg)
01757         ++__beg, ++__pos;
01758           if (__len != __pos)
01759         __err |= ios_base::failbit;
01760         }
01761       if (!__err)
01762         __tm->tm_mon = __tmpmon;
01763     }
01764  
01765       if (__beg == __end)
01766     __err |= ios_base::eofbit;
01767       return __beg;
01768     }
01769 
01770   template<typename _CharT, typename _InIter>
01771     _InIter
01772     time_get<_CharT, _InIter>::
01773     do_get_year(iter_type __beg, iter_type __end, ios_base& __io, 
01774         ios_base::iostate& __err, tm* __tm) const
01775     {
01776       locale __loc = __io.getloc();
01777       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc); 
01778 
01779       char_type __c = *__beg;
01780       size_t __i = 0;
01781       string __digits;
01782       while (__i < 4 && __beg != __end && __ctype.is(ctype_base::digit, __c))
01783     {
01784       __digits += __ctype.narrow(__c, 0);
01785       __c = *(++__beg);
01786       ++__i;
01787     }
01788       if (__i == 2 || __i == 4)
01789     {
01790       long __l;
01791       __convert_to_v(__digits.c_str(), __l, __err, _S_c_locale);
01792       if (!(__err & ios_base::failbit) && __l <= INT_MAX)
01793         {
01794           __l = __i == 2 ? __l : __l - 1900; 
01795           __tm->tm_year = static_cast<int>(__l);
01796         }
01797     }
01798       else
01799     __err |= ios_base::failbit;
01800       if (__beg == __end)
01801     __err |= ios_base::eofbit;
01802       return __beg;
01803     }
01804 
01805   template<typename _CharT, typename _OutIter>
01806     _OutIter
01807     time_put<_CharT, _OutIter>::
01808     put(iter_type __s, ios_base& __io, char_type, const tm* __tm, 
01809     const _CharT* __beg, const _CharT* __end) const
01810     {
01811       locale __loc = __io.getloc();
01812       ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
01813       while (__beg != __end)
01814     {
01815       char __c = __ctype.narrow(*__beg, 0);
01816       ++__beg;
01817       if (__c == '%')
01818         {
01819           char __format;
01820           char __mod = 0;
01821           size_t __len = 1; 
01822           __c = __ctype.narrow(*__beg, 0);
01823           ++__beg;
01824           if (__c == 'E' || __c == 'O')
01825         {
01826           __mod = __c;
01827           __format = __ctype.narrow(*__beg, 0);
01828           ++__beg;
01829         }
01830           else
01831         __format = __c;
01832           __s = this->do_put(__s, __io, char_type(), __tm, __format, 
01833                  __mod);
01834         }
01835       else
01836         {
01837           *__s = __c;
01838           ++__s;
01839         }
01840     }
01841       return __s;
01842     }
01843 
01844   template<typename _CharT, typename _OutIter>
01845     _OutIter
01846     time_put<_CharT, _OutIter>::
01847     do_put(iter_type __s, ios_base& __io, char_type, const tm* __tm, 
01848        char __format, char __mod) const
01849     { 
01850       locale __loc = __io.getloc();
01851       ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
01852       __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
01853 
01854       
01855       
01856       const size_t __maxlen = 64;
01857       char_type* __res =
01858     static_cast<char_type*>(__builtin_alloca(sizeof(char_type) * __maxlen));
01859 
01860       
01861       
01862       
01863       
01864       
01865       char_type __fmt[4];
01866       __fmt[0] = __ctype.widen('%'); 
01867       if (!__mod)
01868     {
01869       __fmt[1] = __format;
01870       __fmt[2] = char_type();
01871     }
01872       else
01873     {
01874       __fmt[1] = __mod;
01875       __fmt[2] = __format;
01876       __fmt[3] = char_type();
01877     }
01878 
01879       __tp._M_put(__res, __maxlen, __fmt, __tm);
01880 
01881       
01882       size_t __len = char_traits<char_type>::length(__res);
01883       for (size_t __i = 0; __i < __len; ++__i, ++__s)
01884     *__s = __res[__i];
01885       return __s;
01886     }
01887 
01888 
01889   
01890   template<typename _CharT>
01891     int
01892     collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const
01893     { return 0; }
01894 
01895   
01896   template<typename _CharT>
01897     size_t
01898     collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const
01899     { return 0; }
01900 
01901   template<typename _CharT>
01902     int
01903     collate<_CharT>::
01904     do_compare(const _CharT* __lo1, const _CharT* __hi1, 
01905            const _CharT* __lo2, const _CharT* __hi2) const
01906     { 
01907       const string_type __one(__lo1, __hi1);
01908       const string_type __two(__lo2, __hi2);
01909       return _M_compare(__one.c_str(), __two.c_str());
01910     }
01911 
01912  template<typename _CharT>
01913     typename collate<_CharT>::string_type
01914     collate<_CharT>::
01915     do_transform(const _CharT* __lo, const _CharT* __hi) const
01916     {
01917       size_t __len = (__hi - __lo) * 2;
01918       
01919       _CharT* __c =
01920     static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __len));
01921       size_t __res = _M_transform(__c, __lo, __len);
01922       
01923       if (__res >= __len)
01924     {
01925       __c =
01926         static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * (__res + 1)));
01927       _M_transform(__c, __lo, __res + 1);
01928     }
01929       return string_type(__c);
01930     }
01931 
01932  template<typename _CharT>
01933     long
01934     collate<_CharT>::
01935     do_hash(const _CharT* __lo, const _CharT* __hi) const
01936     { 
01937       unsigned long __val = 0;
01938       for (; __lo < __hi; ++__lo)
01939     __val = *__lo + ((__val << 7) | 
01940                (__val >> (numeric_limits<unsigned long>::digits - 7)));
01941       return static_cast<long>(__val);
01942     }
01943 
01944   
01945   
01946   
01947   template<typename _Tv>
01948     void
01949     __convert_to_v(const char* __in, _Tv& __out, ios_base::iostate& __err, 
01950            const __c_locale& __cloc, int __base = 10);
01951 
01952   
01953   
01954   
01955 #ifdef _GLIBCPP_USE_C99
01956   template<typename _Tv>
01957     int
01958     __convert_from_v(char* __out, const int __size, const char* __fmt,
01959              _Tv __v, const __c_locale&, int __prec = -1)
01960     {
01961       int __ret;
01962       const char* __old = setlocale(LC_ALL, "C");
01963       if (__prec >= 0)
01964         __ret = snprintf(__out, __size, __fmt, __prec, __v);
01965       else
01966         __ret = snprintf(__out, __size, __fmt, __v);
01967       setlocale(LC_ALL, __old);
01968       return __ret;
01969     }
01970 #else
01971   template<typename _Tv>
01972     int
01973     __convert_from_v(char* __out, const int, const char* __fmt, _Tv __v,
01974              const __c_locale&, int __prec = -1)
01975     {
01976       int __ret;
01977       const char* __old = setlocale(LC_ALL, "C");
01978       if (__prec >= 0)
01979         __ret = sprintf(__out, __fmt, __prec, __v);
01980       else
01981         __ret = sprintf(__out, __fmt, __v);
01982       setlocale(LC_ALL, __old);
01983       return __ret;
01984     }
01985 #endif
01986 
01987   
01988   
01989   
01990   
01991   
01992   
01993   
01994   
01995   template<typename _CharT, typename _Traits>
01996     void
01997     __pad(ios_base& __io, _CharT __fill, _CharT* __news, const _CharT* __olds,
01998       const streamsize __newlen, const streamsize __oldlen, 
01999       const bool __num)
02000     {
02001       typedef _CharT    char_type;
02002       typedef _Traits   traits_type;
02003       typedef typename traits_type::int_type int_type;
02004       
02005       int_type __plen = static_cast<size_t>(__newlen - __oldlen); 
02006       char_type* __pads = static_cast<char_type*>(__builtin_alloca(sizeof(char_type) * __plen));
02007       traits_type::assign(__pads, __plen, __fill); 
02008 
02009       char_type* __beg;
02010       char_type* __end;
02011       size_t __mod = 0;
02012       size_t __beglen; 
02013       ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;
02014 
02015       if (__adjust == ios_base::left)
02016     {
02017       
02018       __beg = const_cast<char_type*>(__olds);
02019       __beglen = __oldlen;
02020       __end = __pads;
02021     }
02022       else if (__adjust == ios_base::internal && __num)
02023     {
02024       
02025       
02026       
02027           locale __loc = __io.getloc();
02028       const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc); 
02029       const char_type __minus = __ctype.widen('-');
02030       const char_type __plus = __ctype.widen('+');
02031       bool __testsign = __olds[0] == __minus || __olds[0] == __plus;
02032       bool __testhex = __ctype.widen('0') == __olds[0] 
02033                        && (__ctype.widen('x') == __olds[1] 
02034                    || __ctype.widen('X') == __olds[1]);
02035       if (__testhex)
02036         {
02037           __news[0] = __olds[0]; 
02038           __news[1] = __olds[1];
02039           __mod += 2;
02040           __news += 2;
02041           __beg = __pads;
02042           __beglen = __plen;
02043           __end = const_cast<char_type*>(__olds + __mod);
02044         }
02045       else if (__testsign)
02046         {
02047           __news[0] = __olds[0] == __plus ? __plus : __minus;
02048           ++__mod;
02049           ++__news;
02050           __beg = __pads;
02051           __beglen = __plen;
02052           __end = const_cast<char_type*>(__olds + __mod);
02053         }
02054       else
02055         {
02056           
02057           __beg = __pads;
02058           __beglen = __plen;
02059           __end = const_cast<char_type*>(__olds);
02060         }
02061     }
02062       else
02063     {
02064       
02065       __beg = __pads;
02066       __beglen = __plen;
02067       __end = const_cast<char_type*>(__olds);
02068     }
02069       traits_type::copy(__news, __beg, __beglen);
02070       traits_type::copy(__news + __beglen, __end, __newlen - __beglen - __mod);
02071     }
02072 
02073   
02074   
02075   
02076   template<typename _CharT>
02077     void
02078     __pad(ios_base& __io, _CharT __fill, _CharT* __news, const _CharT* __olds,
02079       const streamsize __newlen, const streamsize __oldlen, 
02080       const bool __num)
02081     { 
02082       return __pad<_CharT, char_traits<_CharT> >(__io, __fill, __news, __olds,
02083                          __newlen, __oldlen, __num); 
02084     }
02085 
02086   
02087   
02088   
02089   
02090   
02091   
02092   
02093   
02094   template<typename _CharT>
02095     bool
02096     __verify_grouping(const basic_string<_CharT>& __grouping, 
02097               basic_string<_CharT>& __grouping_tmp)
02098     {         
02099       int __i = 0;
02100       int __j = 0;
02101       const int __len = __grouping.size();
02102       const int __n = __grouping_tmp.size();
02103       bool __test = true;
02104       
02105       
02106       
02107       
02108       while (__test && __i < __n - 1)
02109     for (__j = 0; __test && __j < __len && __i < __n - 1; ++__j,++__i)
02110       __test &= __grouping[__j] == __grouping_tmp[__n - __i - 1];
02111       
02112       
02113       __j == __len ? __j = 0 : __j;
02114       __test &= __grouping[__j] >= __grouping_tmp[__n - __i - 1];
02115       return __test;
02116     }
02117 
02118   
02119   
02120   
02121   
02122   
02123   template<typename _CharT>
02124     _CharT*
02125     __add_grouping(_CharT* __s, _CharT __sep,  
02126            const char* __gbeg, const char* __gend, 
02127            const _CharT* __first, const _CharT* __last)
02128     {
02129       if (__last - __first > *__gbeg)
02130         {
02131           __s = __add_grouping(__s,  __sep, 
02132                    (__gbeg + 1 == __gend ? __gbeg : __gbeg + 1),
02133                    __gend, __first, __last - *__gbeg);
02134           __first = __last - *__gbeg;
02135           *__s++ = __sep;
02136         }
02137       do
02138     *__s++ = *__first++;
02139       while (__first != __last);
02140       return __s;
02141     }
02142 
02143   
02144   
02145   
02146   extern template class moneypunct<char, false>;
02147   extern template class moneypunct<char, true>;
02148   extern template class moneypunct_byname<char, false>;
02149   extern template class moneypunct_byname<char, true>;
02150   extern template class money_get<char>;
02151   extern template class money_put<char>;
02152   extern template class moneypunct<wchar_t, false>;
02153   extern template class moneypunct<wchar_t, true>;
02154   extern template class moneypunct_byname<wchar_t, false>;
02155   extern template class moneypunct_byname<wchar_t, true>;
02156   extern template class money_get<wchar_t>;
02157   extern template class money_put<wchar_t>;
02158   extern template class numpunct<char>;
02159   extern template class numpunct_byname<char>;
02160   extern template class num_get<char>;
02161   extern template class num_put<char>; 
02162   extern template class numpunct<wchar_t>;
02163   extern template class numpunct_byname<wchar_t>;
02164   extern template class num_get<wchar_t>;
02165   extern template class num_put<wchar_t>;
02166   extern template class __timepunct<char>;
02167   extern template class time_put<char>;
02168   extern template class time_put_byname<char>;
02169   extern template class time_get<char>;
02170   extern template class time_get_byname<char>;
02171   extern template class __timepunct<wchar_t>;
02172   extern template class time_put<wchar_t>;
02173   extern template class time_put_byname<wchar_t>;
02174   extern template class time_get<wchar_t>;
02175   extern template class time_get_byname<wchar_t>;
02176   extern template class messages<char>;
02177   extern template class messages_byname<char>;
02178   extern template class messages<wchar_t>;
02179   extern template class messages_byname<wchar_t>;
02180   extern template class ctype_byname<char>;
02181   extern template class ctype_byname<wchar_t>;
02182   extern template class codecvt_byname<char, char, mbstate_t>;
02183   extern template class codecvt_byname<wchar_t, char, mbstate_t>;
02184   extern template class collate<char>;
02185   extern template class collate_byname<char>;
02186   extern template class collate<wchar_t>;
02187   extern template class collate_byname<wchar_t>;
02188 
02189   extern template
02190     const codecvt<char, char, mbstate_t>& 
02191     use_facet<codecvt<char, char, mbstate_t> >(const locale&);
02192 
02193   extern template
02194     const collate<char>& 
02195     use_facet<collate<char> >(const locale&);
02196 
02197   extern template
02198     const numpunct<char>& 
02199     use_facet<numpunct<char> >(const locale&);
02200 
02201   extern template 
02202     const num_put<char>& 
02203     use_facet<num_put<char> >(const locale&);
02204 
02205   extern template 
02206     const num_get<char>& 
02207     use_facet<num_get<char> >(const locale&);
02208 
02209   extern template
02210     const moneypunct<char, true>& 
02211     use_facet<moneypunct<char, true> >(const locale&);
02212 
02213   extern template
02214     const moneypunct<char, false>& 
02215     use_facet<moneypunct<char, false> >(const locale&);
02216 
02217   extern template 
02218     const money_put<char>& 
02219     use_facet<money_put<char> >(const locale&);
02220 
02221   extern template 
02222     const money_get<char>& 
02223     use_facet<money_get<char> >(const locale&);
02224 
02225   extern template
02226     const __timepunct<char>& 
02227     use_facet<__timepunct<char> >(const locale&);
02228 
02229   extern template 
02230     const time_put<char>& 
02231     use_facet<time_put<char> >(const locale&);
02232 
02233   extern template 
02234     const time_get<char>& 
02235     use_facet<time_get<char> >(const locale&);
02236 
02237   extern template 
02238     const messages<char>& 
02239     use_facet<messages<char> >(const locale&);
02240 
02241   extern template
02242     const codecvt<wchar_t, char, mbstate_t>& 
02243     use_facet<codecvt<wchar_t, char, mbstate_t> >(locale const&);
02244 
02245   extern template
02246     const collate<wchar_t>& 
02247     use_facet<collate<wchar_t> >(const locale&);
02248 
02249   extern template
02250     const numpunct<wchar_t>& 
02251     use_facet<numpunct<wchar_t> >(const locale&);
02252 
02253   extern template 
02254     const num_put<wchar_t>& 
02255     use_facet<num_put<wchar_t> >(const locale&);
02256 
02257   extern template 
02258     const num_get<wchar_t>& 
02259     use_facet<num_get<wchar_t> >(const locale&);
02260 
02261   extern template
02262     const moneypunct<wchar_t, true>& 
02263     use_facet<moneypunct<wchar_t, true> >(const locale&);
02264 
02265   extern template
02266     const moneypunct<wchar_t, false>& 
02267     use_facet<moneypunct<wchar_t, false> >(const locale&);
02268  
02269   extern template 
02270     const money_put<wchar_t>& 
02271     use_facet<money_put<wchar_t> >(const locale&);
02272 
02273   extern template 
02274     const money_get<wchar_t>& 
02275     use_facet<money_get<wchar_t> >(const locale&);
02276 
02277   extern template
02278     const __timepunct<wchar_t>& 
02279     use_facet<__timepunct<wchar_t> >(const locale&);
02280 
02281   extern template 
02282     const time_put<wchar_t>& 
02283     use_facet<time_put<wchar_t> >(const locale&);
02284 
02285   extern template 
02286     const time_get<wchar_t>& 
02287     use_facet<time_get<wchar_t> >(const locale&);
02288 
02289   extern template 
02290     const messages<wchar_t>& 
02291     use_facet<messages<wchar_t> >(const locale&);
02292 
02293 
02294   extern template 
02295     bool
02296     has_facet<ctype<char> >(const locale&);
02297 
02298   extern template 
02299     bool
02300     has_facet<codecvt<char, char, mbstate_t> >(const locale&);
02301 
02302   extern template 
02303     bool
02304     has_facet<collate<char> >(const locale&);
02305 
02306   extern template 
02307     bool
02308     has_facet<numpunct<char> >(const locale&);
02309 
02310   extern template 
02311     bool
02312     has_facet<num_put<char> >(const locale&);
02313 
02314   extern template 
02315     bool
02316     has_facet<num_get<char> >(const locale&);
02317 
02318   extern template 
02319     bool
02320     has_facet<moneypunct<char> >(const locale&);
02321 
02322   extern template 
02323     bool
02324     has_facet<money_put<char> >(const locale&);
02325 
02326   extern template 
02327     bool
02328     has_facet<money_get<char> >(const locale&);
02329 
02330   extern template 
02331     bool
02332     has_facet<__timepunct<char> >(const locale&);
02333 
02334   extern template 
02335     bool
02336     has_facet<time_put<char> >(const locale&);
02337 
02338   extern template 
02339     bool
02340     has_facet<time_get<char> >(const locale&);
02341 
02342   extern template 
02343     bool
02344     has_facet<messages<char> >(const locale&);
02345 
02346  extern template 
02347     bool
02348     has_facet<ctype<wchar_t> >(const locale&);
02349 
02350   extern template 
02351     bool
02352     has_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);
02353 
02354   extern template 
02355     bool
02356     has_facet<collate<wchar_t> >(const locale&);
02357 
02358   extern template 
02359     bool
02360     has_facet<numpunct<wchar_t> >(const locale&);
02361 
02362   extern template 
02363     bool
02364     has_facet<num_put<wchar_t> >(const locale&);
02365 
02366   extern template 
02367     bool
02368     has_facet<num_get<wchar_t> >(const locale&);
02369 
02370   extern template 
02371     bool
02372     has_facet<moneypunct<wchar_t> >(const locale&);
02373 
02374   extern template 
02375     bool
02376     has_facet<money_put<wchar_t> >(const locale&);
02377 
02378   extern template 
02379     bool
02380     has_facet<money_get<wchar_t> >(const locale&);
02381 
02382   extern template 
02383     bool
02384     has_facet<__timepunct<wchar_t> >(const locale&);
02385 
02386   extern template 
02387     bool
02388     has_facet<time_put<wchar_t> >(const locale&);
02389 
02390   extern template 
02391     bool
02392     has_facet<time_get<wchar_t> >(const locale&);
02393 
02394   extern template 
02395     bool
02396     has_facet<messages<wchar_t> >(const locale&);
02397 } 
02398 
02399 #endif
02400 
02401