libstdc++-v3/include/bits/localefwd.h

   1 // Locale support -*- C++ -*-
   2
   3 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002
   4 // Free Software Foundation, Inc.
   5 //
   6 // This file is part of the GNU ISO C++ Library.  This library is free
   7 // software; you can redistribute it and/or modify it under the
   8 // terms of the GNU General Public License as published by the
   9 // Free Software Foundation; either version 2, or (at your option)
  10 // any later version.
  11
  12 // This library is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU General Public License for more details.
  16
  17 // You should have received a copy of the GNU General Public License along
  18 // with this library; see the file COPYING.  If not, write to the Free
  19 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  20 // USA.
  21
  22 // As a special exception, you may use this file as part of a free software
  23 // library without restriction.  Specifically, if other files instantiate
  24 // templates or use macros or inline functions from this file, or you compile
  25 // this file and link it with other files to produce an executable, this
  26 // file does not by itself cause the resulting executable to be covered by
  27 // the GNU General Public License.  This exception does not however
  28 // invalidate any other reasons why the executable file might be covered by
  29 // the GNU General Public License.
  30
  31 //
  32 // ISO C++ 14882: 22.1  Locales
  33 //
  34
  35 /** @file localefwd.h
  36  *  This is an internal header file, included by other library headers.
  37  *  You should not attempt to use it directly.
  38  */
  39
  40 #ifndef _CPP_BITS_LOCCORE_H
  41 #define _CPP_BITS_LOCCORE_H     1
  42
  43 #pragma GCC system_header
  44
  45 #include <bits/c++config.h>
  46 #include <bits/c++locale.h>     // Defines __c_locale, config-specific includes
  47 #include <climits>              // For CHAR_BIT
  48 #include <cctype>               // For isspace, etc.
  49 #include <string>               // For string
  50 #include <bits/functexcept.h>
  51
  52 #include <bits/atomicity.h>
  53
  54 namespace std
  55 {
  56   // NB: Don't instantiate required wchar_t facets if no wchar_t support.
  57 #ifdef _GLIBCPP_USE_WCHAR_T
  58 # define  _GLIBCPP_NUM_FACETS 28
  59 #else
  60 # define  _GLIBCPP_NUM_FACETS 14
  61 #endif
  62
  63   // 22.1.1 Locale
  64   template<typename _Tp, typename _Alloc>
  65     class vector;
  66   class locale;
  67
  68   // 22.1.3 Convenience interfaces
  69   template<typename _CharT>
  70     inline bool
  71     isspace(_CharT, const locale&);
  72
  73   template<typename _CharT>
  74     inline bool
  75     isprint(_CharT, const locale&);
  76
  77   template<typename _CharT>
  78     inline bool
  79     iscntrl(_CharT, const locale&);
  80
  81   template<typename _CharT>
  82     inline bool
  83     isupper(_CharT, const locale&);
  84
  85   template<typename _CharT>
  86     inline bool
  87     islower(_CharT, const locale&);
  88
  89   template<typename _CharT>
  90     inline bool
  91     isalpha(_CharT, const locale&);
  92
  93   template<typename _CharT>
  94     inline bool
  95     isdigit(_CharT, const locale&);
  96
  97   template<typename _CharT>
  98     inline bool
  99     ispunct(_CharT, const locale&);
 100
 101   template<typename _CharT>
 102     inline bool
 103     isxdigit(_CharT, const locale&);
 104
 105   template<typename _CharT>
 106     inline bool
 107     isalnum(_CharT, const locale&);
 108
 109   template<typename _CharT>
 110     inline bool
 111     isgraph(_CharT, const locale&);
 112
 113   template<typename _CharT>
 114     inline _CharT
 115     toupper(_CharT, const locale&);
 116
 117   template<typename _CharT>
 118     inline _CharT
 119     tolower(_CharT, const locale&);
 120
 121
 122   // 22.2.1 and 22.2.1.3 ctype
 123   class ctype_base;
 124   template<typename _CharT>
 125     class ctype;
 126   template<> class ctype<char>;
 127 #ifdef _GLIBCPP_USE_WCHAR_T
 128   template<> class ctype<wchar_t>;
 129 #endif
 130   template<typename _CharT>
 131     class ctype_byname;
 132   // NB: Specialized for char and wchar_t in locale_facets.h.
 133
 134   class codecvt_base;
 135   class __enc_traits;
 136   template<typename _InternT, typename _ExternT, typename _StateT>
 137     class codecvt;
 138   template<> class codecvt<char, char, mbstate_t>;
 139 #ifdef _GLIBCPP_USE_WCHAR_T
 140   template<> class codecvt<wchar_t, char, mbstate_t>;
 141 #endif
 142   template<typename _InternT, typename _ExternT, typename _StateT>
 143     class codecvt_byname;
 144
 145   // 22.2.2 and 22.2.3 numeric
 146   template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
 147     class num_get;
 148   template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
 149     class num_put;
 150   template<typename _CharT> class numpunct;
 151   template<typename _CharT> class numpunct_byname;
 152
 153   // 22.2.4 collation
 154   template<typename _CharT>
 155     class collate;
 156   template<typename _CharT> class
 157     collate_byname;
 158
 159   // 22.2.5 date and time
 160   class time_base;
 161   template<typename _CharT, typename _InIter =  istreambuf_iterator<_CharT> >
 162     class time_get;
 163   template<typename _CharT, typename _InIter =  istreambuf_iterator<_CharT> >
 164     class time_get_byname;
 165   template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
 166     class time_put;
 167   template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
 168     class time_put_byname;
 169
 170   // 22.2.6 money
 171   class money_base;
 172   template<typename _CharT, typename _InIter =  istreambuf_iterator<_CharT> >
 173     class money_get;
 174   template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
 175     class money_put;
 176   template<typename _CharT, bool _Intl = false>
 177     class moneypunct;
 178   template<typename _CharT, bool _Intl = false>
 179     class moneypunct_byname;
 180
 181   // 22.2.7 message retrieval
 182   class messages_base;
 183   template<typename _CharT>
 184     class messages;
 185   template<typename _CharT>
 186     class messages_byname;
 187
 188   // 22.1.1 Class locale
 189   class locale
 190   {
 191   public:
 192     // Types:
 193     typedef unsigned int        category;
 194
 195     // Forward decls and friends:
 196     class facet;
 197     class id;
 198     class _Impl;
 199
 200     friend class facet;
 201     friend class _Impl;
 202
 203     template<typename _Facet>
 204       friend const _Facet&
 205       use_facet(const locale&);
 206
 207     template<typename _Facet>
 208       friend bool
 209       has_facet(const locale&) throw();
 210
 211     // Category values:
 212     // NB: Order must match _S_facet_categories definition in locale.cc
 213     static const category none          = 0;
 214     static const category ctype         = 1L << 0;
 215     static const category numeric       = 1L << 1;
 216     static const category collate       = 1L << 2;
 217     static const category time          = 1L << 3;
 218     static const category monetary      = 1L << 4;
 219     static const category messages      = 1L << 5;
 220     static const category all           = (collate | ctype | monetary |
 221                                            numeric | time  | messages);
 222
 223     // Construct/copy/destroy:
 224     locale() throw();
 225
 226     locale(const locale& __other) throw();
 227
 228     explicit
 229     locale(const char* __std_name);
 230
 231     locale(const locale& __base, const char* __s, category __cat);
 232
 233     locale(const locale& __base, const locale& __add, category __cat);
 234
 235     template<typename _Facet>
 236       locale(const locale& __other, _Facet* __f);
 237
 238     ~locale() throw();
 239
 240     const locale&
 241     operator=(const locale& __other) throw();
 242
 243     template<typename _Facet>
 244       locale
 245       combine(const locale& __other) const;
 246
 247     // Locale operations:
 248     string
 249     name() const;
 250
 251     bool
 252     operator==(const locale& __other) const throw ();
 253
 254     inline bool
 255     operator!=(const locale& __other) const throw ()
 256     { return !(this->operator==(__other));  }
 257
 258     template<typename _Char, typename _Traits, typename _Alloc>
 259       bool
 260       operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
 261                  const basic_string<_Char, _Traits, _Alloc>& __s2) const;
 262
 263     // Global locale objects:
 264     static locale
 265     global(const locale&);
 266
 267     static const locale&
 268     classic();
 269
 270   private:
 271     // The (shared) implementation
 272     _Impl*              _M_impl;
 273
 274     // The "C" reference locale
 275     static _Impl*       _S_classic;
 276
 277     // Current global reference locale
 278     static _Impl*       _S_global;
 279
 280     static const size_t _S_num_categories = 6;
 281     static const size_t _S_num_facets = _GLIBCPP_NUM_FACETS;
 282
 283     explicit
 284     locale(_Impl*) throw();
 285
 286     static inline void
 287     _S_initialize()
 288     {
 289       if (!_S_classic)
 290         classic();
 291     }
 292
 293     static category
 294     _S_normalize_category(category);
 295
 296     void
 297     _M_coalesce(const locale& __base, const locale& __add, category __cat);
 298   };
 299
 300
 301   // Implementation object for locale
 302   class locale::_Impl
 303   {
 304   public:
 305     // Types.
 306     typedef vector<facet*, allocator<facet*> >  __vec_facet;
 307
 308     // Friends.
 309     friend class locale;
 310     friend class locale::facet;
 311
 312     template<typename _Facet>
 313       friend const _Facet&
 314       use_facet(const locale&);
 315
 316     template<typename _Facet>
 317       friend bool
 318       has_facet(const locale&) throw();
 319
 320   private:
 321     // Data Members.
 322     _Atomic_word                        _M_references;
 323     __vec_facet*                        _M_facets;
 324     string                              _M_names[_S_num_categories];
 325     static const locale::id* const      _S_id_ctype[];
 326     static const locale::id* const      _S_id_numeric[];
 327     static const locale::id* const      _S_id_collate[];
 328     static const locale::id* const      _S_id_time[];
 329     static const locale::id* const      _S_id_monetary[];
 330     static const locale::id* const      _S_id_messages[];
 331     static const locale::id* const* const _S_facet_categories[];
 332
 333     inline void
 334     _M_add_reference() throw()
 335     { __atomic_add(&_M_references, 1); }
 336
 337     inline void
 338     _M_remove_reference() throw()
 339     {
 340       if (__exchange_and_add(&_M_references, -1) == 1)
 341         {
 342           try
 343             { delete this; }
 344           catch(...)
 345             { }
 346         }
 347     }
 348
 349     _Impl(const _Impl&, size_t);
 350     _Impl(string __name, size_t);
 351    ~_Impl() throw();
 352
 353     inline bool
 354     _M_check_same_name()
 355     {
 356       bool __ret = true;
 357       for (size_t i = 0; i < _S_num_categories - 1; ++i)
 358         __ret &= _M_names[i] == _M_names[i + 1];
 359       return __ret;
 360     }
 361
 362     void
 363     _M_replace_categories(const _Impl*, category);
 364
 365     void
 366     _M_replace_category(const _Impl*, const locale::id* const*);
 367
 368     void
 369     _M_replace_facet(const _Impl*, const locale::id*);
 370
 371     void
 372     _M_install_facet(const locale::id*, facet*);
 373
 374     template<typename _Facet>
 375       inline void
 376       _M_init_facet(_Facet* __facet)
 377       { _M_install_facet(&_Facet::id, __facet);  }
 378   };
 379
 380   template<typename _Facet>
 381     locale::locale(const locale& __other, _Facet* __f)
 382     {
 383       _M_impl = new _Impl(*__other._M_impl, 1);
 384       _M_impl->_M_install_facet(&_Facet::id, __f);
 385       for (size_t __i = 0; __i < _S_num_categories; ++__i)
 386         _M_impl->_M_names[__i] = "*";
 387     }
 388
 389   // 22.1.1.1.2  Class locale::facet
 390   class locale::facet
 391   {
 392     friend class locale;
 393     friend class locale::_Impl;
 394     friend class __enc_traits;
 395
 396   private:
 397     _Atomic_word _M_references;
 398
 399   protected:
 400     // Contains data from the underlying "C" library for default "C"
 401     // or "POSIX" locale.
 402     static __c_locale                _S_c_locale;
 403
 404     explicit
 405     facet(size_t __refs = 0) throw();
 406
 407     virtual
 408     ~facet();
 409
 410     static void
 411     _S_create_c_locale(__c_locale& __cloc, const char* __s);
 412
 413     static __c_locale
 414     _S_clone_c_locale(__c_locale& __cloc);
 415
 416     static void
 417     _S_destroy_c_locale(__c_locale& __cloc);
 418
 419   private:
 420     void
 421     _M_add_reference() throw();
 422
 423     void
 424     _M_remove_reference() throw();
 425
 426     facet(const facet&);  // Not defined.
 427
 428     void
 429     operator=(const facet&);  // Not defined.
 430   };
 431
 432
 433   // 22.1.1.1.3 Class locale::id
 434   class locale::id
 435   {
 436   private:
 437     friend class locale;
 438     friend class locale::_Impl;
 439     template<typename _Facet>
 440       friend const _Facet&
 441       use_facet(const locale&);
 442     template<typename _Facet>
 443       friend bool
 444       has_facet(const locale&) throw ();
 445
 446     // NB: There is no accessor for _M_index because it may be used
 447     // before the constructor is run; the effect of calling a member
 448     // function (even an inline) would be undefined.
 449     mutable size_t      _M_index;
 450
 451     // Last id number assigned
 452     static _Atomic_word         _S_highwater;
 453
 454     void
 455     operator=(const id&);  // not defined
 456
 457     id(const id&);  // not defined
 458
 459   public:
 460     // NB: This class is always a static data member, and thus can be
 461     // counted on to be zero-initialized.
 462     id();
 463   };
 464
 465   template<typename _Facet>
 466     const _Facet&
 467     use_facet(const locale& __loc);
 468
 469   template<typename _Facet>
 470     bool
 471     has_facet(const locale& __loc) throw();
 472 } // namespace std
 473
 474 #endif