/*
 * Copyright (c) 1999
 * Silicon Graphics Computer Systems, Inc.
 *
 * Copyright (c) 1999 
 * Boris Fomitchev
 *
 * This material is provided "as is", with absolutely no warranty expressed
 * or implied. Any use is at your own risk.
 *
 * Permission to use or copy this software for any purpose is hereby granted 
 * without fee, provided the above notices are retained on all copies.
 * Permission to modify the code and to distribute modified code is granted,
 * provided the above notices are retained, and a notice that the code was
 * modified is included with the above copyright notice.
 *
 */ 
# include "stlport_prefix.h"

// #include <locale>
#include <hash_map>
#include "locale_impl.h"
#include "c_locale.h"

#include "locale_nonclassic.h"


#include <stl/_codecvt.h>
#include <stl/_collate.h>
#include <stl/_ctype.h>
#include <stl/_monetary.h>
#include <stl/_time_facets.h>
#include <stl/_messages_facets.h>
#include <stl/_istream.h>
#include <stl/_num_get.h>
#include <stl/_num_put.h>


_STLP_BEGIN_NAMESPACE

// those wrappers are needed to avoid extern "C"

 void* _Loc_ctype_create(const char * s)
  { return (void*)_Locale_ctype_create(s); }
 void* _Loc_numeric_create(const char * s)
  { return (void*)_Locale_numeric_create(s); }
 void* _Loc_time_create(const char * s)
  { return (void*)_Locale_time_create(s); }
 void* _Loc_collate_create(const char * s)
  { return (void*)_Locale_collate_create(s); }
 void* _Loc_monetary_create(const char * s)
  { return (void*)_Locale_monetary_create(s); }
 void* _Loc_messages_create(const char * s)
  { return (void*)_Locale_messages_create(s); }

 char* _Loc_ctype_name(const void* l, char* s)
  { return _Locale_ctype_name(l, s); }
 char* _Loc_numeric_name(const void* l, char* s)
  { return _Locale_numeric_name(l, s); }
 char* _Loc_time_name(const void* l, char* s)
  { return _Locale_time_name(l,s); }
 char* _Loc_collate_name( const void* l, char* s)
  { return _Locale_collate_name(l,s); }
 char* _Loc_monetary_name(const void* l, char* s)
  { return _Locale_monetary_name(l,s); }
 char* _Loc_messages_name(const void* l, char* s)
  { return _Locale_messages_name(l,s); }

 const char* _Loc_ctype_default(char* p)    { return _Locale_ctype_default(p); }
 const char* _Loc_numeric_default(char * p) { return _Locale_numeric_default(p); }
 const char* _Loc_time_default(char* p)     { return _Locale_time_default(p); }
 const char* _Loc_collate_default(char* p)  { return _Locale_collate_default(p); }
 const char* _Loc_monetary_default(char* p) { return _Locale_monetary_default(p); }
 const char* _Loc_messages_default(char* p) { return _Locale_messages_default(p); }

 void _Loc_ctype_destroy(void* p)    {_Locale_ctype_destroy(p); }
 void _Loc_numeric_destroy(void* p)  {_Locale_numeric_destroy(p); }
 void _Loc_time_destroy(void* p)     {_Locale_time_destroy(p);}
 void _Loc_collate_destroy(void* p)  {_Locale_collate_destroy(p);}
 void _Loc_monetary_destroy(void* p) {_Locale_monetary_destroy(p);}
 void _Loc_messages_destroy(void* p) {_Locale_messages_destroy(p);}

typedef void* (*loc_create_func_t)(const char *);
typedef char* (*loc_name_func_t)(const void* l, char* s);
typedef void (*loc_destroy_func_t)(void* l);
typedef const char* (*loc_default_name_func_t)(char* s);

//----------------------------------------------------------------------
// Acquire and release low-level category objects.  The whole point of
// this is so that we don't allocate (say) four different _Locale_ctype
// objects for a single locale.

struct __eqstr {
  bool operator()(const char* s1, const char* s2) const
    { return strcmp(s1, s2) == 0; }
};

struct __ptr_hash {
  size_t operator()(const void* p) const
    { return __REINTERPRET_CAST(size_t,p); }
};

template <class _Category_ptr>
struct __destroy_fun {
  typedef void (*_fun_type)(_Category_ptr);
  _fun_type _M_fun;
  __destroy_fun(_fun_type __f) : _M_fun(__f) {}
  void operator()(_Category_ptr __c) { _M_fun(__c); }  
};

// Global hash tables for category objects.
typedef hash_map<const char*, pair<void*, size_t>, hash<const char*>, __eqstr> Category_Map;

// Look up a category by name
static hash_map<const char*, pair<void*, size_t>, hash<const char*>, __eqstr>* ctype_hash;
static hash_map<const char*, pair<void*, size_t>, hash<const char*>, __eqstr>* numeric_hash;
static hash_map<const char*, pair<void*, size_t>, hash<const char*>, __eqstr>* time_hash;
static hash_map<const char*, pair<void*, size_t>, hash<const char*>, __eqstr>* collate_hash;
static hash_map<const char*, pair<void*, size_t>, hash<const char*>, __eqstr>* monetary_hash;
static hash_map<const char*, pair<void*, size_t>, hash<const char*>, __eqstr>* messages_hash;

// We have a single lock for all of the hash tables.  We may wish to 
// replace it with six different locks.
/* REFERENCED */
_STLP_STATIC_MUTEX __category_hash_lock _STLP_MUTEX_INITIALIZER;

static void*
__acquire_category(const char* name, loc_create_func_t create_obj,
                   loc_default_name_func_t default_obj, Category_Map ** M)
{
  typedef Category_Map::iterator Category_iterator;
  pair<Category_iterator, bool> result;
  _STLP_auto_lock sentry(__category_hash_lock);

  typedef const char* key_type; 
  pair<const key_type, pair<void*,size_t> > __e(name, pair<void*,size_t>((void*)0,size_t(0)));

  if (!*M)
    *M = new Category_Map();

#if defined(__SC__)		//*TY 06/01/2000 - added workaround for SCpp
  if(!*M) delete *M;	//*TY 06/01/2000 - it forgets to generate dtor for Category_Map class. This fake code forces to generate one.
#endif					//*TY 06/01/2000 - 

  // Find what name to look for.  Be careful if user requests the default.
  char buf[_Locale_MAX_SIMPLE_NAME];
  if (name == 0 || name[0] == 0)
    name = default_obj(buf);
  if (name == 0 || name[0] == 0)
    name = "C";

  // Look for an existing entry with that name.

  result = (*M)->insert_noresize(__e);

  // There was no entry in the map already.  Create the category.
  if (result.second) 
    (*result.first).second.first = create_obj(name);

  // Increment the reference count.
  ++((*result.first).second.second);

  return (*result.first).second.first;
}


static void 
__release_category(void* cat,
                 loc_destroy_func_t destroy_fun,
                 loc_name_func_t get_name,
                 Category_Map* M)
{
  _STLP_auto_lock sentry(__category_hash_lock);

  if (cat && M) {
    // Find the name of the category object.
    char buf[_Locale_MAX_SIMPLE_NAME + 1];
    char* name = get_name(cat, buf);

    if (name != 0) {
      Category_Map::iterator it = M->find(name);
      if (it != M->end()) {
        // Decrement the ref count.  If it goes to zero, delete this category
        // from the map.
        if (--((*it).second.second) == 0) {
          void* cat1 = (*it).second.first;
          destroy_fun(cat1);
          M->erase(it);
        }
      }
    }
  }
}

_Locale_ctype* _STLP_CALL __acquire_ctype(const char* name)
{ return __REINTERPRET_CAST(_Locale_ctype*,
                            __acquire_category(name, _Loc_ctype_create, _Loc_ctype_default, &ctype_hash)); }
_Locale_numeric* _STLP_CALL __acquire_numeric(const char* name)
{ return __REINTERPRET_CAST(_Locale_numeric*,
                            __acquire_category(name, _Loc_numeric_create, _Loc_numeric_default, &numeric_hash)); }
_Locale_time* _STLP_CALL __acquire_time(const char* name)
{ return __REINTERPRET_CAST(_Locale_time*,
                            __acquire_category(name, _Loc_time_create, _Loc_time_default, &time_hash)); }
_Locale_collate* _STLP_CALL __acquire_collate(const char* name)
{ return __REINTERPRET_CAST(_Locale_collate*,
                            __acquire_category(name, _Loc_collate_create, _Loc_collate_default, &collate_hash)); }
_Locale_monetary* _STLP_CALL __acquire_monetary(const char* name)
{ return __REINTERPRET_CAST(_Locale_monetary*,
                            __acquire_category(name, _Loc_monetary_create, _Loc_monetary_default, &monetary_hash)); }
_Locale_messages* _STLP_CALL __acquire_messages(const char* name)
{ return __REINTERPRET_CAST(_Locale_messages*,
                            __acquire_category(name, _Loc_messages_create, _Loc_messages_default, &messages_hash)); }

void  _STLP_CALL __release_ctype(_Locale_ctype* cat) {
  __release_category(cat, _Loc_ctype_destroy, _Loc_ctype_name, ctype_hash);
}
void _STLP_CALL __release_numeric(_Locale_numeric* cat) {
  __release_category(cat, _Loc_numeric_destroy, _Loc_numeric_name, numeric_hash);
}
void _STLP_CALL __release_time(_Locale_time* cat) {
  __release_category(cat, _Loc_time_destroy, _Loc_time_name, time_hash);
}
void _STLP_CALL __release_collate(_Locale_collate* cat) {
  __release_category(cat, _Loc_collate_destroy, _Loc_collate_name, collate_hash);
}
void _STLP_CALL __release_monetary(_Locale_monetary* cat) {
  __release_category(cat, _Loc_monetary_destroy, _Loc_monetary_name, monetary_hash);
}
void _STLP_CALL __release_messages(_Locale_messages* cat) {
  __release_category(cat, _Loc_messages_destroy, _Loc_messages_name, messages_hash);
}


//
// <locale> content which is dependent on the name 
//

template <class Facet>
inline locale::facet* 
_Locale_insert(_Locale* __that, Facet* f) {
  return __that->insert(f, Facet::id._M_index, false);
}

// Give L a name where all facets except those in category c
// are taken from name1, and those in category c are taken from name2.
void _Stl_loc_combine_names(_Locale* L,
                   const char* name1, const char* name2,
                   locale::category c)
{
  if ((c & locale::all) == 0 || strcmp(name1, name2) == 0)
    L->name = name1;
  else if ((c & locale::all) == locale::all)
    L->name = name2;
  else {
    // Decompose the names.
    char ctype_buf[_Locale_MAX_SIMPLE_NAME];
    char numeric_buf[_Locale_MAX_SIMPLE_NAME];
    char time_buf[_Locale_MAX_SIMPLE_NAME];
    char collate_buf[_Locale_MAX_SIMPLE_NAME];
    char monetary_buf[_Locale_MAX_SIMPLE_NAME];
    char messages_buf[_Locale_MAX_SIMPLE_NAME];

    _Locale_extract_ctype_name((c & locale::ctype) ? name2 : name1,
                               ctype_buf); 
    _Locale_extract_numeric_name((c & locale::numeric) ? name2 : name1,
                                 numeric_buf); 
    _Locale_extract_time_name((c & locale::time) ? name2 : name1,
                              time_buf); 
    _Locale_extract_collate_name((c & locale::collate) ? name2 : name1,
                                 collate_buf); 
    _Locale_extract_monetary_name((c & locale::monetary) ? name2 : name1,
                                  monetary_buf); 
    _Locale_extract_messages_name((c & locale::messages) ? name2 : name1,
                                  messages_buf); 
    
    // Construct a new composite name.
    char composite_buf[_Locale_MAX_COMPOSITE_NAME];
    _Locale_compose_name(composite_buf,
                         ctype_buf, numeric_buf, time_buf,
                         collate_buf, monetary_buf, messages_buf,
                         name1);
    L->name = composite_buf;
  }
}


// Create a locale from a name.
locale::locale(const char* name)
  : _M_impl(0)
{
  if (!name)
    _M_throw_runtime_error(0);

  _Locale* impl = 0;

  _STLP_TRY {
    impl = new _Locale(locale::id::_S_max, name);

    // Insert categories one at a time.
    impl->insert_ctype_facets(name);
    impl->insert_numeric_facets(name);
    impl->insert_time_facets(name);
    impl->insert_collate_facets(name);
    impl->insert_monetary_facets(name);
    impl->insert_messages_facets(name);
    // reassign impl
    _M_impl = impl;
  }
  _STLP_UNWIND(delete impl);
}

// Create a locale that's a copy of L, except that all of the facets
// in category c are instead constructed by name.
locale::locale(const locale& L, const char* name, locale::category c)
  : _M_impl(0)
{
  if (name == 0 || strcmp(name, "*") == 0)
    _M_throw_runtime_error(name);

  _Locale* impl = 0;

  _STLP_TRY {
    impl = new _Locale(*L._M_impl);
    _Stl_loc_combine_names(impl, L._M_impl->name.c_str(), name, c);

    if (c & locale::ctype)
      impl->insert_ctype_facets(name);
    if (c & locale::numeric)
      impl->insert_numeric_facets(name);
    if (c & locale::time)
      impl->insert_time_facets(name);
    if (c & locale::collate)
      impl->insert_collate_facets(name);
    if (c & locale::monetary)
      impl->insert_monetary_facets(name);
    if (c & locale::messages)
      impl->insert_messages_facets(name);
    _M_impl = impl;
  }
  _STLP_UNWIND(delete impl)

}

// Contruct a new locale where all facets that aren't in category c
// come from L1, and all those that are in category c come from L2.
locale::locale(const locale& L1, const locale& L2, category c)
  : _M_impl(0)
{
  _Locale* impl = new _Locale(*L1._M_impl);
  
  _Locale_impl* i2 = L2._M_impl;

  static string nameless("*");
  if (L1.name() != nameless && L2.name() != nameless)
    _Stl_loc_combine_names(impl,
                  L1._M_impl->name.c_str(), L2._M_impl->name.c_str(),
                  c);
  else {
    impl->name = "*";
  }

  if (c & collate) {
    impl->insert( i2, _STLP_STD::collate<char>::id);
# ifndef _STLP_NO_WCHAR_T
    impl->insert( i2, _STLP_STD::collate<wchar_t>::id);
# endif
  }
  if (c & ctype) {
    impl->insert( i2, _STLP_STD::ctype<char>::id);
    impl->insert( i2, _STLP_STD::codecvt<char, char, mbstate_t>::id);
# ifndef _STLP_NO_WCHAR_T
    impl->insert( i2, _STLP_STD::ctype<wchar_t>::id);
    impl->insert( i2, _STLP_STD::codecvt<wchar_t, char, mbstate_t>::id);
# endif
  }
  if (c & monetary) {
    impl->insert( i2, _STLP_STD::moneypunct<char, true>::id);
    impl->insert( i2, _STLP_STD::moneypunct<char, false>::id);
    impl->insert( i2, _STLP_STD::money_get<char, istreambuf_iterator<char, char_traits<char> > >::id);
    impl->insert( i2, _STLP_STD::money_put<char, ostreambuf_iterator<char, char_traits<char> > >::id);
# ifndef _STLP_NO_WCHAR_T
    impl->insert( i2, _STLP_STD::moneypunct<wchar_t, true>::id);
    impl->insert( i2, _STLP_STD::moneypunct<wchar_t, false>::id);
    impl->insert( i2, _STLP_STD::money_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id);
    impl->insert( i2, _STLP_STD::money_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id);
# endif
  }
  if (c & numeric) {
    impl->insert( i2, _STLP_STD::numpunct<char>::id);
    impl->insert( i2, _STLP_STD::num_get<char, istreambuf_iterator<char, char_traits<char> > >::id);
    impl->insert( i2, _STLP_STD::num_put<char, ostreambuf_iterator<char, char_traits<char> > >::id);
# ifndef _STLP_NO_WCHAR_T
    impl->insert( i2, _STLP_STD::numpunct<wchar_t>::id);
    impl->insert( i2, num_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id);
    impl->insert( i2, num_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id);
# endif
  }
  if (c & time) {
    impl->insert( i2, _STLP_STD::time_get<char, istreambuf_iterator<char, char_traits<char> > >::id);
    impl->insert( i2, _STLP_STD::time_put<char, ostreambuf_iterator<char, char_traits<char> > >::id);
# ifndef _STLP_NO_WCHAR_T
    impl->insert( i2, _STLP_STD::time_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id);
    impl->insert( i2, _STLP_STD::time_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id);
# endif
  }
  if (c & messages) {
    impl->insert( i2, _STLP_STD::messages<char>::id);
# ifndef _STLP_NO_WCHAR_T
    impl->insert( i2, _STLP_STD::messages<wchar_t>::id);
# endif
  }
  _M_impl = impl;
}

// Six functions, one for each category.  Each of them takes a 
// _Locale* and a name, constructs that appropriate category
// facets by name, and inserts them into the locale.  

void _Locale::insert_ctype_facets(const char* pname)
{
  char buf[_Locale_MAX_SIMPLE_NAME];
  _Locale_impl* i2 = locale::classic()._M_impl;

  if (pname == 0 || pname[0] == 0)
    pname = _Locale_ctype_default(buf);

  if (pname == 0 || pname[0] == 0 || strcmp(pname, "C") == 0) {
    this->insert(i2, ctype<char>::id);
# ifndef _STLP_NO_MBSTATE_T
    this->insert(i2, codecvt<char, char, mbstate_t>::id);
# endif
# ifndef _STLP_NO_WCHAR_T
    this->insert(i2, ctype<wchar_t>::id);
# ifndef _STLP_NO_MBSTATE_T
    this->insert(i2, codecvt<wchar_t, char, mbstate_t>::id);
# endif
# endif
  }
  else {
    ctype<char>*    ct                      = 0;
# ifndef _STLP_NO_MBSTATE_T
    codecvt<char, char, mbstate_t>*    cvt  = 0;
# endif
# ifndef _STLP_NO_WCHAR_T
    ctype<wchar_t>* wct                     = 0;
    codecvt<wchar_t, char, mbstate_t>* wcvt = 0;
# endif
    _STLP_TRY {
      ct   = new ctype_byname<char>(pname);
# ifndef _STLP_NO_MBSTATE_T
      cvt  = new codecvt_byname<char, char, mbstate_t>(pname);
# endif
# ifndef _STLP_NO_WCHAR_T
      wct  = new ctype_byname<wchar_t>(pname); 
      wcvt = new codecvt_byname<wchar_t, char, mbstate_t>(pname);
# endif
    }
    
# ifndef _STLP_NO_WCHAR_T
#  ifdef _STLP_NO_MBSTATE_T
    _STLP_UNWIND(delete ct; delete wct; delete wcvt);
#  else
    _STLP_UNWIND(delete ct; delete wct; delete cvt; delete wcvt);
#  endif
# else
#  ifdef _STLP_NO_MBSTATE_T
    _STLP_UNWIND(delete ct);
#  else
    _STLP_UNWIND(delete ct; delete cvt);
#  endif
# endif    
    _Locale_insert(this, ct);
#  ifndef _STLP_NO_MBSTATE_T
    _Locale_insert(this, cvt);
#  endif
#  ifndef _STLP_NO_WCHAR_T
    _Locale_insert(this, wct);
    _Locale_insert(this, wcvt);
#  endif
  }
}

void _Locale::insert_numeric_facets(const char* pname)
{
  _Locale_impl* i2 = locale::classic()._M_impl;

  numpunct<char>*    punct  = 0;
  num_get<char, istreambuf_iterator<char, char_traits<char> > >*     get    = 0;
  num_put<char, ostreambuf_iterator<char, char_traits<char> > >*     put    = 0;
# ifndef _STLP_NO_WCHAR_T
  numpunct<wchar_t>* wpunct = 0;
  num_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >*  wget   = 0;
  num_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >*  wput   = 0;
# endif

  char buf[_Locale_MAX_SIMPLE_NAME];
  if (pname == 0 || pname[0] == 0)
    pname = _Locale_numeric_default(buf);

  if (pname == 0 || pname[0] == 0 || strcmp(pname, "C") == 0) {
    this->insert(i2, numpunct<char>::id);
    this->insert(i2, 
		 num_put<char, ostreambuf_iterator<char, char_traits<char> >  >::id);
    this->insert(i2, 
		 num_get<char, istreambuf_iterator<char, char_traits<char> > >::id);
# ifndef _STLP_NO_WCHAR_T
    this->insert(i2, numpunct<wchar_t>::id);
    this->insert(i2, 
		 num_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> >  >::id);
    this->insert(i2, 
		 num_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id);
# endif
  }
  else {
    _STLP_TRY {
      punct  = new numpunct_byname<char>(pname);
      get    = new num_get<char, istreambuf_iterator<char, char_traits<char> > >;
      put    = new num_put<char, ostreambuf_iterator<char, char_traits<char> > >;
# ifndef _STLP_NO_WCHAR_T
      wpunct = new numpunct_byname<wchar_t>(pname);
      wget   = new num_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >;
      wput   = new num_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >;
# endif
    }
# ifndef _STLP_NO_WCHAR_T
    _STLP_UNWIND(delete punct; delete wpunct; delete get; delete wget;
    delete put; delete wput);
# else
    _STLP_UNWIND(delete punct; delete get;delete put);
# endif
    
  _Locale_insert(this,punct);
  _Locale_insert(this,get);
  _Locale_insert(this,put);

# ifndef _STLP_NO_WCHAR_T
  _Locale_insert(this,wpunct);
  _Locale_insert(this,wget);
  _Locale_insert(this,wput);
# endif
  }
}

void _Locale::insert_time_facets(const char* pname)
{
  _Locale_impl* i2 = locale::classic()._M_impl;
  time_get<char, istreambuf_iterator<char, char_traits<char> > >*    get  = 0;
  time_put<char, ostreambuf_iterator<char, char_traits<char> > >*    put  = 0;
# ifndef _STLP_NO_WCHAR_T
  time_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >* wget = 0;
  time_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >* wput = 0;
# endif

  char buf[_Locale_MAX_SIMPLE_NAME];
  if (pname == 0 || pname[0] == 0)
    pname = _Locale_time_default(buf);
  
  if (pname == 0 || pname[0] == 0 || strcmp(pname, "C") == 0) {

    this->insert(i2, 
		 time_get<char, istreambuf_iterator<char, char_traits<char> > >::id);
    this->insert(i2, 
		 time_put<char, ostreambuf_iterator<char, char_traits<char> > >::id);
# ifndef _STLP_NO_WCHAR_T
    this->insert(i2,
		 time_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id);
    this->insert(i2,
		 time_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id);
# endif
  }
  else {
    _STLP_TRY {
      get  = new time_get_byname<char, istreambuf_iterator<char, char_traits<char> > >(pname);
      put  = new time_put_byname<char, ostreambuf_iterator<char, char_traits<char> > >(pname);
# ifndef _STLP_NO_WCHAR_T
      wget = new time_get_byname<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >(pname);
      wput = new time_put_byname<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >(pname);
# endif
    }
# ifndef _STLP_NO_WCHAR_T
    _STLP_UNWIND(delete get; delete wget; delete put; delete wput);
# else
    _STLP_UNWIND(delete get; delete put);
# endif
    _Locale_insert(this,get);
    _Locale_insert(this,put);
# ifndef _STLP_NO_WCHAR_T
    _Locale_insert(this,wget);
    _Locale_insert(this,wput);
# endif
  }
}

void _Locale::insert_collate_facets(const char* nam)
{
  _Locale_impl* i2 = locale::classic()._M_impl;

  collate<char>*    col  = 0;
# ifndef _STLP_NO_WCHAR_T
  collate<wchar_t>* wcol = 0;
# endif

  char buf[_Locale_MAX_SIMPLE_NAME];
  if (nam == 0 || nam[0] == 0)
    nam = _Locale_collate_default(buf);

  if (nam == 0 || nam[0] == 0 || strcmp(nam, "C") == 0) {
    this->insert(i2, collate<char>::id);
# ifndef _STLP_NO_WCHAR_T
    this->insert(i2, collate<wchar_t>::id);
# endif
  }
  else {
    _STLP_TRY {
      col   = new collate_byname<char>(nam);
# ifndef _STLP_NO_WCHAR_T
      wcol  = new collate_byname<wchar_t>(nam); 
# endif
    }
# ifndef _STLP_NO_WCHAR_T
    _STLP_UNWIND(delete col; delete wcol);
# else
    _STLP_UNWIND(delete col);
# endif
    _Locale_insert(this,col);
# ifndef _STLP_NO_WCHAR_T
    _Locale_insert(this,wcol);
# endif
  }
}

void _Locale::insert_monetary_facets(const char* pname)
{
  _Locale_impl* i2 = locale::classic()._M_impl;

  moneypunct<char,    false>* punct   = 0;
  moneypunct<char,    true>*  ipunct  = 0;
  money_get<char, istreambuf_iterator<char, char_traits<char> > >*            get     = 0;
  money_put<char, ostreambuf_iterator<char, char_traits<char> > >*            put     = 0;

# ifndef _STLP_NO_WCHAR_T
  moneypunct<wchar_t, false>* wpunct  = 0;
  moneypunct<wchar_t, true>*  wipunct = 0;
  money_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >*         wget    = 0;
  money_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >*         wput    = 0;
# endif

  char buf[_Locale_MAX_SIMPLE_NAME];
  if (pname == 0 || pname[0] == 0)
    pname = _Locale_monetary_default(buf);

  if (pname == 0 || pname[0] == 0 || strcmp(pname, "C") == 0) {
    this->insert(i2, moneypunct<char, false>::id);
    this->insert(i2, moneypunct<char, true>::id);
    this->insert(i2, money_get<char, istreambuf_iterator<char, char_traits<char> > >::id);
    this->insert(i2, money_put<char, ostreambuf_iterator<char, char_traits<char> > >::id);
# ifndef _STLP_NO_WCHAR_T
    this->insert(i2, moneypunct<wchar_t, false>::id);
    this->insert(i2, moneypunct<wchar_t, true>::id);
    this->insert(i2, money_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id);
    this->insert(i2, money_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id);
# endif
  }
  else {    
    _STLP_TRY {
      punct   = new moneypunct_byname<char, false>(pname);
      ipunct  = new moneypunct_byname<char, true>(pname);
      get     = new money_get<char, istreambuf_iterator<char, char_traits<char> > >;
      put     = new money_put<char, ostreambuf_iterator<char, char_traits<char> > >;
# ifndef _STLP_NO_WCHAR_T
      wpunct  = new moneypunct_byname<wchar_t, false>(pname);
      wipunct = new moneypunct_byname<wchar_t, true>(pname);
      wget    = new money_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >;
      wput    = new money_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >;
# endif
    }
# ifndef _STLP_NO_WCHAR_T
    _STLP_UNWIND(delete punct; delete ipunct; delete wpunct; delete wipunct;
    delete get; delete wget; delete put; delete wput);
# else
    _STLP_UNWIND(delete punct; delete ipunct; delete get; delete put);
# endif
    _Locale_insert(this,punct);
    _Locale_insert(this,ipunct);
    _Locale_insert(this,get);
    _Locale_insert(this,put);
# ifndef _STLP_NO_WCHAR_T
    _Locale_insert(this,wget);
    _Locale_insert(this,wpunct);
    _Locale_insert(this,wipunct);
    _Locale_insert(this,wput);
# endif
  }
}


void _Locale::insert_messages_facets(const char* pname)
{
  _Locale_impl* i2 = locale::classic()._M_impl;
  messages<char>*    msg  = 0;
# ifndef _STLP_NO_WCHAR_T
  messages<wchar_t>* wmsg = 0;
# endif

  char buf[_Locale_MAX_SIMPLE_NAME];
  if (pname == 0 || pname[0] == 0)
    pname = _Locale_messages_default(buf);

  if (pname == 0 || pname[0] == 0 || strcmp(pname, "C") == 0) {
    this->insert(i2, messages<char>::id);
# ifndef _STLP_NO_WCHAR_T
    this->insert(i2, messages<wchar_t>::id);
# endif
  }
  else {
    _STLP_TRY {
      msg  = new messages_byname<char>(pname);
# ifndef _STLP_NO_WCHAR_T
      wmsg = new messages_byname<wchar_t>(pname);
# endif
    }
# ifndef _STLP_NO_WCHAR_T
    _STLP_UNWIND(delete msg; delete wmsg);
# else
    _STLP_UNWIND(delete msg);
# endif
    _Locale_insert(this,msg);
# ifndef _STLP_NO_WCHAR_T
    _Locale_insert(this,wmsg);
# endif
  }
}

_STLP_END_NAMESPACE