xlocale File Reference

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

Classes
class	_Locbase< _Dummy >
class	collate< _Elem >
struct	_Crt_new_delete
class	locale
class	locale::id
class	locale::facet
class	locale::_Locimp
struct	_Facetptr< _Facet >
class	codecvt_base
class	codecvt< _Elem, _Byte, _Statype >
class	codecvt< char16_t, char, _Mbstatet >
class	codecvt< char32_t, char, _Mbstatet >
class	codecvt< wchar_t, char, _Mbstatet >
class	codecvt_byname< _Elem, _Byte, _Statype >
struct	ctype_base
class	ctype< _Elem >
class	ctype< char >
class	ctype< wchar_t >
class	ctype_byname< _Elem >
class	ctype_byname< char >

Macros
#define	_XLOCALE_
#define	_ADDFAC(loc, pfac)   locale(loc, pfac) /* add facet to locale */
#define	_USE(loc, fac)   use_facet< fac >(loc) /* get facet reference from locale */
#define	_MAKLOCBYTE(Elem, chr, cvt)   _Maklocbyte((_Elem)chr, cvt) /* convert Elem to char */
#define	_MAKLOCCHR(Elem, chr, cvt)   _Maklocchr(chr, (Elem *)0, cvt) /* convert char to Elem */
#define	_MAKLOCSTR(Elem, str, cvt)   _Maklocstr(str, (Elem *)0, cvt) /* convert C string to Elem sequence */

Enumerations
enum	_Codecvt_mode { _Consume_header = 4, _Generate_header = 2 }

Functions
template<class _Facet >
const _Facet &__CRTDECL	use_facet (const locale &)
template<class _Elem , class _InIt >
int __CRTDECL	_Getloctxt (_InIt &_First, _InIt &_Last, size_t _Numfields, const _Elem *_Ptr)
template<class _Elem >
char __CRTDECL	_Maklocbyte (_Elem _Char, const _Locinfo::_Cvtvec &)
template<>
char __CRTDECL	_Maklocbyte (wchar_t _Char, const _Locinfo::_Cvtvec &_Cvt)
template<class _Elem >
_Elem __CRTDECL	_Maklocchr (char _Byte, _Elem *, const _Locinfo::_Cvtvec &)
template<>
wchar_t __CRTDECL	_Maklocchr (char _Byte, wchar_t *, const _Locinfo::_Cvtvec &_Cvt)
template<class _Elem >
_Elem *__CRTDECL	_Maklocstr (const char *_Ptr, _Elem *, const _Locinfo::_Cvtvec &)
template<>
wchar_t *__CRTDECL	_Maklocstr (const char *_Ptr, wchar_t *, const _Locinfo::_Cvtvec &_Cvt)

Macro Definition Documentation

#define _ADDFAC	(		loc,
			pfac
	)		locale(loc, pfac) /* add facet to locale */

#define _MAKLOCBYTE	(		Elem,
			chr,
			cvt
	)		_Maklocbyte((_Elem)chr, cvt) /* convert Elem to char */

#define _MAKLOCCHR	(		Elem,
			chr,
			cvt
	)		_Maklocchr(chr, (Elem *)0, cvt) /* convert char to Elem */

#define _MAKLOCSTR	(		Elem,
			str,
			cvt
	)		_Maklocstr(str, (Elem *)0, cvt) /* convert C string to Elem sequence */

#define _USE	(		loc,
			fac
	)		use_facet< fac >(loc) /* get facet reference from locale */

#define _XLOCALE_

Enumeration Type Documentation

enum _Codecvt_mode

Enumerator
_Consume_header
_Generate_header

                   {
    _Consume_header = 4,
    _Generate_header = 2
    };

Function Documentation

template<class _Elem , class _InIt >

int __CRTDECL _Getloctxt ( _InIt &  _First, _InIt &  _Last, size_t  _Numfields, const _Elem *  _Ptr  )

inline

    {   // find field at _Ptr that matches longest in [_First, _Last)
    for (size_t _Off = 0; _Ptr[_Off] != (_Elem)0; ++_Off)
        if (_Ptr[_Off] == _Ptr[0])
            ++_Numfields;   // add fields with leading mark to initial count
    string _Str(_Numfields, '\0');  // one column counter for each field

    int _Ans = -2;  // no candidates so far
    for (size_t _Column = 1; ; ++_Column, (void)++_First, _Ans = -1)
        {   // test each element against all viable fields
        bool _Prefix = false;   // seen at least one valid prefix
        size_t _Off = 0;    // offset into fields
        size_t _Field = 0;  // current field number

        for (; _Field < _Numfields; ++_Field)
            {   // test element at _Column in field _Field
            for (; _Ptr[_Off] != (_Elem)0 && _Ptr[_Off] != _Ptr[0]; ++_Off)
                ;   // find beginning of field

            if (_Str[_Field] != '\0')
                _Off += _Str[_Field];   // skip tested columns in field
            else if (_Ptr[_Off += _Column] == _Ptr[0]
                || _Ptr[_Off] == (_Elem)0)
                {   // matched all of field, save as possible answer
                _Str[_Field] = (char)(_Column < 127
                    ? _Column : 127);   // save skip count if small enough
                _Ans = (int)_Field; // save answer
                }
            else if (_First == _Last || _Ptr[_Off] != *_First)
                _Str[_Field] = (char)(_Column < 127
                    ? _Column : 127);   // no match, just save skip count
            else
                _Prefix = true; // still a valid prefix
            }

        if (!_Prefix || _First == _Last)
            break;  // no pending prefixes or no input, give up
        }
    return (_Ans);  // return field number or negative value on failure
    }

template<class _Elem >

char __CRTDECL _Maklocbyte ( _Elem  _Char, const _Locinfo::_Cvtvec &    )

inline

    {   // convert _Elem to char using _Cvtvec
    return ((char)(unsigned char)_Char);
    }

template<>

char __CRTDECL _Maklocbyte ( wchar_t  _Char, const _Locinfo::_Cvtvec &  _Cvt  )

inline

    {   // convert wchar_t to char using _Cvtvec
    char _Byte = '\0';
    _Mbstinit(_Mbst1);
    _Wcrtomb(&_Byte, _Char, &_Mbst1, &_Cvt);
    return (_Byte);
    }

template<class _Elem >

_Elem __CRTDECL _Maklocchr ( char  _Byte, _Elem *  , const _Locinfo::_Cvtvec &    )

inline

    {   // convert char to _Elem using _Cvtvec
    return ((_Elem)(unsigned char)_Byte);
    }

template<>

wchar_t __CRTDECL _Maklocchr ( char  _Byte, wchar_t *  , const _Locinfo::_Cvtvec &  _Cvt  )

inline

    {   // convert char to wchar_t using _Cvtvec
    wchar_t _Wc = L'\0';
    _Mbstinit(_Mbst1);
    _Mbrtowc(&_Wc, &_Byte, 1, &_Mbst1, &_Cvt);
    return (_Wc);
    }

template<class _Elem >

_Elem* __CRTDECL _Maklocstr ( const char *  _Ptr, _Elem *  , const _Locinfo::_Cvtvec &    )

inline

    {   // convert C string to _Elem sequence using _Cvtvec
    size_t _Count = _CSTD strlen(_Ptr) + 1;

    _Elem *_Ptrdest = (_Elem *)_calloc_dbg(_Count, sizeof (_Elem),
        _CRT_BLOCK, __FILE__, __LINE__);

    if (!_Ptrdest)
        _Xbad_alloc();

 #pragma warning(push)
 #pragma warning(disable: 6011) /* quiet prefast noise */
    for (_Elem *_Ptrnext = _Ptrdest; 0 < _Count; --_Count, ++_Ptrnext, ++_Ptr)
        *_Ptrnext = (_Elem)(unsigned char)*_Ptr;
 #pragma warning(pop)

    return (_Ptrdest);
    }

template<>

wchar_t* __CRTDECL _Maklocstr ( const char *  _Ptr, wchar_t *  , const _Locinfo::_Cvtvec &  _Cvt  )

inline

    {   // convert C string to wchar_t sequence using _Cvtvec
    size_t _Count, _Count1;
    size_t _Wchars;
    const char *_Ptr1;
    int _Bytes;
    wchar_t _Wc;
    _Mbstinit(_Mbst1);

    _Count1 = _CSTD strlen(_Ptr) + 1;
    for (_Count = _Count1, _Wchars = 0, _Ptr1 = _Ptr; 0 < _Count;
        _Count -= _Bytes, _Ptr1 += _Bytes, ++_Wchars)
        if ((_Bytes = _Mbrtowc(&_Wc, _Ptr1, _Count, &_Mbst1, &_Cvt)) <= 0)
            break;
    ++_Wchars;  // count terminating nul

    wchar_t *_Ptrdest = (wchar_t *)_calloc_dbg(_Wchars, sizeof (wchar_t),
        _CRT_BLOCK, __FILE__, __LINE__);

    if (!_Ptrdest)
        _Xbad_alloc();
    wchar_t *_Ptrnext = _Ptrdest;
    _Mbstinit(_Mbst2);

 #pragma warning(push)
 #pragma warning(disable: 6011) /* quiet prefast noise */
    for (; 0 < _Wchars;
        _Count -= _Bytes, _Ptr += _Bytes, --_Wchars, ++_Ptrnext)
        if ((_Bytes = _Mbrtowc(_Ptrnext, _Ptr, _Count1, &_Mbst2, &_Cvt)) <= 0)
            break;
    *_Ptrnext = L'\0';
 #pragma warning(pop)

    return (_Ptrdest);
    }

template<class _Facet >

const _Facet &__CRTDECL use_facet ( const locale &  _Loc )

inline

    {   // get facet reference from locale
 #if _NO_LOCALES
    static _Wrap_facet<_Facet> _Wfac;
    return (*(_Facet *)&_Wfac);

 #else /* _NO_LOCALES */
    _BEGIN_LOCK(_LOCK_LOCALE)   // the thread lock, make get atomic
        const locale::facet *_Psave =
            _Facetptr<_Facet>::_Psave;  // static pointer to lazy facet

        size_t _Id = _Facet::id;
        const locale::facet *_Pf = _Loc._Getfacet(_Id);

        if (_Pf != 0)
            ;   // got facet from locale
        else if (_Psave != 0)
            _Pf = _Psave;   // lazy facet already allocated
        else if (_Facet::_Getcat(&_Psave, &_Loc) == (size_t)(-1))

 #if _HAS_EXCEPTIONS

            _THROW_NCEE(_XSTD bad_cast, _EMPTY_ARGUMENT);   // lazy disallowed

 #else /* _HAS_EXCEPTIONS */
            abort();    // lazy disallowed
 #endif /* _HAS_EXCEPTIONS */

        else
            {   // queue up lazy facet for destruction
            _Pf = _Psave;
            _Facetptr<_Facet>::_Psave = _Psave;

            locale::facet *_Pfmod = (_Facet *)_Psave;
            _Pfmod->_Incref();

 #if defined(_M_CEE)
            _Facet_Register_m(_Pfmod);

 #else /* defined(_M_CEE) */
            _Facet_Register(_Pfmod);
 #endif /* defined(_M_CEE) */
            }

        return ((const _Facet&)(*_Pf)); // should be dynamic_cast
    _END_LOCK()
 #endif /* _NO_LOCALES */
    }   // end of use_facet body