// xlocale internal header (from <locale>)
#ifndef _XLOCALE_
#define _XLOCALE_

#pragma info(none)
#ifndef __CHKHDR__
#  pragma report(level, E)
#endif
#pragma info(restore)

#if __IBMCPP__ < 400
#error This file to be used only with IBM VisualAge C++ v4 and later compilers.
#endif /* __IBMCPP__ */

#pragma namemangling(ansi)

   /********************************************************************/
   /*  <xlocale> header file                                           */
   /*                                                                  */
   /*  VisualAge C++, Version 4.0                                      */
   /*    Licensed Material - Property of IBM                           */
   /*                                                                  */
   /*  5801-AAR and Other Materials                                    */
   /*                                                                  */
   /*  (c) Copyright IBM Corp 1991, 1998. All rights reserved.         */
   /*                                                                  */
   /*                                                                  */
   /*  Licensed Materials.                                             */
   /*                                                                  */
   /*  Dinkum C++ Library                                              */
   /*  Copyright (c) 1998.  Licensed to IBM Corp. and its suppliers.   */
   /*                                                                  */
   /********************************************************************/

#include <climits>
#include <cstring>
#include <stdexcept>
#include <typeinfo>
#include <xlocinfo>

 #ifdef __TOS_AIX__
  #include </usr/include/stdlib.h>
  #ifndef __mbstate_t
   #define __mbstate_t
   #ifndef _AIX43
    typedef short mbstate_t;
   #endif /* _AIX43 */
  #endif
 #endif

_STD_BEGIN
		// CLASS locale
class _CXX_IMPORT locale {
public:
	enum _Category {collate = _M_COLLATE, ctype = _M_CTYPE,
		monetary = _M_MONETARY, numeric = _M_NUMERIC,
		time = _M_TIME, messages = _M_MESSAGE,
		all = _M_ALL, none = 0};
	typedef int category;
			// CLASS id
	class _CXX_IMPORT id {
	public:
		id(size_t _X = 0)
			: _Id(_X) {}
		operator size_t()
			{_Lockit _Lk(_LOCK_LOCALE);
			if (_Id == 0)
				_Id = ++_Id_cnt;
			return (_Id); }
	private:
		id(const id&);	// not defined
		id& operator=(const id&);	// not defined
		size_t _Id;
		static int _Id_cnt;
		};
	class _Locimp;
			// class facet
	class facet {
		friend class locale;
		friend class _Locimp;
	public:
		static size_t _Getcat(const facet **_Ppf = 0)
			{return ((size_t)(-1)); }
		void _Incref()
			{_Lockit _Lk(_LOCK_LOCALE);
			if (_Refs < (size_t)(-1))
				++_Refs; }
		facet *_Decref()
			{_Lockit _Lk(_LOCK_LOCALE);
			if (0 < _Refs && _Refs < (size_t)(-1))
				--_Refs;
			return (_Refs == 0 ? this : 0); }
//	_PROTECTED:
		virtual ~facet()
			{}
	protected:
		explicit facet(size_t _R = 0)
			: _Refs(_R) {}
	private:
		facet(const facet&);	// not defined
		facet& operator=(const facet&);	// not defined
		size_t _Refs;
		};
			// CLASS _Locimp
	class _CXX_IMPORT _Locimp : public facet {
	_PROTECTED:
		~_Locimp();
	private:
		friend class locale;
		_Locimp(bool _Xp = false);
		_Locimp(const _Locimp&);
		void _Addfac(facet *, size_t);
		static _Locimp *_Makeloc(const _Locinfo&,
			category, _Locimp *, const locale *);
		static void _Makewloc(const _Locinfo&,
			category, _Locimp *, const locale *);
		static void _Makexloc(const _Locinfo&,
			category, _Locimp *, const locale *);
		facet **_Fv;
		size_t _Nfv;
		category _Cat;
		bool _Xpar;
		string _Name;
		static _Locimp *_Clocptr, *_Global;
		};
	template<class _E, class _Tr, class _A>
		bool operator()(const basic_string<_E, _Tr, _A>&,
			const basic_string<_E, _Tr, _A>&) const;
	template<class _F>
		locale combine(const locale& _X) const;
	template<class _F>
		locale(const locale& _X, _F *_Fac)
			: _Ptr(new _Locimp(_X._Ptr))
		{if (_Fac != 0)
			{_Ptr->_Addfac(_Fac, _F::id);
			if (_F::_Getcat() != (size_t)(-1))
				_Ptr->_Cat = 0, _Ptr->_Name = "*"; }}
	locale() _THROW0()
		: _Ptr(_Init())
		{_Locimp::_Global->_Incref(); }
	locale(_Uninitialized)
		{}
	locale(const locale& _X) _THROW0()
		: _Ptr(_X._Ptr)
		{_Ptr->_Incref(); }
	locale(const locale&, const locale&, category);
	explicit locale(const char *, category = all);
	locale(const locale&, const char *, category);
	~locale() _THROW0()
		{if (_Ptr != 0)
			delete _Ptr->_Decref(); }
	locale& operator=(const locale& _X) _THROW0()
		{if (_Ptr != _X._Ptr)
			{delete _Ptr->_Decref();
			_Ptr = _X._Ptr;
			_Ptr->_Incref(); }
		return (*this); }
	string name() const
		{return (_Ptr->_Name); }
	const facet *_Getfacet(size_t _Id) const;
	bool operator==(const locale& _X) const;
	bool operator!=(const locale& _X) const
		{return (!(*this == _X)); }
	static const locale& classic();
	static locale global(const locale&);
	static locale empty();
private:
	locale(_Locimp *_P)
		: _Ptr(_P) {}
	static _Locimp *_Init();
	static void _Tidy();
	_Locimp *_Ptr;
	};
_BITMASK_OPS(locale::_Category)
		// SUPPORT TEMPLATES
template<class _F>
	class _Tidyfac {
public:
	static _F *_Save(_F *_Fac)
		{_Facsav = _Fac;
		_Facsav->_Incref();
		atexit(_Tidy);
		return (_Fac); }
	static void _Tidy()
		{if (_Facsav != 0)
			{delete _Facsav->_Decref();
			_Facsav = 0; }}
private:
	static _F *_Facsav;
	};
template<class _F>
	_F *_Tidyfac<_F>::_Facsav = 0;
 #define _ADDFAC(loc, pfac) locale(loc, pfac)
 #define _USEFAC(loc, fac)	use_facet<fac >(loc)
 #define _USE(loc, fac)		use_facet<fac >(loc)
template<class _F> inline
	const _F& use_facet(const locale& _L)
	{static const locale::facet *_Psave = 0;
	size_t _Id = _F::id;
	const locale::facet *_Pf = _L._Getfacet(_Id);
	if (_Pf != 0)
		;
	else if (_Psave != 0)
		_Pf = _Psave;
	else if (_F::_Getcat(&_Psave) != (size_t)(-1))
		_Pf = _Tidyfac<_F>::_Save((_F *)_Psave);
	else
		_THROW(bad_cast, "");
	return ((const _F&)(*_Pf)); }	// should be dynamic_cast
		// TEMPLATE FUNCTION _Narrow
#define _NARROW(T, V)	_Narrow(static_cast<T>(V))
template<class _E> inline
	int _Narrow(_E _C)	// needs _E::operator char()
	{return ((unsigned char)(char)_C); }
template<> inline int _Narrow(wchar_t _C)
	{return (wctob(_C)); }
		// TEMPLATE FUNCTION _Widen
#define _WIDEN(T, V)	_Widen(V, (T *)0)
template<class _E> inline
	_E _Widen(char _Ch, _E *)	// needs _E(char)
	{return (_Ch); }
template<> inline wchar_t _Widen(char _Ch, wchar_t *)
	{return (btowc(_Ch)); }
		// TEMPLATE FUNCTION _Getloctxt
template<class _E, class _II> inline
	int _Getloctxt(_II& _F, _II& _L, size_t _N,
		const _E *_S)
	{for (size_t _I = 0; _S[_I] != (_E)0; ++_I)
		if (_S[_I] == _S[0])
			++_N;
	string _Str(_N, '\0');
	int _Ans = -2;
	for (size_t _J = 1; ; ++_J, ++_F, _Ans = -1)
		{bool  _Pfx;
		size_t _I, _K;
		for (_I = 0, _K = 0, _Pfx = false; _K < _N; ++_K)
			{for (; _S[_I] != (_E)0 && _S[_I] != _S[0]; ++_I)
				;
			if (_Str[_K] != '\0')
				_I += _Str[_K];
			else if (_S[_I += _J] == _S[0] || _S[_I] == (_E)0)
				{_Str[_K] = _J < 127 ? _J : 127;
				_Ans = _K; }
			else if (_F == _L || _S[_I] != *_F)
				_Str[_K] = _J < 127 ? _J : 127;
			else
				_Pfx = true; }
		if (!_Pfx || _F == _L)
			break; }
	return (_Ans); }
		// TEMPLATE FUNCTION _Maklocstr
#define _MAKLOCSTR(T, S)	_Maklocstr(S, (T *)0)
template<class _E> inline
	_E *_Maklocstr(const char *_S, _E *)
	{size_t _L = strlen(_S) + 1;
	_E *_X = new _E[_L];
	for (_E *_P = _X; 0 < _L; --_L, ++_P, ++_S)
		if (_S != 0)
			*_P = _WIDEN(_E, *_S);
		else
			*_P = _WIDEN(_E, 0);
	return (_X); }
		// STRUCT codecvt_base
class _CXX_IMPORT codecvt_base : public locale::facet {
public:
	enum _Result {ok, partial, error, noconv};
	_BITMASK(_Result, result);
	codecvt_base(size_t _R = 0)
		: locale::facet(_R) {}
	bool always_noconv() const _THROW0()
		{return (do_always_noconv()); }
	int max_length() const _THROW0()
		{return (do_max_length()); }
	int encoding() const _THROW0()
		{return (do_encoding()); }
	~codecvt_base() {}
protected:
	virtual bool do_always_noconv() const _THROW0()
		{return (true); }
	virtual int do_max_length() const _THROW0()
		{return (1); }
	virtual int do_encoding() const _THROW0()
		{return (1); }
	};
_BITMASK_OPS(codecvt_base::_Result)
		// TEMPLATE CLASS codecvt
template<class _E, class _To, class _St>
class codecvt : public codecvt_base {
public:
	typedef _E intern_type;
	typedef _To extern_type;
	typedef _St state_type;
	result in(_St& _State,
		const _To *_F1, const _To *_L1, const _To *& _Mid1,
		_E *_F2, _E *_L2, _E *& _Mid2) const
		{return (do_in(_State,
			_F1, _L1, _Mid1, _F2, _L2, _Mid2)); }
	result out(_St& _State,
		const _E *_F1, const _E *_L1, const _E *& _Mid1,
		_To *_F2, _To *_L2, _To *& _Mid2) const
		{return (do_out(_State,
			_F1, _L1, _Mid1, _F2, _L2, _Mid2)); }
	result unshift(_St& _State,
		_To *_F2, _To *_L2, _To *& _Mid2) const
		{return (do_unshift(_State,
			_F2, _L2, _Mid2)); }
	int length(_St& _State, const _To *_F1,
		const _To *_L1, size_t _N2) const _THROW0()
		{return (do_length(_State, _F1, _L1, _N2)); }
	static locale::id id;
	explicit codecvt(size_t _R = 0)
		: codecvt_base(_R) {_Init(_Locinfo()); }
	codecvt(const _Locinfo& _Lobj, size_t _R = 0)
		: codecvt_base(_R) {_Init(_Lobj); }
	static size_t _Getcat(const locale::facet **_Ppf = 0)
		{if (_Ppf != 0 && *_Ppf == 0)
			*_Ppf = new codecvt<_E, _To, _St>;
		return (_X_CTYPE); }
_PROTECTED:
	virtual ~codecvt()
		{};
protected:
	void _Init(const _Locinfo& _Lobj)
		{_Cvt = _Lobj._Getcvt(); }
	virtual result do_in(_St& _State,
		const _To *_F1, const _To *, const _To *& _Mid1,
		_E *_F2, _E *, _E *& _Mid2) const
		{_Mid1 = _F1, _Mid2 = _F2;
		return (noconv); }
	virtual result do_out(_St& _State,
		const _E *_F1, const _E *, const _E *& _Mid1,
		_To *_F2, _To *, _To *& _Mid2) const
		{_Mid1 = _F1, _Mid2 = _F2;
		return (noconv); }
	virtual result do_unshift(_St& _State,
		_To *_F2, _To *_L2, _To *& _Mid2) const
		{return (noconv); }
	virtual int do_length(_St& _State, const _To *_F1,
		const _To *_L1, size_t _N2) const _THROW0()
		{return (_N2 < _L1 - _F1 ? _N2 : _L1 - _F1); }
private:
	_Locinfo::_Cvtvec _Cvt;
	};
template<class _E, class _To, class _St>
	locale::id codecvt<_E, _To, _St>::id;
		// CLASS codecvt<wchar_t, char, mbstate_t>
template<>
class _CXX_IMPORT codecvt<wchar_t, char, mbstate_t>
	: public codecvt_base {
public:
	typedef wchar_t _E;
	typedef char _To;
	typedef mbstate_t _St;
	typedef _E intern_type;
	typedef _To extern_type;
	typedef _St state_type;
	result in(_St& _State,
		const _To *_F1, const _To *_L1, const _To *& _Mid1,
		_E *_F2, _E *_L2, _E *& _Mid2) const
		{return (do_in(_State,
			_F1, _L1, _Mid1, _F2, _L2, _Mid2)); }
	result out(_St& _State,
		const _E *_F1, const _E *_L1, const _E *& _Mid1,
		_To *_F2, _To *_L2, _To *& _Mid2) const
		{return (do_out(_State,
			_F1, _L1, _Mid1, _F2, _L2, _Mid2)); }
	result unshift(_St& _State,
		_To *_F2, _To *_L2, _To *& _Mid2) const
		{return (do_unshift(_State,
			_F2, _L2, _Mid2)); }
	int length(_St& _State, const _To *_F1,
		const _To *_L1, size_t _N2) const _THROW0()
		{return (do_length(_State, _F1, _L1, _N2)); }
	static locale::id id;
	explicit codecvt(size_t _R = 0)
		: codecvt_base(_R) {_Init(_Locinfo()); }
	codecvt(const _Locinfo& _Lobj, size_t _R = 0)
		: codecvt_base(_R) {_Init(_Lobj); }
	static size_t _Getcat(const locale::facet **_Ppf = 0)
		{if (_Ppf != 0 && *_Ppf == 0)
			*_Ppf = new codecvt<_E, _To, _St>;
		return (_X_CTYPE); }
_PROTECTED:
	virtual ~codecvt()
		{};
protected:
	void _Init(const _Locinfo& _Lobj)
		{_Cvt = _Lobj._Getcvt(); }
	virtual result do_in(_St& _State,
		const _To *_F1, const _To *_L1, const _To *& _Mid1,
		_E *_F2, _E *_L2, _E *& _Mid2) const
		{_Mid1 = _F1, _Mid2 = _F2;
		result _Ans = _Mid1 == _L1 ? ok : partial;
		int _N;
		while (_Mid1 != _L1 && _Mid2 != _L2)
			switch (_N = _Mbrtowc(_Mid2, _Mid1, _L1 - _Mid1,
				&_State, &_Cvt))
			{case -2:
				_Mid1 = _L1;
				return (_Ans);
			case -1:
				return (error);
			case 0:
				_N = strlen(_Mid1) + 1;
			default:	// fall through
				_Mid1 += _N, ++_Mid2, _Ans = ok; }
		return (_Ans); }
	virtual result do_out(_St& _State,
		const _E *_F1, const _E *_L1, const _E *& _Mid1,
		_To *_F2, _To *_L2, _To *& _Mid2) const
		{_Mid1 = _F1, _Mid2 = _F2;
		result _Ans = _Mid1 == _L1 ? ok : partial;
		int _N;
		while (_Mid1 != _L1 && _Mid2 != _L2)
			if (MB_CUR_MAX <= _L2 - _Mid2)
				if ((_N = _Wcrtomb(_Mid2, *_Mid1,
					&_State, &_Cvt)) <= 0)
					return (error);
				else
					++_Mid1, _Mid2 += _N, _Ans = ok;
			else
				{_To _Buf[MB_LEN_MAX];
				_St _Stsave = _State;
				if ((_N = _Wcrtomb(_Buf, *_Mid1,
					&_State, &_Cvt)) <= 0)
					return (error);
				else if (_L2 - _Mid2 < _N)
					{_State = _Stsave;
					return (_Ans); }
				else
					{memcpy(_Mid2, _Buf, _N);
					++_Mid1, _Mid2 += _N, _Ans = ok; }}
		return (_Ans); }
	virtual result do_unshift(_St& _State,
		_To *_F2, _To *_L2, _To *& _Mid2) const
		{_Mid2 = _F2;
		result _Ans = ok;
		int _N;
		_To _Buf[MB_LEN_MAX];
		_St _Stsave = _State;
		if ((_N = _Wcrtomb(_Buf, L'\0', &_State, &_Cvt)) <= 0)
			_Ans = error;
		else if (_L2 - _Mid2 < --_N)
			{_State = _Stsave;
			_Ans = partial; }
		else if (0 < _N)
			{memcpy(_Mid2, _Buf, _N);
			_Mid2 += _N; }
		return (_Ans); }
	virtual int do_length(_St& _State, const _To *_F1,
		const _To *_L1, size_t _N2) const _THROW0()
		{int _N1;
		const _To *_Mid1;
		for (_N1 = 0, _Mid1 = _F1; _N1 < _N2 && _Mid1 != _L1; )
			{int _N;
			_E _Ch;
			switch (_N = _Mbrtowc(&_Ch, _Mid1, _L1 - _Mid1,
				&_State, &_Cvt))
			{case -2:
				return (_N1);
			case -1:
				return (_N1);
			case 0:
				_N = strlen(_Mid1) + 1;
			default:	// fall through
				_Mid1 += _N, ++_N1; }}
		return (_N1); }
	virtual bool do_always_noconv() const _THROW0()
		{return (false); }
	virtual int do_max_length() const _THROW0()
		{return (MB_LEN_MAX); }
	virtual int do_encoding() const _THROW0()
		{return (0); }
private:
	_Locinfo::_Cvtvec _Cvt;
	};
		// TEMPLATE CLASS codecvt_byname
template<class _E, class _To, class _St>
	class codecvt_byname : public codecvt<_E, _To, _St> {
public:
	explicit codecvt_byname(const char *_S, size_t _R = 0)
		: codecvt<_E, _To, _St>(_Locinfo(_S), _R) {}
_PROTECTED:
	virtual ~codecvt_byname()
		{}
	};
		// STRUCT ctype_base
struct ctype_base : public locale::facet {
	enum _Mask {alnum = _DI|_LO|_UP|_XA, alpha = _LO|_UP|_XA,
		cntrl = _BB, digit = _DI, graph = _DI|_LO|_PU|_UP|_XA,
		lower = _LO, print = _DI|_LO|_PU|_SP|_UP|_XA|_XD,
		punct = _PU, space = _CN|_SP|_XS, upper = _UP,
		xdigit = _XD};
//	_BITMASK(_Mask, mask);
	typedef short mask;	// to match <ctype.h>
	ctype_base(size_t _R = 0)
		: locale::facet(_R) {}
	~ctype_base() {}
	};
		// TEMPLATE CLASS ctype
template<class _E>
	class ctype : public ctype_base {
public:
	typedef _E char_type;
	bool is(mask _M, _E _C) const
		{return (do_is(_M, _C)); }
	const _E *is(const _E *_F, const _E *_L, mask *_V) const
		{return (do_is(_F, _L, _V)); }
	const _E *scan_is(mask _M, const _E *_F,
		const _E *_L) const
		{return (do_scan_is(_M, _F, _L)); }
	const _E *scan_not(mask _M, const _E *_F,
		const _E *_L) const
		{return (do_scan_not(_M, _F, _L)); }
	_E tolower(_E _C) const
		{return (do_tolower(_C)); }
	const _E *tolower(_E *_F, const _E *_L) const
		{return (do_tolower(_F, _L)); }
	_E toupper(_E _C) const
		{return (do_toupper(_C)); }
	const _E *toupper(_E *_F, const _E *_L) const
		{return (do_toupper(_F, _L)); }
	_E widen(char _X) const
		{return (do_widen(_X)); }
	const char *widen(const char *_F, const char *_L,
		_E *_V) const
		{return (do_widen(_F, _L, _V)); }
	char narrow(_E _C, char _D = '\0') const
		{return (do_narrow(_C, _D)); }
	const _E *narrow(const _E *_F, const _E *_L, char _D,
		char *_V) const
		{return (do_narrow(_F, _L, _D, _V)); }
	static locale::id id;
	explicit ctype(size_t _R = 0)
		: ctype_base(_R) {_Init(_Locinfo()); }
	ctype(const _Locinfo& _Lobj, size_t _R = 0)
		: ctype_base(_R) {_Init(_Lobj); }
	static size_t _Getcat(const locale::facet **_Ppf = 0)
		{if (_Ppf != 0 && *_Ppf == 0)
			*_Ppf = new ctype<_E>;
		return (_X_CTYPE); }
_PROTECTED:
	virtual ~ctype()
		{if (_Ctype._Delfl)
			free((void *)_Ctype._Table); }
protected:
	void _Init(const _Locinfo& _Lobj)
		{_Ctype = _Lobj._Getctype(); }
	virtual bool do_is(mask _M, _E _C) const
		{return ((_Ctype._Table[narrow(_C)] & _M) != 0); }
	virtual const _E *do_is(const _E *_F, const _E *_L,
		mask *_V) const
		{for (; _F != _L; ++_F, ++_V)
			*_V = _Ctype._Table[narrow(*_F)];
		return (_F); }
	virtual const _E *do_scan_is(mask _M, const _E *_F,
		const _E *_L) const
		{for (; _F != _L && !is(_M, *_F); ++_F)
			;
		return (_F); }
	virtual const _E *do_scan_not(mask _M, const _E *_F,
		const _E *_L) const
		{for (; _F != _L && is(_M, *_F); ++_F)
			;
		return (_F); }
	virtual _E do_tolower(_E _C) const
		{return (widen(_Tolower(narrow(_C), &_Ctype))); }
	virtual const _E *do_tolower(_E *_F, const _E *_L) const
		{for (; _F != _L; ++_F)
			*_F = _Tolower(*_F, &_Ctype);
		return ((const _E *)_F); }
	virtual _E do_toupper(_E _C) const
		{return (widen(_Toupper(narrow(_C), &_Ctype))); }
	virtual const _E *do_toupper(_E *_F, const _E *_L) const
		{for (; _F != _L; ++_F)
			*_F = _Toupper(*_F, &_Ctype);
		return ((const _E *)_F); }
	virtual _E do_widen(char _X) const
		{return (_WIDEN(_E, _X)); }
	virtual const char *do_widen(const char *_F, const char *_L,
		_E *_V) const
		{for (; _F != _L; ++_F, ++_V)
			*_V = _WIDEN(_E, *_F);
		return (_F); }
	virtual char do_narrow(_E _C, char) const
		{return (_NARROW(_E, _C)); }
	virtual const _E *do_narrow(const _E *_F, const _E *_L,
		char, char *_V) const
		{for (; _F != _L; ++_F, ++_V)
			*_V = _NARROW(_E, *_F);
		return (_F); }
private:
	_Locinfo::_Ctypevec _Ctype;
	};
template<class _E>
	locale::id ctype<_E>::id;
		// CLASS ctype<char>
template<>
class _CXX_IMPORT ctype<char> : public ctype_base {
public:
	typedef char _E;
	typedef _E char_type;
	bool is(mask _M, _E _C) const
		{return ((_Ctype._Table[(unsigned char)_C] & _M) != 0); }
	const _E *is(const _E *_F, const _E *_L, mask *_V) const
		{for (; _F != _L; ++_F, ++_V)
			*_V = _Ctype._Table[(unsigned char)*_F];
		return (_F); }
	const _E *scan_is(mask _M, const _E *_F,
		const _E *_L) const
		{for (; _F != _L && !is(_M, *_F); ++_F)
			;
		return (_F); }
	const _E *scan_not(mask _M, const _E *_F,
		const _E *_L) const
		{for (; _F != _L && is(_M, *_F); ++_F)
			;
		return (_F); }
	_E tolower(_E _C) const
		{return (do_tolower(_C)); }
	const _E *tolower(_E *_F, const _E *_L) const
		{return (do_tolower(_F, _L)); }
	_E toupper(_E _C) const
		{return (do_toupper(_C)); }
	const _E *toupper(_E *_F, const _E *_L) const
		{return (do_toupper(_F, _L)); }
	_E widen(char _X) const
		{return (do_widen(_X)); }
	const _E *widen(const char *_F, const char *_L, _E *_V) const
		{return (do_widen(_F, _L, _V)); }
	_E narrow(_E _C, char _D = '\0') const
		{return (do_narrow(_C, _D)); }
	const _E *narrow(const _E *_F, const _E *_L, char _D,
		char *_V) const
		{return (do_narrow(_F, _L, _D, _V)); }
	static locale::id id;
	explicit ctype(const mask *_Tab = 0, bool _Df = false,
		size_t _R = 0)
		: ctype_base(_R)
		{_Init(_Locinfo());
		if (_Ctype._Delfl)
			free((void *)_Ctype._Table), _Ctype._Delfl = false;
		if (_Tab == 0)
			_Ctype._Table = _Cltab;
		else
			_Ctype._Table = _Tab, _Ctype._Delfl = _Df; }
	ctype(const _Locinfo& _Lobj, size_t _R = 0)
		: ctype_base(_R) {_Init(_Lobj); }
	static size_t _Getcat(const locale::facet **_Ppf = 0)
		{if (_Ppf != 0 && *_Ppf == 0)
			*_Ppf = new ctype<_E>;
		return (_X_CTYPE); }
	static const size_t table_size;
_PROTECTED:
	virtual ~ctype()
		{if (_Ctype._Delfl)
			free((void *)_Ctype._Table); }
protected:
	void _Init(const _Locinfo& _Lobj)
		{_Ctype = _Lobj._Getctype();
		if (_Cltab == 0)
			_Cltab = _Ctype._Table, _Ctype._Delfl = false; }
	virtual _E do_tolower(_E _C) const
		{return (_Tolower((unsigned char)_C, &_Ctype)); }
	virtual const _E *do_tolower(_E *_F, const _E *_L) const
		{for (; _F != _L; ++_F)
			*_F = _Tolower(*_F, &_Ctype);
		return ((const _E *)_F); }
	virtual _E do_toupper(_E _C) const
		{return (_Toupper((unsigned char)_C, &_Ctype)); }
	virtual const _E *do_toupper(_E *_F, const _E *_L) const
		{for (; _F != _L; ++_F)
			*_F = _Toupper(*_F, &_Ctype);
		return ((const _E *)_F); }
	virtual _E do_widen(char _X) const
		{return (_X); }
	virtual const _E *do_widen(const char *_F, const char *_L,
		_E *_V) const
		{memcpy(_V, _F, _L - _F);
		return (_L); }
	virtual _E do_narrow(_E _C, char _D) const
		{return (_C); }
	virtual const _E *do_narrow(const _E *_F, const _E *_L,
		char _D, char *_V) const
		{memcpy(_V, _F, _L - _F);
		return (_L); }
	const mask *table() const _THROW0()
		{return (_Ctype._Table); }
	static const mask *classic_table() _THROW0()
		{if (_Cltab == 0)
			locale::classic();	// force locale::_Init() call
		return (_Cltab); }
private:
	_Locinfo::_Ctypevec _Ctype;
	static const mask *_Cltab;
	};
		// TEMPLATE CLASS ctype_byname
template<class _E>
	class ctype_byname : public ctype<_E> {
public:
	explicit ctype_byname(const char *_S, size_t _R = 0)
		: ctype<_E>(_Locinfo(_S), _R) {}
_PROTECTED:
	virtual ~ctype_byname()
		{}
	};
_STD_END

#pragma namemangling()

#pragma info(none)
#ifndef __CHKHDR__
#  pragma report(pop)
#endif
#pragma info(restore)

#endif /* _XLOCALE_ */

/*
 * Copyright (c) 1995 by P.J. Plauger.  ALL RIGHTS RESERVED. 
 * Consult your license regarding permissions and restrictions.
V2.2:0081 */
