locale_body.cpp

Go to the documentation of this file.

 
#define _RWSTD_LIB_SRC
 
#include <rw/_defs.h>
 
#include <new>        // for placement new
#include <locale.h>
#include <stdio.h>
#include <stdlib.h>   // for bsearch(), qsort()
#include <string.h>   // for memxxx() and strxxx() functions
 
#include <loc/_locale.h>
 
#include "access.h"
#include "locale_body.h"
#include "setlocale.h"
 
 
#ifdef _RWSTD_NO_LOCALE_NAME_FMAT
 
// pick an arbitrary order for categories in locale names
#  define _RWSTD_CAT_0(pfx) \
       { _RWSTD_LC_CTYPE, "LC_CTYPE", pfx::_C_ctype }
#  define _RWSTD_CAT_1(pfx) \
       { _RWSTD_LC_NUMERIC, "LC_NUMERIC", pfx::_C_numeric }
#  define _RWSTD_CAT_2(pfx) \
       { _RWSTD_LC_TIME, "LC_TIME", pfx::_C_time }
#  define _RWSTD_CAT_3(pfx) \
       { _RWSTD_LC_COLLATE, "LC_COLLATE", pfx::_C_collate }
#  define _RWSTD_CAT_4(pfx) \
       { _RWSTD_LC_MONETARY, "LC_MONETARY", pfx::_C_monetary }
#  define _RWSTD_CAT_5(pfx) \
       { _RWSTD_LC_MESSAGES, "LC_MESSAGES", pfx::_C_messages }
 
#endif   // _RWSTD_NO_LOCALE_NAME_FMAT
 
 
#if 6 == _RWSTD_HP_aCC_MAJOR && _RWSTD_HP_aCC_MINOR <= 1600
   // silence bogus HP aCC 6.16/cadvise warning #20200-D:
   // Potential null pointer dereference
#  pragma diag_suppress 20200
#endif
 
 
_RWSTD_NAMESPACE (__rw) {
 
 
// maps LC_XXX category values to their names
extern const __rw_cats_t
__rw_cats [] = {
 
    // expands to { LC_XXX, "LC_XXX", _RW::__rw_locale::_C_xxx }
    // the order of these is determined at config time and corresponds to
    // the order mixed/combined locale categories returned by setlocale()
    _RWSTD_CAT_0 (_RW::__rw_locale),
    _RWSTD_CAT_1 (_RW::__rw_locale),
    _RWSTD_CAT_2 (_RW::__rw_locale),
    _RWSTD_CAT_3 (_RW::__rw_locale),
    _RWSTD_CAT_4 (_RW::__rw_locale),
 
#ifdef _RWSTD_CAT_5
    _RWSTD_CAT_5 (_RW::__rw_locale)
#else   // if !defined (_RWSTD_CAT_5)
    // for Windoze (no LC_MESSAGES there)
    _RWSTD_CAT_0 (_RW::__rw_locale)
#endif   // _RWSTD_CAT_5
 
};
 
 
// fills provided buffer (if large anough) with the names of locales
// for each of the standard LC_XXX categories; if all categories come
// from the same locale, copies the name of the common locale into
// the provided buffer
//
// names of categories are in the following order:
//     LC_COLLATE, LC_CTYPE, LC_MONETARY, LC_NUMERIC, LC_TIME, LC_MESSAGES
//
// examples of output (assuming ';' as a separator):
//     "C"
//         all facets of all categories come from the "C" locale
//
//     "C;C;de_DE;C;C;C;"
//         all facets come from the "C" locale except those that belong
//         to the LC_MONETARY category, which all come from "de_DE"
// 
//     "C;en_US;*;*;*;*;"
//         facets the belong to the LC_COLLATE category come from the
//         "C" locale, those belonging to the LC_CTYPE category come
//         from "en_US", all others are from mixed locales within
//         their respective categories
//
//     "*"
//         facets belonging to each category come from all different
//         locales (e.g., ctype<char> might come from the "C" locale,
//         and ctype<wchar_t> from "ja_JP", etc.)
 
char* __rw_locale::
_C_get_cat_names (char *buf, size_t bufsize) const
{
    const size_t  savesize = bufsize;
    char         *savebuf  = buf;
 
    if (!buf)
        buf = new char [bufsize ? bufsize : (bufsize = 256)];
 
    *buf = '\0';
 
    // will point at the locale name common across all categories
    // if one such name exists; otherwise at "*" (mixed locale)
    const char *common_name = 0;
 
    // iterate over all categories, searching for all facets that belong
    // to that category and comparing their names. if all such facets come
    // from the same locale, the name of the category is the name of the
    // locale; otherwise "*"
    for (size_t i = 0; i != __rw_n_cats; ++i) {
 
        const char *cat_name = 0;
 
        for (size_t j = 0; j != _C_n_std_facets; ++j) {
 
            // verify that all facet pointers are set
            _RWSTD_ASSERT (_C_std_facets [j]);
 
            // ignore the non-localized {money,num}_{get,put} facets
            // and consider only moneypunct and numpunct for the
            // monetary category
            switch (_C_std_facets [j]->_C_type) {
            case __rw_facet::_C_num_get:
            case __rw_facet::_C_wnum_get:
            case __rw_facet::_C_num_put:
            case __rw_facet::_C_wnum_put:
            case __rw_facet::_C_money_get:
            case __rw_facet::_C_wmoney_get:
            case __rw_facet::_C_money_put:
            case __rw_facet::_C_wmoney_put:
                continue;
            default:
                break;
            }
 
            _RWSTD_ASSERT (0 != _C_std_facets [j]->_C_pid);
 
            // one category at a time
            if (   __rw_cats [i].cat
                != __rw_get_cat (int (*_C_std_facets [j]->_C_pid)))
                continue;
 
            // default facet name (if 0) is "C"
            const char *facet_name = _C_std_facets [j]->_C_name
                ? _C_std_facets [j]->_C_name : "C";
 
            if (cat_name && strcmp (cat_name, facet_name))
                cat_name = "*";
            else
                cat_name = facet_name;
 
            if (common_name) {
                // if the name of the locale for this category doesn't
                // match the common locale name so far, assign "*"
                if (strcmp (common_name, cat_name))
                    common_name = "*";
            }
            else
                common_name = cat_name;
        }
 
        // will be 0 iff all facets in a category are 0
        // (i.e., an internal logic error)
        _RWSTD_ASSERT (cat_name);
 
        if (   strlen (buf) + strlen (cat_name) + 2
            >= bufsize) {
            // reallocate buffer if necessary
            char *tmp = 0;
 
            _TRY {
                tmp = new char [bufsize *= 2];
            }
            _CATCH (...) {
                if (buf != savebuf)
                    delete[] buf;
                _RETHROW;
            }
 
            strcpy (tmp, buf);
            if (buf != savebuf)
                delete[] buf;
            buf = tmp;
        }
 
        strcat (buf, cat_name);
        strcat (buf, _RWSTD_CAT_SEP);
    }
 
    _RWSTD_ASSERT (common_name);
 
    if (__rw_facet::_C_opts & __rw_facet::_C_condensed_name) {
        // if all categories come from the same locale, copy the name
        // of that locale into the buffer
        if ('*' != common_name [0] || '\0' != common_name [1]) {
            if (   savebuf && buf != savebuf
                && savesize >= strlen (common_name)) {
                // delete allocated memory and repoint at original buffer
                delete[] buf;
                buf = savebuf;
            }
            strcpy (buf, common_name);
        }
    }
 
    // remove trailing separator
    const size_t len = strlen (buf);
    if (len && *_RWSTD_CAT_SEP == buf [len - 1])
        buf [len - 1] = '\0';
 
    return buf;
}
 
 
// returns a pointer to a character array containing locale names separated
// by _RWSTD_CAT_SEP corresponding to the named locale (typically all the
// names will be the same except possibly for the native locale which can
// consist of facets from different named locales specified by the LC_XXX
// environment variables)
static const char*
__rw_expand_name (__rw_chararray &namebuf, const char *name)
{
    const char *sep = strchr (name, *_RWSTD_CAT_SEP);
 
    if (sep == name) {
        // skip the first separator if it's at the beginning of `name'
        // (e.g., SunOS locale names have the format "/en/C/ja/C/it/de")
        sep = strchr (++name, *_RWSTD_CAT_SEP);
    }
 
    // true if all ctaegories are from the same locale, false otherwise
    bool same_cats = true;
 
    if (sep) {
 
        // `name' contains a locale category separator; iterate over
        // all locale categories to determine the name of the locale
        // for each one of them
 
        for (size_t i = 0; ; sep = strchr (name, *_RWSTD_CAT_SEP)) {
 
            if (!sep)
                sep = name + strlen (name);
 
            const size_t catlen = sep - name;
 
            // copy the read-only substring forming a locale name
            // into a writeable buffer so that it can be NUL-terminated
            const __rw_chararray shortname (name, catlen);
 
            __rw_chararray longname;
 
            // convert the (possibly abbreviated) name or a locale alias
            // into the full name uniquely identifying the locale (e.g.,
            // all of "de," "de_DE," and "german" can expand into the
            // full canonical name "de_DE.ISO-8869-1"; this is necessary
            // to guarantee that the internal locale repository doesn't
            // contain duplicate entries)
            const char* const fullname =
                __rw_locale_name (__rw_cats [i].cat, shortname.data (),
                                  longname);
 
            if (!fullname)
                return 0;
 
            const size_t namelen = strlen (fullname);
 
            _RWSTD_ASSERT (0 != namelen);
 
            // determine if the new category name is the same as the first
            // one (if it is, it is also the same as all subsequent ones,
            // otherwise `same_cats' is already set to false)
            if (same_cats && i)
                same_cats =    !memcmp (namebuf.data (), fullname, namelen)
                            && *_RWSTD_CAT_SEP == namebuf.data () [namelen];
 
            namebuf.append (fullname, namelen);
 
            if (++i == __rw_n_cats || !*sep)
                break;
 
            namebuf.append (_RWSTD_CAT_SEP, 1);
 
            name = sep + 1;
        }
    }
    else if ('\0' == *name) {
 
        // no separator found, set all categories
        const __rw_setlocale loc (name, _RWSTD_LC_ALL, 1 /* nothrow */);
 
        if (!loc.name ())
            return 0;
 
        // compose a string of category names separated by CAT_SEP
        for (size_t i = 0; ; ) {
 
            // retrieve the name of each idividual category
            const char* const fullname = setlocale (__rw_cats [i].cat, 0);
 
            // call to setlocale() must succeed if `loc' succeeded
            _RWSTD_ASSERT (0 != fullname);
 
            const size_t namelen = strlen (fullname);
 
            if (same_cats && i)
                same_cats =    !memcmp (namebuf.data (), fullname, namelen)
                            && *_RWSTD_CAT_SEP == namebuf.data () [namelen];
 
            namebuf.append (fullname, namelen);
 
            if (++i == __rw_n_cats)
                break;
 
            namebuf.append (_RWSTD_CAT_SEP, 1);
        }
    }
    
    if (*namebuf.data ()) {
 
        if (same_cats && __rw_facet::_C_opts & __rw_facet::_C_condensed_name) {
 
            // all categories were the same, store just the first one
 
            char* const  data   = namebuf.data ();
            const size_t sepinx = strchr (data, *_RWSTD_CAT_SEP) - data;
 
            // NUL-terminate at the first separator
            namebuf.acquire (data, sepinx);
            namebuf.append ("", 1);
        }
    }
    else {
 
        const char* const fullname =
            __rw_locale_name (_RWSTD_LC_ALL, name, namebuf);
 
        if (!fullname)
            return 0;
    }
 
    return namebuf.data ();
 
    
#if 0
 
    // points to the next category name
    const char *next = strchr (name, *_RWSTD_CAT_SEP);
 
    if (next && *next) {
 
            // save the end of the first name to detect combined locale
            // names composed of categories referring to the same locale
            char *first_end = bufbeg;
 
            // name is a string of locale category names; compose
            // an equivalent string obtained by concatenating the
            // results of calling setlocale() on each
            // substring
 
            const char *ps = name;
 
            size_t __i = 0;
            do {
                if (!next)
                    next = ps + strlen (ps);
 
                memcpy (pbuf, ps, next - ps);
                pbuf [next - ps] = '\0';
 
                if (__i < __rw_n_cats) {
 
                    const int cat = __rw_cats [__i++].cat;
 
                    // get the actual locale name for each category
                    // and append it to the end of the name buffer
                    if (!__rw_locale_name (cat, pbuf, pbuf, pbuf - bufbeg))
                        return 0;   // name not recognized
                }
 
                const size_t len = strlen (pbuf);
 
                if (first_end == bufbeg)
                    first_end = pbuf + len;
                else if (   first_end
                         && (   size_t (first_end - bufbeg) != len
                             || memcmp (bufbeg, pbuf, len))) {
                    // category name differs from the first (i.e., category
                    // names will be cobined) no need to check further
                    first_end = 0;
                }
 
                // advance to the next name
                pbuf    += len;
                *pbuf++  = *_RWSTD_CAT_SEP;
 
                // reached the end of the (not `sep'-terminated) list
                if ('\0' == *next)
                    break;
 
                ps    = next + 1;
                next  = strchr (ps, *_RWSTD_CAT_SEP);
            } while (*ps);
 
            *pbuf = '\0';
 
            // assume the native locale for all missing categories
            while (__i < __rw_n_cats) {
 
                const int cat = __rw_cats [__i++].cat;
 
                const __rw_setlocale loc ("", cat, 1 /* nothrow */);
 
                if (!loc.name ())
                    return 0;
 
                const char* catname = setlocale (cat, 0);
 
                _RWSTD_ASSERT (0 != catname);
 
                strcat (pbuf, catname);
 
                // compare the category name with the first one and remember
                // if they differ (to detect all the same category names)
                if (first_end && memcmp (bufbeg, name, first_end - name))
                    first_end = 0;
 
                pbuf    += strlen (pbuf);
                *pbuf++  = *_RWSTD_CAT_SEP;
            }
 
            // remove the last separator
            if (pbuf [-1] == *_RWSTD_CAT_SEP)
                pbuf [-1] = '\0';
 
            // if non-0, all categories come from the same locale
            // keep the first name and chop off the rest
            if (   __rw_facet::_C_opts & __rw_facet::_C_condensed_name
                && first_end)
                bufbeg [first_end - bufbeg] = '\0';
        }
        else {
            // all categories have the same name in named locales
 
            name = __rw_locale_name (_RWSTD_LC_ALL, name, bufbeg, bufsize);
            if (!name)
                return 0;
        }
    }
 
    return bufbeg;
 
#endif
}
 
 
size_t __rw_locale::
_C_get_facet_inx (size_t id) const
{
    // verify that facet's id is initialized
    _RWSTD_ASSERT (id);
 
    // standard facet's id are one greater than their index
    if (id <= _C_n_std_facets)
        return id - 1;
 
    _RWSTD_ASSERT (!_C_n_usr_facets || _C_usr_facets);
 
    // linear search through user-defined facets (if any)
    for (size_t i = 0; i != _C_n_usr_facets; ++i) {
 
        _RWSTD_ASSERT (_C_usr_facets [i]->_C_pid);
 
        if (*_C_usr_facets [i]->_C_pid == id)
            return i + _C_n_std_facets;
    }
 
    return _RWSTD_SIZE_MAX;
}
 
 
__rw_locale::
__rw_locale (const char *name)
    : _C_usr_facets (0), _C_n_usr_facets (0), _C_ref (1),
      _C_std_facet_bits (0), _C_byname_facet_bits (0)
{
    _RWSTD_ASSERT (name);
 
    // verify that name doesn't refer to an unnamed (combined) locale
    _RWSTD_ASSERT (!strchr (name, '*'));
 
    if ('\0' == *name) {
 
        __rw_chararray fullname;
        fullname.acquire (_C_namebuf, 0);
 
        // get the names of locales for all standard categories
        // avoiding dynamic memory allocation if possible
        _C_name = __rw_expand_name (fullname, name);
 
        fullname.release ();
 
        // caller must guarantee that `name' is valid
        _RWSTD_ASSERT (0 != _C_name);
 
        // note that `name' may not be the same as `_C_name' at this point
    }
    else {
        const size_t namelen = strlen (name) + 1;
 
        // assume name is well-formed and valid (checked by caller)
        char* const tmp = namelen < sizeof _C_namebuf
            ? _C_namebuf : new char [namelen];
 
        memcpy (tmp, name, namelen);
 
        _C_name = tmp;
    }
 
   // all facets are standard
   _C_std_facet_bits = _C_all;
 
   // byname facets determined below
   _C_byname_facet_bits = 0;
 
   if (strchr (_C_name, *_RWSTD_CAT_SEP)) {
 
       // name consist of multiple locale names; iterate over them all
       // setting byname facet bits for each named category
       size_t inx = 0;
 
       for (const char *nm = _C_name; *nm && inx != __rw_n_cats; ++nm) {
 
           if ('C' != nm [0] || *_RWSTD_CAT_SEP != nm [1])
               _C_byname_facet_bits |= __rw_cats [inx].facet_bits;
 
           nm = strchr (nm, *_RWSTD_CAT_SEP);
           if (!nm)
               break;
 
           ++inx;
       }
   }
   else {
       // all facets (except for num_{get,put}) are byname in non-C locales
       if (!__rw_is_C (_C_name))
           _C_byname_facet_bits = _C_all;
   }
 
#if defined (__i386__) || !defined (__GNUG__) || __GNUG__ < 3
 
   memset (_C_std_facets, 0, sizeof _C_std_facets);
 
#else   // !i86  || !gcc 3.x
 
   // Working around a gcc 3.1 optimizer bug on SPARC (and possibly
   // other RISC architectures) where, when generating PIC, _C_std_facets
   // ends up being 4-byte aligned and gcc replaces memset() with a series
   // of std %o1, [_C_std_facets + i] instructions with %o1 being 0 and i
   // being 0, 8, 16, etc. and std operating on 64-bit double words. The
   // first such misaligned std operation causes a SIGBUS
 
   for (size_t i = 0; i != _C_n_std_facets; ++i)
       _C_std_facets [i] = 0;
 
#endif   // i86/gcc 3.x
 
}
 
 
// convert a LC_XXX constant to a locale::category value
/* static */ int __rw_locale::
_C_LC2category (int cat)
{
    switch (cat) {
    case _RWSTD_LC_ALL:      cat = __rw_cat_all; break;
    case _RWSTD_LC_COLLATE:  cat = __rw_cat_collate; break;
    case _RWSTD_LC_CTYPE:    cat = __rw_cat_ctype; break;
    case _RWSTD_LC_MONETARY: cat = __rw_cat_monetary; break;
    case _RWSTD_LC_NUMERIC:  cat = __rw_cat_numeric; break;
    case _RWSTD_LC_TIME:     cat = __rw_cat_time; break;
#ifdef _RWSTD_LC_MESSAGES
    case _RWSTD_LC_MESSAGES: cat = __rw_cat_messages; break;
#endif
 
    default:
        // assume `cat' is already a locale::category value
        break;
    }
    return cat;
}
 
 
// convert a LC_XXX constant to an internal bitset of facets
/* static */ int __rw_locale::
_C_LC2facet_bits (int cat)
{
    int bits;
 
    switch (cat) {
    case _RWSTD_LC_ALL:      bits = __rw_locale::_C_all; break;
    case _RWSTD_LC_COLLATE:  bits = __rw_locale::_C_collate; break;
    case _RWSTD_LC_CTYPE:    bits = __rw_locale::_C_ctype; break;
    case _RWSTD_LC_MONETARY: bits = __rw_locale::_C_monetary; break;
    case _RWSTD_LC_NUMERIC:  bits = __rw_locale::_C_numeric; break;
    case _RWSTD_LC_TIME:     bits = __rw_locale::_C_time; break;
#ifdef _RWSTD_LC_MESSAGES
    case _RWSTD_LC_MESSAGES: bits = __rw_locale::_C_messages; break;
#endif
 
    default: {
 
        // assume `cat' is a locale::category value
        bits = 0;
 
        if (cat & __rw_cat_collate)
            bits |= _RW::__rw_locale::_C_collate;
        if (cat & __rw_cat_ctype)
            bits |= _RW::__rw_locale::_C_ctype;
        if (cat & __rw_cat_monetary)
            bits |= _RW::__rw_locale::_C_monetary;
        if (cat & __rw_cat_numeric)
            bits |= _RW::__rw_locale::_C_numeric;
        if (cat & __rw_cat_time)
            bits |= _RW::__rw_locale::_C_time;
        if (cat & __rw_cat_messages)
            bits |= _RW::__rw_locale::_C_messages;
        break;
    }
 
    }
    return bits;
}
 
 
__rw_locale::
~__rw_locale ()
{
    // verify that object isn't being destroyed prematurely
    _RWSTD_ASSERT (0 == _C_ref);
 
    if (_C_name != _C_namebuf)
        delete[] _RWSTD_CONST_CAST (char*, _C_name);
 
    // decrement the reference count of each installed facet
    // and delete each facet whose refcount drops to zero
    for (size_t i = 0; i != _C_n_std_facets; ++i) {
 
        if (!_C_std_facets [i])
            continue;
 
        _RWSTD_ASSERT (_C_std_facets [i]->_C_type != __rw_facet::_C_invalid);
 
        if (_C_std_facets [i]->_C_type) {
 
            // only standard facets (non-zero type) are managed
            // decrement the facet's reference count and remove
            // it from the global repository if it is 0
            const __rw_facet* const pfacet =
                __rw_facet::_C_manage (_C_std_facets [i],
                                       _C_std_facets [i]->_C_type,
                                       _C_std_facets [i]->_C_name,
                                       0);
 
            // verify that facet has been disposed of
            _RWSTD_ASSERT (0 == pfacet);
            _RWSTD_UNUSED (pfacet);
        }
        else {
            // decrement ref count (must not drop below 0)
            const size_t ref = _C_remove_ref (*_C_std_facets [i]);
 
            _RWSTD_ASSERT (ref + 1U != 0);
 
            if (0 == ref)
                delete _C_std_facets [i];
        }
    }
 
    // verify that either both are 0 or neither is 0
    _RWSTD_ASSERT (!_C_n_usr_facets == !_C_usr_facets);
 
    // decrement ref counts of user-defined facets and delete if necessary
    for (size_t j = 0; j != _C_n_usr_facets; ++j) {
 
        _RWSTD_ASSERT (_C_usr_facets [j]);
 
        _RWSTD_ASSERT (_C_usr_facets [j]->_C_type != __rw_facet::_C_invalid);
 
        // decrement ref count (must not drop below 0)
        const size_t ref = _C_remove_ref (*_C_usr_facets [j]);
 
        _RWSTD_ASSERT (ref + 1U != 0);
 
        if (0 == ref)
            delete _C_usr_facets [j];
    }
 
    delete[] _C_usr_facets;
}
 
 
extern "C" {
 
// compares two locales, returns 0 if equal, -1 if less, +1 otherwise
static int
cmplocales (const void *pv1, const void *pv2)
{
    _RWSTD_ASSERT (0 != pv1);
    _RWSTD_ASSERT (0 != pv2);
 
    const __rw_locale* const pl1 =
        *_RWSTD_STATIC_CAST (const __rw_locale* const*, pv1);
    const __rw_locale* const pl2 =
        *_RWSTD_STATIC_CAST (const __rw_locale* const*, pv2);
 
    _RWSTD_ASSERT (0 != pl1->_C_get_name ());
    _RWSTD_ASSERT (0 != pl1->_C_get_name ());
 
    return strcmp (pl1->_C_get_name (), pl2->_C_get_name ());
}
 
 
// compares a key to a locale, returns 0 if equal, -1 if less, +1 otherwise
static int
cmplocale (const void *pv1, const void *pv2)
{
    _RWSTD_ASSERT (0 != pv1);
    _RWSTD_ASSERT (0 != pv2);
 
    const char* const nm1 = _RWSTD_STATIC_CAST (const char*, pv1);
 
    const __rw_locale* const plocale =
        *_RWSTD_STATIC_CAST (const __rw_locale* const*, pv2);
 
    _RWSTD_ASSERT (0 != nm1);
    _RWSTD_ASSERT (0 != plocale->_C_get_name ());
 
    return strcmp (nm1, plocale->_C_get_name ());
}
 
}   // extern "C"
 
 
// manages a global, per-process repository of locale bodies according
// to the following table:
 
//     plocale   locname   algorithm
//        0         0      retrieve the global locale
//        0       non-0    find named locale in repository and increment
//                         its ref count if found, or construct it with
//                         ref count of 1 and add it otherwise
//      non-0       0      make `plocale' the new global locale and
//                         return the previous global locale
//      non-0     non-0    find locale in repository, decrement its ref
//                         count, and remove it if the ref count is 0
 
/* static */ __rw_locale*
__rw_locale::
_C_manage (__rw_locale *plocale, const char *locname)
{
    // a per-process array of locale body pointers
    static __rw_locale*  locale_buf [8];
    static __rw_locale** locales        = locale_buf;
    static __rw_locale*  classic        = 0;
    static size_t        n_locales      = 0;
    static size_t        locale_bufsize =
        sizeof locale_buf / sizeof *locale_buf;
 
    if (!locname) {
 
        // manage the global locale
 
        static __rw_locale* global = 0;
 
        if (!global) {
 
            // volatile to prevent optimizers from turning
            // the while statement below into an infinite loop
            static volatile int ginit /* = 0 */;
 
            // cast ginit to int& (STDCXX-792)
            // casting should be removed after fixing STDCXX-794
            if (!ginit && 1 == _RWSTD_ATOMIC_PREINCREMENT (
                    _RWSTD_CONST_CAST (int&, ginit), false)) {
                global  = _C_manage (0, "C");
                ginit  += 1000;
            }
            else {
                // ginit must be volatile to prevent optimizers
                // from turning this into an infinite loop
                while (ginit < 1000) { /* empty */ }
            }
        }
 
        // re-entrant
        _RWSTD_MT_STATIC_GUARD (_RW::__rw_locale);
 
        __rw_locale* const tmp = global;
 
        _RWSTD_ASSERT (0 != tmp);
 
        if (plocale) {
            // replace the global locale with `plocale'
 
            // increment the future global locale's ref count first
            _RWSTD_ATOMIC_PREINCREMENT (plocale->_C_ref, false);
 
            // and then set the global locale
            global = plocale;
        }
        else {
 
            // retrieve the global locale
 
            // always increment a ref count, even if `global' is being set
            // (and its ref count is > 0), to prevent its ref count from
            // dropping to 0
            _RWSTD_ATOMIC_PREINCREMENT (tmp->_C_ref, false);
        }
 
        return tmp;
    }
 
 
    // re-entrant to protect static local data structures
    // (not the locales themselves)
    _RWSTD_MT_STATIC_GUARD (_RW::__rw_locale);
 
    // determine whether `locname' refers to the classic C locale
    // (e.g., it could be any of "C", "POSIX", "C C C C C C", etc.)
    bool is_C_locale = __rw_is_C (locname);
 
    // substitute the fully expanded libc name for the classic C locale,
    // i.e., the result of calling std::setlocale ("C")
    if (is_C_locale)
        locname = __rw_C_locale_name;
 
    __rw_chararray fullname;
 
    if (!plocale && !is_C_locale) {
        // to avoid unnecessary calls to setlocale() only get cat names
        // when composing a locale name, otherwise the locale name is
        // assumed to be correct and complete
        locname = __rw_expand_name (fullname, locname);
 
        if (!locname)
            return 0;   // program error
 
        is_C_locale = __rw_is_C (locname);
 
        if (is_C_locale)
            locname = __rw_C_locale_name;
    }
 
    if (plocale) {
        // remove locale from the locale repository (if it is found) and
        // destroy it (the classic C locale is never destroyed)
 
        _RWSTD_ASSERT (0 != n_locales);
 
        const void* const pl =
            bsearch (locname, locales, n_locales, sizeof *locales, &cmplocale);
        if (pl) {
 
            const size_t inx =
                  _RWSTD_STATIC_CAST (const __rw_locale* const*, pl)
                - _RWSTD_CONST_CAST (const __rw_locale* const*, locales);
 
            plocale = locales [inx];
 
            const size_t ref =
                _RWSTD_ATOMIC_PREDECREMENT (plocale->_C_ref, false);
 
            _RWSTD_ASSERT (_RWSTD_SIZE_MAX != ref);
 
            if (0 == ref) {
 
                static const size_t bufsize =
                    sizeof locale_buf / sizeof *locale_buf;
 
                --n_locales;
 
                if (n_locales < bufsize / 2 && locales != locale_buf) {
 
                    _RWSTD_ASSERT (inx < bufsize);
 
                    // when the number of locales in the dynamically
                    // allocated repository drops below half the capacity
                    // of the statically allocated buffer, copy locales
                    // from the former into the latter and deallocate the
                    // former
                    memcpy (locale_buf, locales, inx * sizeof (*locales));
 
                    memcpy (locale_buf + inx, locales + inx + 1,
                            (n_locales - inx) * sizeof (*locales));
 
                    delete[] locales;
 
                    // point at the statically allocated buffer and reset
                    // the current capacity to the original capacity
                    locales        = locale_buf;
                    locale_bufsize = bufsize;
                }
                else {
                    // move facet pointers back
                    memmove (locales + inx, locales + inx + 1,
                             (n_locales - inx) * sizeof (*locales));
                }
 
                _RWSTD_ASSERT (0 != plocale->_C_name);
 
                // only named locales (i.e., other than the C locale) 
                // are deleted
                if (!__rw_is_C (plocale->_C_name))
                    delete plocale;
            }
        }
        else {
 
            // object is the classic C locale which is never destroyed
            _RWSTD_ASSERT (plocale->_C_name);
            _RWSTD_ASSERT (__rw_is_C (plocale->_C_name));
 
            const size_t ref =
                _RWSTD_ATOMIC_PREDECREMENT (plocale->_C_ref, false);
 
            _RWSTD_ASSERT (ref + 1U != 0);
            _RWSTD_UNUSED (ref);
         }
        
        plocale = 0;
    }
    else {
 
        // find locale in the repository or construct it if not found
 
        const void* const pcl =
            bsearch (locname, locales, n_locales, sizeof *locales, &cmplocale);
 
        if (pcl) {
            // facet already exists in the repository, bump up its ref count
 
            void* const pl = _RWSTD_CONST_CAST (void*, pcl);
 
            plocale  = *_RWSTD_STATIC_CAST (__rw_locale**, pl);
 
            _RWSTD_ASSERT (0 != plocale);
 
            _RWSTD_ATOMIC_PREINCREMENT (plocale->_C_ref, false);
        }
        else {
 
            if (n_locales == locale_bufsize) {
 
                // reallocate buffer of facet pointers
                __rw_locale** const tmp =
                    new __rw_locale* [n_locales * 2];
 
                memcpy (tmp, locales, n_locales * sizeof *tmp);
 
                if (locales != locale_buf)
                    delete[] locales;
 
                locales         = tmp;
                locale_bufsize *= 2;
            }
 
            if (__rw_is_C (locname)) {
 
                if (!classic) {
 
                    // the classic C locale is statically allocated
                    // and not destroyed during the lifetime of the process
                    static union {
                        void* _C_align;
                        char  _C_buf [sizeof (__rw_locale)];
                    } classic_body;
 
                    // construct a locale body in place
                    // with the initial reference count of 1
                    classic = new (&classic_body) __rw_locale (locname);
 
                    _RWSTD_ASSERT (1 == classic->_C_ref);
                }
                else {
                    _RWSTD_ASSERT (0 != classic);
 
                    _RWSTD_ATOMIC_PREINCREMENT (classic->_C_ref, false);
                }
 
                plocale = classic;
            }
            else {
                plocale = new __rw_locale (locname);
 
                _RWSTD_ASSERT (1 == plocale->_C_ref);
            }
 
            _RWSTD_ASSERT (plocale);
 
            // add locale body pointer to the end of the repository
            locales [n_locales++] = plocale;
 
            // sort pointers for fast access
            qsort (locales, n_locales, sizeof *locales, &cmplocales);
        }
    }
 
    return plocale;
}
 
 
// returns true iff all the facets in the given locale category
// installed in `*this' are being globally managed by the library
// if (cat == locale::none) holds, returns true iff the entire
// locale body is being managed
bool __rw_locale::
_C_is_managed (int cat) const
{
    // `cat' must be a valid category
    _RWSTD_ASSERT (_C_check_category (_C_LC2category (cat)));
 
    if (cat == __rw_cat_none) {
 
        // locales containing any user-defined facets are not globally managed
        if (_C_n_usr_facets) {
            _RWSTD_ASSERT (0 != _C_usr_facets);
            return false;
        }
 
        // unless all facets in the same category come either from
        // the C locale or from some named locale the locale object
        // containing the facets is not managed (this test doesn't
        // detect categores of all byname facets not all of which
        // belong to the same named locale)
        if (   (_C_std_facet_bits & _C_all) != _C_all
            || (_C_byname_facet_bits & _C_collate)
            && (_C_byname_facet_bits & _C_collate)  != _C_collate
            || (_C_byname_facet_bits & _C_ctype)
            && (_C_byname_facet_bits & _C_ctype)    != _C_ctype
            || (_C_byname_facet_bits & _C_monetary)
            && (_C_byname_facet_bits & _C_monetary) != _C_monetary
            || (_C_byname_facet_bits & _C_numeric)
            && (_C_byname_facet_bits & _C_numeric)  != _C_numeric
            || (_C_byname_facet_bits & _C_time)
            && (_C_byname_facet_bits & _C_time)     != _C_time
            || (_C_byname_facet_bits & _C_messages)
            && (_C_byname_facet_bits & _C_messages) != _C_messages)
            return false;
 
        // check whether all _byname facets in each category belong
        // to the same named locale; facets witout byname forms are
        // excluded from this test
        // note that the locale may have a combined name such as
        // "/de/en/fr/it/ja/ru"
        const char* locname = _C_name ? _C_name : "C";
 
        if (*_RWSTD_CAT_SEP == *locname)
            ++locname;
 
        // find the first category separator (if any) and compute
        // the length of the name of the first category's locale
        // (don't bother when combined locales don't exist, i.e.,
        // when no locale separator is defined)
        const char* next =
            *_RWSTD_CAT_SEP ? strchr (locname, *_RWSTD_CAT_SEP) : 0;
 
        size_t loclen = next ? next - locname : strlen (locname);
 
        // iterate over all standard facets, comparing the name of the
        // locale each comes from with the name of the category encoded
        // in the locale name for equality; a mismatch indicates that
        // the locale is not managed
        for (size_t i = 0, catinx = 0; i != _C_n_std_facets; ++i) {
 
            if (0 == _C_std_facets [i]) {
                // skip facets that are not installed
                continue;
            }
 
            const __rw_facet::_C_facet_type facet_type =
                _C_get_facet_type (*_C_std_facets [i]);
 
            switch (facet_type) {
            case __rw_facet::_C_money_get:
            case __rw_facet::_C_money_put:
            case __rw_facet::_C_num_get:
            case __rw_facet::_C_num_put:
            case __rw_facet::_C_wmoney_get:
            case __rw_facet::_C_wmoney_put:
            case __rw_facet::_C_wnum_get:
            case __rw_facet::_C_wnum_put:
                // skip facets with no _byname forms
                continue;
            default:
                break;
            }
 
            // iterate through the names of categories in the combined
            // locale name looking for one that the facet belongs to
            while (next && !(__rw_cats [catinx].facet_bits & (1 << i))) {
 
                if (*next) {
                    // advance past the category separator to the name
                    // of the next category in the (potentially combined)
                    // locale name
                    _RWSTD_ASSERT (*next == *_RWSTD_CAT_SEP);
 
                   locname = ++next;
                    ++catinx;
                }
                else {
                    // reset to the name of the first category
                    locname = _C_name ? _C_name : "C";
                    catinx  = 0;
                }
 
                // skip over the category separator
                if (*_RWSTD_CAT_SEP == *locname)
                    ++locname;
 
                next = strchr (locname, *_RWSTD_CAT_SEP);
                if (next)
                    loclen = next - locname;
                else {
                    loclen = strlen (locname);
                    next   = "";
                }
            }
 
            // get the facet name (or "C" if null)
            const char* const facet_name =
                _C_std_facets [i]->_C_get_name ();
 
            _RWSTD_ASSERT (0 != facet_name);
            _RWSTD_ASSERT (0 != locname);
 
            // mismatch indicates a combined category
            if (   strlen (facet_name) != loclen
                || memcmp (locname, facet_name, loclen)) {
                // locales with heterogeneous categories are not managed
                return false;
            }
        }
 
        // locales with all heterogeneous categories are managed
        return true;
    }
 
    // in order for the entire category to be considered globally managed,
    // all its facets must come from the same (named or unnamed) locale
    // i.e., if the LC_CTYPE category contains codecvt from "de_DE" and
    // ctype from "en_US", the category is not considered globally managed
    // because it doesn't have a unambiguous name
    const int bits = _C_LC2facet_bits (cat);
 
    const int std_bits = bits & int (_C_std_facet_bits);
 
    if (std_bits ? bits == std_bits
                 : bits == (bits & int (_C_byname_facet_bits)))
        return true;
 
    return false;
}
 
 
}   // namespace __rw
 
 
 
#include <memory>
#include <loc/_locale.h>
 
#include <rw/_defs.h>
 
 
_RWSTD_NAMESPACE (std) { 
 
 
const locale&
locale::
operator= (const locale &rhs) _THROWS (())
{
    // copy body and bump up a ref count in `rhs'
    _RW::__rw_locale* const body = rhs._C_body;
 
    _RWSTD_ATOMIC_PREINCREMENT (rhs._C_body->_C_ref, false);
 
 
    // _C_body is never 0 except in objects still being constructed by
    // the combining ctor locale::locale<Facet>(const locale&, Facet*)
 
    if (_C_body) {
        // dispose of old body (dtor decrements ref count and possibly deletes)
        locale destroy (*_C_body);
 
        _RWSTD_UNUSED (destroy);
    }
 
    // assign new body
    _C_body = body;
 
    return *this;
}
 
 
}   // namespace std