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

   1 // Locale support -*- C++ -*-
   2
   3 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003
   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_LOCALE_CLASSES_H
  41 #define _CPP_BITS_LOCALE_CLASSES_H      1
  42
  43 #pragma GCC system_header
  44
  45 #include <bits/localefwd.h>
  46 #include <cstring>              // For strcmp.
  47 #include <string>
  48 #include <bits/atomicity.h>
  49
  50 namespace std
  51 {
  52   // 22.1.1 Class locale
  53   class locale
  54   {
  55   public:
  56     // Types:
  57     typedef unsigned int        category;
  58
  59     // Forward decls and friends:
  60     class facet;
  61     class id;
  62     class _Impl;
  63
  64     friend class facet;
  65     friend class _Impl;
  66
  67     template<typename _Facet>
  68       friend const _Facet&
  69       use_facet(const locale&);
  70
  71     template<typename _Facet>
  72       friend bool
  73       has_facet(const locale&) throw();
  74
  75     // Category values:
  76     // NB: Order must match _S_facet_categories definition in locale.cc
  77     static const category none          = 0;
  78     static const category ctype         = 1L << 0;
  79     static const category numeric       = 1L << 1;
  80     static const category collate       = 1L << 2;
  81     static const category time          = 1L << 3;
  82     static const category monetary      = 1L << 4;
  83     static const category messages      = 1L << 5;
  84     static const category all           = (ctype | numeric | collate |
  85                                            time  | monetary | messages);
  86
  87     // Construct/copy/destroy:
  88     locale() throw();
  89
  90     locale(const locale& __other) throw();
  91
  92     explicit
  93     locale(const char* __s);
  94
  95     locale(const locale& __base, const char* __s, category __cat);
  96
  97     locale(const locale& __base, const locale& __add, category __cat);
  98
  99     template<typename _Facet>
 100       locale(const locale& __other, _Facet* __f);
 101
 102     ~locale() throw();
 103
 104     const locale&
 105     operator=(const locale& __other) throw();
 106
 107     template<typename _Facet>
 108       locale
 109       combine(const locale& __other) const;
 110
 111     // Locale operations:
 112     string
 113     name() const;
 114
 115     bool
 116     operator==(const locale& __other) const throw ();
 117
 118     inline bool
 119     operator!=(const locale& __other) const throw ()
 120     { return !(this->operator==(__other));  }
 121
 122     template<typename _Char, typename _Traits, typename _Alloc>
 123       bool
 124       operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
 125                  const basic_string<_Char, _Traits, _Alloc>& __s2) const;
 126
 127     // Global locale objects:
 128     static locale
 129     global(const locale&);
 130
 131     static const locale&
 132     classic();
 133
 134   private:
 135     // The (shared) implementation
 136     _Impl*              _M_impl;
 137
 138     // The "C" reference locale
 139     static _Impl*       _S_classic;
 140
 141     // Current global locale
 142     static _Impl*       _S_global;
 143
 144     // Number of standard categories. For C++, these categories are
 145     // collate, ctype, monetary, numeric, time, and messages. These
 146     // directly correspond to ISO C99 macros LC_COLLATE, LC_CTYPE,
 147     // LC_MONETARY, LC_NUMERIC, and LC_TIME. In addition, POSIX (IEEE
 148     // 1003.1-2001) specifies LC_MESSAGES.
 149     static const size_t _S_categories_size = 6;
 150
 151     // In addition to the standard categories, the underlying
 152     // operating system is allowed to define extra LC_*
 153     // macros. For GNU systems, the following are also valid:
 154     // LC_PAPER, LC_NAME, LC_ADDRESS, LC_TELEPHONE, LC_MEASUREMENT,
 155     // and LC_IDENTIFICATION.
 156     static const size_t _S_extra_categories_size = _GLIBCPP_NUM_CATEGORIES;
 157
 158     // Names of underlying locale categories.
 159     // NB: locale::global() has to know how to modify all the
 160     // underlying categories, not just the ones required by the C++
 161     // standard.
 162     static const char*  _S_categories[_S_categories_size
 163                                       + _S_extra_categories_size];
 164
 165     explicit
 166     locale(_Impl*) throw();
 167
 168     static inline void
 169     _S_initialize()
 170     {
 171       if (!_S_classic)
 172         classic();
 173     }
 174
 175     static category
 176     _S_normalize_category(category);
 177
 178     void
 179     _M_coalesce(const locale& __base, const locale& __add, category __cat);
 180   };
 181
 182
 183   // Implementation object for locale
 184   class locale::_Impl
 185   {
 186   public:
 187     // Friends.
 188     friend class locale;
 189     friend class locale::facet;
 190
 191     template<typename _Facet>
 192       friend const _Facet&
 193       use_facet(const locale&);
 194
 195     template<typename _Facet>
 196       friend bool
 197       has_facet(const locale&) throw();
 198
 199   private:
 200     // Data Members.
 201     _Atomic_word                        _M_references;
 202     const facet**                       _M_facets;
 203     size_t                              _M_facets_size;
 204
 205     char*                               _M_names[_S_categories_size
 206                                                  + _S_extra_categories_size];
 207     static const locale::id* const      _S_id_ctype[];
 208     static const locale::id* const      _S_id_numeric[];
 209     static const locale::id* const      _S_id_collate[];
 210     static const locale::id* const      _S_id_time[];
 211     static const locale::id* const      _S_id_monetary[];
 212     static const locale::id* const      _S_id_messages[];
 213     static const locale::id* const* const _S_facet_categories[];
 214
 215     inline void
 216     _M_add_reference() throw()
 217     { __atomic_add(&_M_references, 1); }
 218
 219     inline void
 220     _M_remove_reference() throw()
 221     {
 222       if (__exchange_and_add(&_M_references, -1) == 1)
 223         {
 224           try
 225             { delete this; }
 226           catch(...)
 227             { }
 228         }
 229     }
 230
 231     _Impl(const _Impl&, size_t);
 232     _Impl(const char*, size_t);
 233     _Impl(facet**, size_t, bool);
 234
 235    ~_Impl() throw();
 236
 237     _Impl(const _Impl&);  // Not defined.
 238
 239     void
 240     operator=(const _Impl&);  // Not defined.
 241
 242     inline bool
 243     _M_check_same_name()
 244     {
 245       bool __ret = true;
 246       for (size_t __i = 0;
 247            __ret && __i < _S_categories_size + _S_extra_categories_size - 1;
 248            ++__i)
 249         __ret &= (strcmp(_M_names[__i], _M_names[__i + 1]) == 0);
 250       return __ret;
 251     }
 252
 253     void
 254     _M_replace_categories(const _Impl*, category);
 255
 256     void
 257     _M_replace_category(const _Impl*, const locale::id* const*);
 258
 259     void
 260     _M_replace_facet(const _Impl*, const locale::id*);
 261
 262     void
 263     _M_install_facet(const locale::id*, const facet*);
 264
 265     template<typename _Facet>
 266       inline void
 267       _M_init_facet(_Facet* __facet)
 268       { _M_install_facet(&_Facet::id, __facet);  }
 269   };
 270
 271   template<typename _Facet>
 272     locale::locale(const locale& __other, _Facet* __f)
 273     {
 274       _M_impl = new _Impl(*__other._M_impl, 1);
 275       _M_impl->_M_install_facet(&_Facet::id, __f);
 276       for (size_t __i = 0;
 277            __i < _S_categories_size + _S_extra_categories_size; ++__i)
 278         {
 279           delete [] _M_impl->_M_names[__i];
 280           char* __new = new char[2];
 281           strcpy(__new, "*");
 282           _M_impl->_M_names[__i] = __new;
 283         }
 284     }
 285
 286
 287   // 22.1.1.1.2  Class locale::facet
 288   class locale::facet
 289   {
 290   private:
 291     friend class locale;
 292     friend class locale::_Impl;
 293
 294     mutable _Atomic_word                _M_references;
 295
 296   protected:
 297     // Contains data from the underlying "C" library for the classic locale.
 298     static __c_locale                   _S_c_locale;
 299
 300     // String literal for the name of the classic locale.
 301     static char                         _S_c_name[2];
 302
 303     explicit
 304     facet(size_t __refs = 0) throw();
 305
 306     virtual
 307     ~facet();
 308
 309     static void
 310     _S_create_c_locale(__c_locale& __cloc, const char* __s,
 311                        __c_locale __old = 0);
 312
 313     static __c_locale
 314     _S_clone_c_locale(__c_locale& __cloc);
 315
 316     static void
 317     _S_destroy_c_locale(__c_locale& __cloc);
 318
 319   private:
 320     void
 321     _M_add_reference() const throw();
 322
 323     void
 324     _M_remove_reference() const throw();
 325
 326     facet(const facet&);  // Not defined.
 327
 328     void
 329     operator=(const facet&);  // Not defined.
 330   };
 331
 332
 333   // 22.1.1.1.3 Class locale::id
 334   class locale::id
 335   {
 336   private:
 337     friend class locale;
 338     friend class locale::_Impl;
 339     template<typename _Facet>
 340       friend const _Facet&
 341       use_facet(const locale&);
 342     template<typename _Facet>
 343       friend bool
 344       has_facet(const locale&) throw ();
 345
 346     // NB: There is no accessor for _M_index because it may be used
 347     // before the constructor is run; the effect of calling a member
 348     // function (even an inline) would be undefined.
 349     mutable size_t              _M_index;
 350
 351     // Last id number assigned.
 352     static _Atomic_word         _S_highwater;
 353
 354     void
 355     operator=(const id&);  // Not defined.
 356
 357     id(const id&);  // Not defined.
 358
 359   public:
 360     // NB: This class is always a static data member, and thus can be
 361     // counted on to be zero-initialized.
 362     id();
 363
 364     inline size_t
 365     _M_id() const
 366     {
 367       if (!_M_index)
 368         _M_index = 1 + __exchange_and_add(&_S_highwater, 1);
 369       return _M_index - 1;
 370     }
 371   };
 372 } // namespace std
 373
 374 #endif