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 #include <bits/atomicity.h>
  52
  53 namespace std
  54 {
  55   // 22.1.1 Locale
  56   class locale;
  57
  58   // 22.1.3 Convenience interfaces
  59   template<typename _CharT>
  60     inline bool
  61     isspace(_CharT, const locale&);
  62
  63   template<typename _CharT>
  64     inline bool
  65     isprint(_CharT, const locale&);
  66
  67   template<typename _CharT>
  68     inline bool
  69     iscntrl(_CharT, const locale&);
  70
  71   template<typename _CharT>
  72     inline bool
  73     isupper(_CharT, const locale&);
  74
  75   template<typename _CharT>
  76     inline bool
  77     islower(_CharT, const locale&);
  78
  79   template<typename _CharT>
  80     inline bool
  81     isalpha(_CharT, const locale&);
  82
  83   template<typename _CharT>
  84     inline bool
  85     isdigit(_CharT, const locale&);
  86
  87   template<typename _CharT>
  88     inline bool
  89     ispunct(_CharT, const locale&);
  90
  91   template<typename _CharT>
  92     inline bool
  93     isxdigit(_CharT, const locale&);
  94
  95   template<typename _CharT>
  96     inline bool
  97     isalnum(_CharT, const locale&);
  98
  99   template<typename _CharT>
 100     inline bool
 101     isgraph(_CharT, const locale&);
 102
 103   template<typename _CharT>
 104     inline _CharT
 105     toupper(_CharT, const locale&);
 106
 107   template<typename _CharT>
 108     inline _CharT
 109     tolower(_CharT, const locale&);
 110
 111
 112   // 22.2.1 and 22.2.1.3 ctype
 113   class ctype_base;
 114   template<typename _CharT>
 115     class ctype;
 116   template<> class ctype<char>;
 117 #ifdef _GLIBCPP_USE_WCHAR_T
 118   template<> class ctype<wchar_t>;
 119 #endif
 120   template<typename _CharT>
 121     class ctype_byname;
 122   // NB: Specialized for char and wchar_t in locale_facets.h.
 123
 124   class codecvt_base;
 125   class __enc_traits;
 126   template<typename _InternT, typename _ExternT, typename _StateT>
 127     class codecvt;
 128   template<> class codecvt<char, char, mbstate_t>;
 129 #ifdef _GLIBCPP_USE_WCHAR_T
 130   template<> class codecvt<wchar_t, char, mbstate_t>;
 131 #endif
 132   template<typename _InternT, typename _ExternT, typename _StateT>
 133     class codecvt_byname;
 134
 135   // 22.2.2 and 22.2.3 numeric
 136   template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
 137     class num_get;
 138   template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
 139     class num_put;
 140   template<typename _CharT> class numpunct;
 141   template<typename _CharT> class numpunct_byname;
 142
 143   // 22.2.4 collation
 144   template<typename _CharT>
 145     class collate;
 146   template<typename _CharT> class
 147     collate_byname;
 148
 149   // 22.2.5 date and time
 150   class time_base;
 151   template<typename _CharT, typename _InIter =  istreambuf_iterator<_CharT> >
 152     class time_get;
 153   template<typename _CharT, typename _InIter =  istreambuf_iterator<_CharT> >
 154     class time_get_byname;
 155   template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
 156     class time_put;
 157   template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
 158     class time_put_byname;
 159
 160   // 22.2.6 money
 161   class money_base;
 162   template<typename _CharT, typename _InIter =  istreambuf_iterator<_CharT> >
 163     class money_get;
 164   template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
 165     class money_put;
 166   template<typename _CharT, bool _Intl = false>
 167     class moneypunct;
 168   template<typename _CharT, bool _Intl = false>
 169     class moneypunct_byname;
 170
 171   // 22.2.7 message retrieval
 172   class messages_base;
 173   template<typename _CharT>
 174     class messages;
 175   template<typename _CharT>
 176     class messages_byname;
 177
 178   // 22.1.1 Class locale
 179   class locale
 180   {
 181   public:
 182     // Types:
 183     typedef unsigned int        category;
 184
 185     // Forward decls and friends:
 186     class facet;
 187     class id;
 188     class _Impl;
 189
 190     friend class facet;
 191     friend class _Impl;
 192
 193     template<typename _Facet>
 194       friend const _Facet&
 195       use_facet(const locale&);
 196
 197     template<typename _Facet>
 198       friend bool
 199       has_facet(const locale&) throw();
 200
 201     // Category values:
 202     // NB: Order must match _S_facet_categories definition in locale.cc
 203     static const category none          = 0;
 204     static const category ctype         = 1L << 0;
 205     static const category numeric       = 1L << 1;
 206     static const category collate       = 1L << 2;
 207     static const category time          = 1L << 3;
 208     static const category monetary      = 1L << 4;
 209     static const category messages      = 1L << 5;
 210     static const category all           = (ctype | numeric | collate |
 211                                            time  | monetary | messages);
 212
 213     // Construct/copy/destroy:
 214     locale() throw();
 215
 216     locale(const locale& __other) throw();
 217
 218     explicit
 219     locale(const char* __s);
 220
 221     locale(const locale& __base, const char* __s, category __cat);
 222
 223     locale(const locale& __base, const locale& __add, category __cat);
 224
 225     template<typename _Facet>
 226       locale(const locale& __other, _Facet* __f);
 227
 228     ~locale() throw();
 229
 230     const locale&
 231     operator=(const locale& __other) throw();
 232
 233     template<typename _Facet>
 234       locale
 235       combine(const locale& __other) const;
 236
 237     // Locale operations:
 238     string
 239     name() const;
 240
 241     bool
 242     operator==(const locale& __other) const throw ();
 243
 244     inline bool
 245     operator!=(const locale& __other) const throw ()
 246     { return !(this->operator==(__other));  }
 247
 248     template<typename _Char, typename _Traits, typename _Alloc>
 249       bool
 250       operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
 251                  const basic_string<_Char, _Traits, _Alloc>& __s2) const;
 252
 253     // Global locale objects:
 254     static locale
 255     global(const locale&);
 256
 257     static const locale&
 258     classic();
 259
 260   private:
 261     // The (shared) implementation
 262     _Impl*              _M_impl;
 263
 264     // The "C" reference locale
 265     static _Impl*       _S_classic;
 266
 267     // Current global reference locale
 268     static _Impl*       _S_global;
 269
 270     // Number of standard categories. For C++, these categories are
 271     // collate, ctype, monetary, numeric, time, and messages. These
 272     // directly correspond to ISO C99 macros LC_COLLATE, LC_CTYPE,
 273     // LC_MONETARY, LC_NUMERIC, and LC_TIME. In addition, POSIX (IEEE
 274     // 1003.1-2001) specifies LC_MESSAGES.
 275     static const size_t _S_categories_size = 6;
 276
 277     // In addition to the standard categories, the underlying
 278     // operating system is allowed to define extra LC_*
 279     // macros. For GNU systems, the following are also valid:
 280     // LC_PAPER, LC_NAME, LC_ADDRESS, LC_TELEPHONE, LC_MEASUREMENT,
 281     // and LC_IDENTIFICATION.
 282     static const size_t _S_extra_categories_size = _GLIBCPP_NUM_CATEGORIES;
 283
 284     // Names of underlying locale categories.
 285     // NB: locale::global() has to know how to modify all the
 286     // underlying categories, not just the ones required by the C++
 287     // standard.
 288     static const char*  _S_categories[_S_categories_size
 289                                       + _S_extra_categories_size];
 290
 291     explicit
 292     locale(_Impl*) throw();
 293
 294     static inline void
 295     _S_initialize()
 296     {
 297       if (!_S_classic)
 298         classic();
 299     }
 300
 301     static category
 302     _S_normalize_category(category);
 303
 304     void
 305     _M_coalesce(const locale& __base, const locale& __add, category __cat);
 306   };
 307
 308
 309   // Implementation object for locale
 310   class locale::_Impl
 311   {
 312   public:
 313     // Friends.
 314     friend class locale;
 315     friend class locale::facet;
 316
 317     template<typename _Facet>
 318       friend const _Facet&
 319       use_facet(const locale&);
 320
 321     template<typename _Facet>
 322       friend bool
 323       has_facet(const locale&) throw();
 324
 325   private:
 326     // Data Members.
 327     _Atomic_word                        _M_references;
 328     facet**                             _M_facets;
 329     size_t                              _M_facets_size;
 330
 331     char*                               _M_names[_S_categories_size
 332                                                  + _S_extra_categories_size];
 333     static const locale::id* const      _S_id_ctype[];
 334     static const locale::id* const      _S_id_numeric[];
 335     static const locale::id* const      _S_id_collate[];
 336     static const locale::id* const      _S_id_time[];
 337     static const locale::id* const      _S_id_monetary[];
 338     static const locale::id* const      _S_id_messages[];
 339     static const locale::id* const* const _S_facet_categories[];
 340
 341     inline void
 342     _M_add_reference() throw()
 343     { __atomic_add(&_M_references, 1); }
 344
 345     inline void
 346     _M_remove_reference() throw()
 347     {
 348       if (__exchange_and_add(&_M_references, -1) == 1)
 349         {
 350           try
 351             { delete this; }
 352           catch(...)
 353             { }
 354         }
 355     }
 356
 357     _Impl(const _Impl&, size_t);
 358     _Impl(const char*, size_t);
 359     _Impl(facet**, size_t, bool);
 360
 361    ~_Impl() throw();
 362
 363     _Impl(const _Impl&);  // Not defined.
 364
 365     void
 366     operator=(const _Impl&);  // Not defined.
 367
 368     inline bool
 369     _M_check_same_name()
 370     {
 371       bool __ret = true;
 372       for (size_t __i = 0;
 373            __ret && __i < _S_categories_size + _S_extra_categories_size - 1;
 374            ++__i)
 375         __ret &= (strcmp(_M_names[__i], _M_names[__i + 1]) == 0);
 376       return __ret;
 377     }
 378
 379     void
 380     _M_replace_categories(const _Impl*, category);
 381
 382     void
 383     _M_replace_category(const _Impl*, const locale::id* const*);
 384
 385     void
 386     _M_replace_facet(const _Impl*, const locale::id*);
 387
 388     void
 389     _M_install_facet(const locale::id*, facet*);
 390
 391     template<typename _Facet>
 392       inline void
 393       _M_init_facet(_Facet* __facet)
 394       { _M_install_facet(&_Facet::id, __facet);  }
 395   };
 396
 397   template<typename _Facet>
 398     locale::locale(const locale& __other, _Facet* __f)
 399     {
 400       _M_impl = new _Impl(*__other._M_impl, 1);
 401       _M_impl->_M_install_facet(&_Facet::id, __f);
 402       for (size_t __i = 0;
 403            __i < _S_categories_size + _S_extra_categories_size; ++__i)
 404         {
 405           delete [] _M_impl->_M_names[__i];
 406           char* __new = new char[2];
 407           strcpy(__new, "*");
 408           _M_impl->_M_names[__i] = __new;
 409         }
 410     }
 411
 412   // 22.1.1.1.2  Class locale::facet
 413   class locale::facet
 414   {
 415   private:
 416     friend class locale;
 417     friend class locale::_Impl;
 418
 419     _Atomic_word                        _M_references;
 420
 421   protected:
 422     // Contains data from the underlying "C" library for default "C"
 423     // or "POSIX" locale.
 424     static __c_locale                   _S_c_locale;
 425
 426     explicit
 427     facet(size_t __refs = 0) throw();
 428
 429     virtual
 430     ~facet();
 431
 432     static void
 433     _S_create_c_locale(__c_locale& __cloc, const char* __s,
 434                        __c_locale __old = 0);
 435
 436     static __c_locale
 437     _S_clone_c_locale(__c_locale& __cloc);
 438
 439     static void
 440     _S_destroy_c_locale(__c_locale& __cloc);
 441
 442   private:
 443     void
 444     _M_add_reference() throw();
 445
 446     void
 447     _M_remove_reference() throw();
 448
 449     facet(const facet&);  // Not defined.
 450
 451     void
 452     operator=(const facet&);  // Not defined.
 453   };
 454
 455
 456   // 22.1.1.1.3 Class locale::id
 457   class locale::id
 458   {
 459   private:
 460     friend class locale;
 461     friend class locale::_Impl;
 462     template<typename _Facet>
 463       friend const _Facet&
 464       use_facet(const locale&);
 465     template<typename _Facet>
 466       friend bool
 467       has_facet(const locale&) throw ();
 468
 469     // NB: There is no accessor for _M_index because it may be used
 470     // before the constructor is run; the effect of calling a member
 471     // function (even an inline) would be undefined.
 472     mutable size_t              _M_index;
 473
 474     // Last id number assigned.
 475     static _Atomic_word         _S_highwater;
 476
 477     void
 478     operator=(const id&);  // Not defined.
 479
 480     id(const id&);  // Not defined.
 481
 482   public:
 483     // NB: This class is always a static data member, and thus can be
 484     // counted on to be zero-initialized.
 485     id();
 486
 487     inline size_t
 488     _M_id() const
 489     {
 490       if (!_M_index)
 491         _M_index = 1 + __exchange_and_add(&_S_highwater, 1);
 492       return _M_index - 1;
 493     }
 494   };
 495
 496   template<typename _Facet>
 497     const _Facet&
 498     use_facet(const locale& __loc);
 499
 500   template<typename _Facet>
 501     bool
 502     has_facet(const locale& __loc) throw();
 503 } // namespace std
 504
 505 #endif