locale_body.h

Go to the documentation of this file.

 
#ifndef _RWSTD_LOC_RW_LOCALE_H_INCLUDED
#define _RWSTD_LOC_RW_LOCALE_H_INCLUDED
 
 
#include <loc/_facet.h>
#include <loc/_locale.h>
#include <string.h>
 
#include "podarray.h"
 
#include <rw/_defs.h>
 
 
_RWSTD_NAMESPACE (std) { 
 
struct _RWSTD_CLASS_EXPORT locale;
 
}   // namespace std
 
 
_RWSTD_NAMESPACE (__rw) { 
 
 
class _RWSTD_EXPORT __rw_locale
{
public:
    // total number of standard facets (char and wchar specializations)
    // ordinary (unnamed) and byname facets share the same array slot
    enum { _C_n_std_facets = __rw_facet::_C_last_type / 2 };
    enum { _C_namebuf_size = 40 };
 
private:
    // standard facets are always present, user defined facets (i.e.,
    // non-standard specializations of standard facets, or user-defined
    // facets with own id's) are dynamically allocated only if installed
 
    // each standard facet is stored at an index, inx, computed from its
    // numeric id, as follows: inx = (Facet::id._C_id - 1) / 2
    // each slot holds either an ordinary (unnamed) or a byname standard
    // facet (if the latter exists)
    __rw_facet     *_C_std_facets [_C_n_std_facets];
    __rw_facet    **_C_usr_facets;     // array of pointers to user facets
    _RWSTD_SIZE_T   _C_n_usr_facets;   // number of user-defined facets
 
    // name buffer sufficiently large to accommodate 6 basic 5-character
    // POSIX locale names such as "en_US" (one for each LC_XXX category)
    char           _C_namebuf [_C_namebuf_size];
    const char    *_C_name;        // name of locale (!= 0)
    _RWSTD_SIZE_T  _C_ref;         // reference count (>= 0)
 
    // a bit is set for each standard ordinary (unnamed) or byname facet that
    // is installed in the locale, and clear for each standard facet that has
    // been replaced with a user-defined (or user-constructed) object (i.e.,
    // one with the same id) in the locale object
    _RWSTD_SIZE_T _C_std_facet_bits;
 
    // a bit is set for each standard byname facet that is installed in
    // the locale object, and clear for each standard byname facet that
    // has been replaced with a user-defined (or user-constructed) object
    // (i.e., one with the same id) in the locale object
    _RWSTD_SIZE_T _C_byname_facet_bits;
 
    __rw_mutex    _C_mutex;
 
    friend struct _STD::locale;
 
public:
 
    enum {
 
#define _FACET_BIT(name)   (1U << (__rw_facet::_C_##name - 1U) / 2U)
 
        // bitmaps of standard facet types for each category
        // used to set and test the value _C_{std,byname}_facet_bits
        // to quickly determine the composition of a locale object
 
        _C_collate  = _FACET_BIT (collate) | _FACET_BIT (wcollate),
        _C_ctype    =   _FACET_BIT (codecvt) | _FACET_BIT (ctype)
                      | _FACET_BIT (wcodecvt) | _FACET_BIT (wctype),
        _C_monetary =   _FACET_BIT (moneypunct) | _FACET_BIT (moneypunct_intl)
                      | _FACET_BIT (wmoneypunct) | _FACET_BIT (wmoneypunct_intl)
                      | _FACET_BIT (money_get) | _FACET_BIT (money_put)
                      | _FACET_BIT (wmoney_get) | _FACET_BIT (wmoney_put),
        _C_numeric  =   _FACET_BIT (numpunct) | _FACET_BIT (wnumpunct)
                      | _FACET_BIT (num_get) | _FACET_BIT (num_put)
                      | _FACET_BIT (wnum_get) | _FACET_BIT (wnum_put),
        _C_time     =   _FACET_BIT (time_get) | _FACET_BIT (time_put)
                      | _FACET_BIT (wtime_get) | _FACET_BIT (wtime_put),
        _C_messages = _FACET_BIT (messages) | _FACET_BIT (wmessages),
        _C_all      =   _C_collate | _C_ctype | _C_monetary
                      | _C_numeric | _C_time  | _C_messages
 
#undef _FACET_BIT
 
    };
 
    // create a locale body from the name of a locale
    __rw_locale (const char*);
 
    // create a locale body from the name of a locale combined with a facet
    __rw_locale (const char *__name, const __rw_facet *__facet) {
        __rw_locale __tmp (__name);
        _C_construct (__tmp, __facet);
    }
 
    // create a locale body from another locale combined with a facet
    __rw_locale (const __rw_locale &__rhs, const __rw_facet *__facet) {
        _C_construct (__rhs, __facet);
    }
 
    // create a locale body from two locales taking cats from the named one
    __rw_locale (const __rw_locale &__rhs, const char *__name, int __cat) {
        __rw_locale __tmp (__name);
        _C_construct (__rhs, __tmp, __cat);
    }
 
    // create a locale body from two locales taking cats from `l2'
    __rw_locale (const __rw_locale &__l1, const __rw_locale &__l2, int __cat) {
        _C_construct (__l1, __l2, __cat);
    }
 
    ~__rw_locale ();
 
    // returns the name of the locale
    const char* _C_get_name () const {
        return _C_name;
    }
 
    static _RWSTD_SIZE_T _C_add_ref (__rw_facet &__facet) {
        return _RWSTD_ATOMIC_PREINCREMENT (__facet._C_ref, false);
    }
 
    static _RWSTD_SIZE_T _C_remove_ref (__rw_facet &__facet) {
        return _RWSTD_ATOMIC_PREDECREMENT (__facet._C_ref, false);
    }
 
    _RWSTD_SIZE_T _C_add_ref () {
        return _RWSTD_ATOMIC_PREINCREMENT (_C_ref, _C_mutex);
    }
 
    _RWSTD_SIZE_T _C_remove_ref () {
        return _RWSTD_ATOMIC_PREDECREMENT (_C_ref, _C_mutex);
    }
 
    // access private facet name
    static const char* _C_get_cat_name (const __rw_facet &__facet) {
        return __facet._C_name;
    }
 
    // get a string of locale names, one for each installed standard
    // facet's category; will dynamically allocate string if buf is 0
    char* _C_get_cat_names (char*, _RWSTD_SIZE_T) const;
 
    // returns true iff all categories of facets (given by the bitmap)
    // in *this are being globally managed, i.e., iff all of *this facets
    // whose category matches the bitmap are also being globally managed
    // (when the category is locale::none, the function fails for all
    // locales that contain any user-defined facets; otherwise only
    // standard facets are considered)
    bool _C_is_managed (int) const;
 
    // converts a LC_XXX constant to a locale::category value
    static int _C_LC2category (int);
 
    // converts a LC_XXX constant to an internal bitset of facets
    static int _C_LC2facet_bits (int);
 
    static bool _C_check_category (int);
 
    // returns the type of the standard facet object or `unknown'
    // if the facet is of a user-defined type
    static __rw_facet::_C_facet_type _C_get_facet_type (const __rw_facet&);
 
private:
 
    // globally manages all named locales; implements default locale
    // ctor, dtor, and locale::global()
    static __rw_locale* _C_manage (__rw_locale*, const char*);
 
    // implements all but the default locale ctor; the function
    // may construct a new object, return one of its first two
    // arguments, or return a pointer to a cached locale object
    static __rw_locale*
    _C_get_body (__rw_locale*, __rw_locale*,
                 const char*, int, const __rw_facet*);
 
    // called from ctors (only) to fully construct a combined locale
    void _C_construct (const __rw_locale&, const __rw_facet*);
    void _C_construct (const __rw_locale&, const __rw_locale&, int);
 
    // implements locale template ctor: locale::locale (const locale&, Facet*)
    __rw_locale* _C_combine (const __rw_facet*) const;
 
    // implements locale ctor: locale (const locale&, const locale&, category)
    __rw_locale* _C_combine (const __rw_locale&, int);
 
    // returns the index into one of the facet arrays
    // corresponding to the given facet id:
    //   -1       if the facet isn't installed
    //   value <  _C_n_std_facets for a standard facet
    //   value >= _C_n_std_facets otherwise (i.e., for user defined facets)
    _RWSTD_SIZE_T _C_get_facet_inx (_RWSTD_SIZE_T) const;
};
 
 
/* static */ inline bool __rw_locale::_C_check_category (int cat)
{
    // `cat' is assumed to be a C++ locale category (i.e., not an LC_XXX)
    _RWSTD_ASSERT (cat == _C_LC2category (cat));
 
    return __rw_cat_none == cat || !(cat & ~__rw_cat_all);
}
 
 
/* static */ inline __rw_facet::_C_facet_type
__rw_locale::_C_get_facet_type (const __rw_facet &__facet)
{
    _RWSTD_ASSERT (0 != __facet._C_pid);
    _RWSTD_ASSERT (0 != *__facet._C_pid);
 
    // compute the numeric value of the facet's type
    const _RWSTD_SIZE_T __numtype =
        *__facet._C_pid * 2 - 1 + (0 != __facet._C_name);
 
    // return `unknown' for user-defined facets
    return __numtype > __rw_facet::_C_last_type ?
        __rw_facet::_C_unknown : __rw_facet::_C_facet_type (__numtype);
}
 
 
// a one-character string to separate LC_XXX categories in locale names
#ifndef _RWSTD_CAT_SEP
#  define _RWSTD_CAT_SEP ""
#endif
 
 
// maps LC_XXX category values to their names
extern const struct __rw_cats_t
{
    int         cat;          // LC_XXX category
    const char *name;         // LC_XXX name
    int         facet_bits;   // bitmap of facet types
} __rw_cats [6];
 
static const _RWSTD_SIZE_T __rw_n_cats = 6;
 
 
// computes LC_XXX category from a numeric facet id, returns the
// LC_XXX category for standard facets, LC_ALL for all others
inline int __rw_get_cat (int id)
{
#if _RWSTD_LC_MIN >= 0 && _RWSTD_LC_MAX < _RWSTD_UCHAR_MAX
    typedef unsigned char LC_type;
#else
    typedef int LC_type;
#endif   // _RWSTD_LC_MIN >= 0 && _RWSTD_LC_MAX < _RWSTD_UCHAR_MAX
 
    const LC_type lc_cats[] = {
        _RWSTD_LC_COLLATE,
        // _C_codecvt, _C_ctype (all derivatives and specialiations)
        _RWSTD_LC_CTYPE, _RWSTD_LC_CTYPE,
        // _C_moneypunct, _C_moneypunct_intl, _C_money_get, _C_money_put
        _RWSTD_LC_MONETARY, _RWSTD_LC_MONETARY,
        _RWSTD_LC_MONETARY, _RWSTD_LC_MONETARY,
        // _C_numpunct, _C_num_get, _C_num_put
        _RWSTD_LC_NUMERIC, _RWSTD_LC_NUMERIC, _RWSTD_LC_NUMERIC,
        // _C_time_get, _C_time_put
        _RWSTD_LC_TIME, _RWSTD_LC_TIME,
#ifdef _RWSTD_LC_MESSAGES
        // _C_messages
        _RWSTD_LC_MESSAGES
#else
        _RWSTD_LC_MAX + 1
#endif
    };
 
    return id > 0 && id <= __rw_locale::_C_n_std_facets ?
          lc_cats [((id - 1) % (sizeof lc_cats / sizeof *lc_cats))]
        : _RWSTD_LC_ALL;
}
 
 
#ifndef _RWSTD_NO_CONDENSED_NAME
 
static const char __rw_C_locale_name[] = "C";
 
#else   // if defined (_RWSTD_NO_CONDENSED_NAME)
 
static const char __rw_C_locale_name[] = {
    'C', *_RWSTD_CAT_SEP, 'C', *_RWSTD_CAT_SEP, 'C', *_RWSTD_CAT_SEP,
    'C', *_RWSTD_CAT_SEP, 'C', *_RWSTD_CAT_SEP, 'C', '\0'
};
 
#endif   // _RWSTD_NO_CONDENSED_NAME
 
 
// returns true iff `name' is a name of the classic C locale
static inline bool __rw_is_C (const char *name)
{
    _RWSTD_ASSERT (0 != name);
 
    return    'C' == name [0] && '\0' == name [1]
 
#ifdef _RWSTD_NO_CONDENSED_NAME
 
           || !strcmp (__rw_C_locale_name, name)
 
#endif   // _RWSTD_NO_CONDENSED_NAME
 
        ;
}
 
 
}   // namespace __rw
 
 
#endif   // _RWSTD_LOC_RW_LOCALE_H_INCLUDED