mbctype.cpp File Reference

#include <corecrt_internal.h>
#include <locale.h>
#include <corecrt_internal_mbstring.h>
#include <mbctype.h>
#include <winnls.h>

Include dependency graph for mbctype.cpp:

Go to the source code of this file.

Classes
struct	code_page_info

Macros
#define	_CHINESE_SIMP_CP   936
#define	_KOREAN_WANGSUNG_CP   949
#define	_CHINESE_TRAD_CP   950
#define	_KOREAN_JOHAB_CP   1361
#define	NUM_CHARS   257 /* -1 through 255 */
#define	NUM_CTYPES   4 /* table contains 4 types of info */
#define	MAX_RANGES   8 /* max number of ranges needed given languages so far */
#define	_MBCTYPE_DEFAULT
#define	_MBCASEMAP_DEFAULT
#define	JAPANSE_DEFAULT_LOCALE_NAME_INDEX   0
#define	CHINESE_SIMPLIFIED_LOCALE_NAME_INDEX   1
#define	KOREAN_DEFAULT_LOCALE_NAME_INDEX   2
#define	CHINESE_TRADITIONAL_LOCALE_NAME_INDEX   3

Functions
	_CRT_LINKER_FORCE_INCLUDE (__acrt_multibyte_initializer)
unsigned char *__cdecl	__p__mbctype ()
unsigned char *__cdecl	__p__mbcasemap ()
int __cdecl	_setmbcp_nolock (int, __crt_multibyte_data *)
static int	getSystemCP (int)
static void	setSBCS (__crt_multibyte_data *ptmbci)
static __crt_multibyte_data *__cdecl	update_thread_multibyte_data_internal (__acrt_ptd *const ptd, __crt_multibyte_data **const current_multibyte_data) throw ()
__crt_multibyte_data *__cdecl	__acrt_update_thread_multibyte_data ()
static int __cdecl	setmbcp_internal (int const requested_codepage, bool const is_for_crt_initialization, __acrt_ptd *const ptd, __crt_multibyte_data **const current_multibyte_data) throw ()
static const wchar_t *	CPtoLocaleName (int codepage)
static void	setSBUpLow (__crt_multibyte_data *ptmbci)
int __cdecl	_setmbcp (int const codepage)
int __cdecl	_getmbcp ()
bool __cdecl	__acrt_initialize_multibyte ()

Variables
__crt_multibyte_data	__acrt_initial_multibyte_data
static unsigned char	_mbctypes [__crt_state_management::state_index_count][NUM_CHARS]
static unsigned char	_mbcasemaps [__crt_state_management::state_index_count][256]
__crt_state_management::dual_state_global< unsigned char * >	_mbctype
__crt_state_management::dual_state_global< unsigned char * >	_mbcasemap
__crt_state_management::dual_state_global< __crt_multibyte_data * >	__acrt_current_multibyte_data
static int	fSystemSet
static char	__rgctypeflag [NUM_CTYPES] = { _MS, _MP, _M1, _M2 }
static code_page_info	__rgcode_page_info []
const wchar_t *const	_mb_locale_names []

Macro Definition Documentation

_CHINESE_SIMP_CP

#define _CHINESE_SIMP_CP   936

Definition at line 22 of file mbctype.cpp.

_CHINESE_TRAD_CP

#define _CHINESE_TRAD_CP   950

Definition at line 24 of file mbctype.cpp.

_KOREAN_JOHAB_CP

#define _KOREAN_JOHAB_CP   1361

Definition at line 25 of file mbctype.cpp.

_KOREAN_WANGSUNG_CP

#define _KOREAN_WANGSUNG_CP   949

Definition at line 23 of file mbctype.cpp.

_MBCASEMAP_DEFAULT

#define _MBCASEMAP_DEFAULT

Value:

    {                                                                           \
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
        0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, \
        0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, \
        0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x00, \
        0x00, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, \
        0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, \
        0x58, 0x59, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00 /* rest is zero */       \
    }

Definition at line 101 of file mbctype.cpp.

_MBCTYPE_DEFAULT

#define _MBCTYPE_DEFAULT

Value:

    {                                                                           \
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, \
        0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, \
        0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, \
        0x00, 0x00, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, \
        0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, \
        0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00 /* rest is zero */       \
    }

Definition at line 77 of file mbctype.cpp.

CHINESE_SIMPLIFIED_LOCALE_NAME_INDEX

#define CHINESE_SIMPLIFIED_LOCALE_NAME_INDEX   1

Definition at line 218 of file mbctype.cpp.

CHINESE_TRADITIONAL_LOCALE_NAME_INDEX

#define CHINESE_TRADITIONAL_LOCALE_NAME_INDEX   3

Definition at line 220 of file mbctype.cpp.

JAPANSE_DEFAULT_LOCALE_NAME_INDEX

#define JAPANSE_DEFAULT_LOCALE_NAME_INDEX   0

Definition at line 217 of file mbctype.cpp.

KOREAN_DEFAULT_LOCALE_NAME_INDEX

#define KOREAN_DEFAULT_LOCALE_NAME_INDEX   2

Definition at line 219 of file mbctype.cpp.

MAX_RANGES

#define MAX_RANGES   8 /* max number of ranges needed given languages so far */

Definition at line 30 of file mbctype.cpp.

NUM_CHARS

#define NUM_CHARS   257 /* -1 through 255 */

Definition at line 27 of file mbctype.cpp.

NUM_CTYPES

#define NUM_CTYPES   4 /* table contains 4 types of info */

Definition at line 29 of file mbctype.cpp.

Function Documentation

__acrt_initialize_multibyte()

bool __cdecl __acrt_initialize_multibyte

(

void

)

Definition at line 894 of file mbctype.cpp.

{
    static bool initialized = false;
 
    // Synchronization note:  it is not possible for a data race to occur here.
    // In the CRT DLLs, this function is called during CRT startup, befor any
    // user code using the CRT may run.  In the static CRT, this function is
    // called by a CRT initializer (at the top of this file), so 'initialized'
    // will be true before any user code can enter the CRT.
    //
    // CRT_REFACTOR TODO We should split this function into two parts:  one that
    // does the initialization (without any check), and one that does nothing,
    // but can be used to cause this object to be linked in.
    if (!initialized)
    {
        // initialize global pointer to the current per-thread mbc information structure
        __acrt_current_multibyte_data.initialize(&__acrt_initial_multibyte_data);
 
        // initialize mbc pointers
        _mbcasemap.initialize_from_array(_mbcasemaps);
        _mbctype  .initialize_from_array(_mbctypes);
 
        // initialize the multibyte globals
        __acrt_ptd* const ptd_head = __acrt_getptd_head();
        for (size_t i = 0; i != __crt_state_management::state_index_count; ++i)
        {
            setmbcp_internal(_MB_CP_ANSI, true, ptd_head + i, &__acrt_current_multibyte_data.dangerous_get_state_array()[i]);
        }
 
        initialized = 1;
    }
 
    return true;
}

Referenced by do_locale_initialization(), initialize_multibyte(), and pre_initialize().

__acrt_update_thread_multibyte_data()

__crt_multibyte_data *__cdecl __acrt_update_thread_multibyte_data

(

void

)

Definition at line 361 of file mbctype.cpp.

{
    return update_thread_multibyte_data_internal(__acrt_getptd(), &__acrt_current_multibyte_data.value());
}

Referenced by __acrt_update_multibyte_info(), __acrt_update_multibyte_info_explicit(), and _get_current_locale().

__p__mbcasemap()

unsigned char *__cdecl __p__mbcasemap

(

void

)

Definition at line 237 of file mbctype.cpp.

{
    return _mbcasemap.value();
}

__p__mbctype()

unsigned char *__cdecl __p__mbctype

(

void

)

Definition at line 232 of file mbctype.cpp.

{
    return _mbctype.value();
}

Referenced by Test__mbctype().

_CRT_LINKER_FORCE_INCLUDE()

_CRT_LINKER_FORCE_INCLUDE

(

__acrt_multibyte_initializer

)

_getmbcp()

int __cdecl _getmbcp

(

void

)

Definition at line 870 of file mbctype.cpp.

{
    _locale_t plocinfo = nullptr;
    _LocaleUpdate _loc_update(plocinfo);
    if ( _loc_update.GetLocaleT()->mbcinfo->ismbcodepage )
        return _loc_update.GetLocaleT()->mbcinfo->mbcodepage;
    else
        return 0;
}

Referenced by test__ismbclx(), test__mbscat_s(), test__mbslwr_s(), test__mbsncpy_s(), test__mbsupr_s(), test_btowc(), test_ismbckata(), test_ismbclegal(), test_mbbtombc(), test_mbcjisjms(), test_mbcjmsjis(), test_mbcp(), test_mbctohira(), test_mbctokata(), test_mbctombb(), test_mbsrev(), test_mbsspn(), test_mbsspnp(), test_splitpath(), and test_wctob().

_setmbcp()

int __cdecl _setmbcp

(

int const

codepage

)

Definition at line 687 of file mbctype.cpp.

{
    return setmbcp_internal(codepage, false, __acrt_getptd(), &__acrt_current_multibyte_data.value());
}

Referenced by __init_global_locale(), test__ismbclx(), test__mbbtype(), test__mbbtype_l(), test__mbscat_s(), test__mbslwr_s(), test__mbsncpy_s(), test__mbsupr_s(), test_btowc(), test_cp_table(), test_ismbckata(), test_ismbclegal(), test_mbbtombc(), test_mbcjisjms(), test_mbcjmsjis(), test_mbcp(), test_mbctohira(), test_mbctokata(), test_mbctombb(), test_mbsrev(), test_mbsspn(), test_mbsspnp(), test_splitpath(), and test_wctob().

_setmbcp_nolock()

int __cdecl _setmbcp_nolock	(	int	codepage,
		__crt_multibyte_data *	ptmbci
	)

Definition at line 692 of file mbctype.cpp.

{
        unsigned int icp;
        unsigned int irg;
        unsigned int ich;
        unsigned char *rgptr;
        CPINFO cpInfo;
 
        codepage = getSystemCP(codepage);
 
        /* user wants 'single-byte' MB code page */
        if (codepage == _MB_CP_SBCS)
        {
            setSBCS(ptmbci);
            return 0;
        }
 
        /* check for CRT code page info */
        for (icp = 0;
            icp < (sizeof(__rgcode_page_info) / sizeof(code_page_info));
            icp++)
        {
            /* see if we have info for this code page */
            if (__rgcode_page_info[icp].code_page == codepage)
            {
                /* clear the table */
                for (ich = 0; ich < NUM_CHARS; ich++)
                    ptmbci->mbctype[ich] = 0;
 
                /* for each type of info, load table */
                for (irg = 0; irg < NUM_CTYPES; irg++)
                {
                    /* go through all the ranges for each type of info */
                    for (rgptr = (unsigned char *)__rgcode_page_info[icp].rgrange[irg];
                        rgptr[0] && rgptr[1];
                        rgptr += 2)
                    {
                        /* set the type for every character in range */
                        for (ich = rgptr[0]; ich <= rgptr[1] && ich < 256; ich++)
                            ptmbci->mbctype[ich + 1] |= __rgctypeflag[irg];
                    }
                }
                /* code page has changed */
                ptmbci->mbcodepage = codepage;
                /* all the code pages we keep info for are truly multibyte */
                ptmbci->ismbcodepage = 1;
                ptmbci->mblocalename = CPtoLocaleName(ptmbci->mbcodepage);
                for (irg = 0; irg < NUM_ULINFO; irg++)
                {
                    ptmbci->mbulinfo[irg] = __rgcode_page_info[icp].mbulinfo[irg];
                }
 
                /* return success */
                setSBUpLow(ptmbci);
                return 0;
            }
        }
 
        /*  verify codepage validity */
        // Unclear why UTF7 is excluded yet stateful and other complex encodings are not
        if (codepage == 0 || codepage == CP_UTF7 || !IsValidCodePage((WORD)codepage))
        {
            /* return failure, code page not changed */
            return -1;
        }
 
        // Special case for UTF-8
        if (codepage == CP_UTF8)
        {
            ptmbci->mbcodepage = CP_UTF8;
            ptmbci->mblocalename = nullptr;
 
            // UTF-8 does not have lead or trail bytes in the terms
            // the CRT thinks of it for DBCS codepages, so we'll
            // clear the flags for all bytes.
            // Note that this array is 257 bytes because there's a
            // "-1" that is used someplaces for EOF.  So this array
            // is actually -1 based.
            for (ich = 0; ich < NUM_ULINFO; ich++)
            {
                ptmbci->mbctype[ich] = 0;
            }
 
            // not really a multibyte code page, we'll have to test
            // ptmbci->mbcodepage == CP_UTF8 when we use this structure.
            ptmbci->ismbcodepage = 0;
 
            // CJK encodings have some full-width mappings, but not here.
            for (irg = 0; irg < NUM_ULINFO; irg++)
            {
                ptmbci->mbulinfo[irg] = 0;
            }
 
            setSBUpLow(ptmbci);
 
            // return success
            return 0;
        }
        /* code page not supported by CRT, try the OS */\
        else if (GetCPInfo(codepage, &cpInfo) != 0)
        {
            BYTE *lbptr;
 
            /* clear the table */
            for (ich = 0; ich < NUM_CHARS; ich++)
            {
                ptmbci->mbctype[ich] = 0;
            }
 
            ptmbci->mbcodepage = codepage;
            ptmbci->mblocalename = nullptr;
 
            // Special case for DBCS where we know there may be a leadbyte/trailbyte pattern
            if (cpInfo.MaxCharSize == 2)
            {
                /* LeadByte range always terminated by two 0's */
                for (lbptr = cpInfo.LeadByte; *lbptr && *(lbptr + 1); lbptr += 2)
                {
                    for (ich = *lbptr; ich <= *(lbptr + 1); ich++)
                        ptmbci->mbctype[ich + 1] |= _M1;
                }
 
                /* All chars > 1 must be considered valid trail bytes */
                for (ich = 0x01; ich < 0xFF; ich++)
                {
                    ptmbci->mbctype[ich + 1] |= _M2;
                }
 
                /* code page has changed */
                ptmbci->mblocalename = CPtoLocaleName(ptmbci->mbcodepage);
 
                /* really a multibyte code page */
                ptmbci->ismbcodepage = 1;
            }
            else
            {
                /* single-byte code page */
                ptmbci->ismbcodepage = 0;
            }
 
            for (irg = 0; irg < NUM_ULINFO; irg++)
            {
                ptmbci->mbulinfo[irg] = 0;
            }
 
            setSBUpLow(ptmbci);
            /* return success */
            return 0;
        }
 
 
        /* If system default call, don't fail - set to SBCS */
        if (fSystemSet)
        {
            setSBCS(ptmbci);
            return 0;
        }
 
        /* return failure, code page not changed */
        return -1;
}

Referenced by _wcreate_locale(), and setmbcp_internal().

CPtoLocaleName()

static const wchar_t * CPtoLocaleName ( int  codepage )

static

Definition at line 514 of file mbctype.cpp.

{
    switch (codepage) {
    case 932:
        return _mb_locale_names[JAPANSE_DEFAULT_LOCALE_NAME_INDEX];
    case 936:
        return _mb_locale_names[CHINESE_SIMPLIFIED_LOCALE_NAME_INDEX];
    case 949:
        return _mb_locale_names[KOREAN_DEFAULT_LOCALE_NAME_INDEX];
    case 950:
        return _mb_locale_names[CHINESE_TRADITIONAL_LOCALE_NAME_INDEX];
    }
 
    return 0;
}

Referenced by _setmbcp_nolock().

getSystemCP()

static int getSystemCP ( int  codepage )

static

Definition at line 554 of file mbctype.cpp.

{
    _locale_t plocinfo = nullptr;
    _LocaleUpdate _loc_update(plocinfo);
    fSystemSet = 0;
 
    /* get system code page values if requested */
 
    if (codepage == _MB_CP_OEM)
    {
        fSystemSet = 1;
        return GetOEMCP();
    }
    else if (codepage == _MB_CP_ANSI)
    {
        fSystemSet = 1;
        return GetACP();
    }
    else if (codepage == _MB_CP_LOCALE)
    {
        fSystemSet = 1;
        return _loc_update.GetLocaleT()->locinfo->_public._locale_lc_codepage;
    }
 
    return codepage;
}

Referenced by _setmbcp_nolock(), and setmbcp_internal().

setmbcp_internal()

static int __cdecl setmbcp_internal ( int const  requested_codepage, bool const  is_for_crt_initialization, __acrt_ptd *const  ptd, __crt_multibyte_data **const  current_multibyte_data  ) throw ( )

static

Definition at line 394 of file mbctype.cpp.

{
    update_thread_multibyte_data_internal(ptd, current_multibyte_data);
    int const system_codepage = getSystemCP(requested_codepage);
 
    // If it's not a new codepage, just return success:
    if (system_codepage == ptd->_multibyte_info->mbcodepage)
    {
        return 0;
    }
 
    // Always allocate space so that we don't have to take a lock for any update:
    __crt_unique_heap_ptr<__crt_multibyte_data> mb_data(_malloc_crt_t(__crt_multibyte_data, 1));
    if (!mb_data)
    {
        return -1;
    }
 
    // Initialize the new multibyte data structure from the current multibyte
    // data structure for this thread, resetting the reference count (since it
    // is not actually referenced by anything yet).
    *mb_data.get() = *ptd->_multibyte_info;
    mb_data.get()->refcount = 0;
 
    // Actually initialize the new multibyte data using the new codepage:
    // CRT_REFACTOR TODO _setmbcp_nolock is a terrible name.
    int const setmbcp_status = _setmbcp_nolock(system_codepage, mb_data.get());
    if (setmbcp_status == -1)
    {
        errno = EINVAL;
        return -1;
    }
 
    // At this point, we have a valid, new set of multibyte data to swap in.  If
    // this is not the initial codepage initialization during process startup,
    // we need to toggle the locale-changed state:
    if (!is_for_crt_initialization)
    {
        __acrt_set_locale_changed();
    }
 
    if (InterlockedDecrement(&ptd->_multibyte_info->refcount) == 0 &&
        ptd->_multibyte_info != &__acrt_initial_multibyte_data)
    {
        _free_crt(ptd->_multibyte_info);
    }
 
    // Update the multibyte codepage for this thread:
    mb_data.get()->refcount = 1;
    ptd->_multibyte_info = mb_data.detach();
 
    // If this thread has its own locale, do not update the global codepage:
    if (!__acrt_should_sync_with_global_locale(ptd))
    {
        return setmbcp_status;
    }
 
    // Otherwise, update the global codepage:
    __acrt_lock_and_call(__acrt_multibyte_cp_lock, [&]
    {
        memcpy_s(_mbctype.value(),   sizeof(_mbctypes[0]),   ptd->_multibyte_info->mbctype,   sizeof(ptd->_multibyte_info->mbctype));
        memcpy_s(_mbcasemap.value(), sizeof(_mbcasemaps[0]), ptd->_multibyte_info->mbcasemap, sizeof(ptd->_multibyte_info->mbcasemap));
 
        if (InterlockedDecrement(&(*current_multibyte_data)->refcount) == 0 &&
            (*current_multibyte_data) != &__acrt_initial_multibyte_data)
        {
            _free_crt(*current_multibyte_data);
        }
 
        *current_multibyte_data = ptd->_multibyte_info;
        InterlockedIncrement(&ptd->_multibyte_info->refcount);
    });
 
    if (is_for_crt_initialization)
    {
        __acrt_initial_locale_pointers.mbcinfo = *current_multibyte_data;
    }
 
    return setmbcp_status;
}

Referenced by __acrt_initialize_multibyte(), and _setmbcp().

setSBCS()

static void setSBCS ( __crt_multibyte_data *  ptmbci )

static

Definition at line 261 of file mbctype.cpp.

{
    int i;
 
    /* set for single-byte code page */
    for (i = 0; i < NUM_CHARS; i++)
        ptmbci->mbctype[i] = 0;
 
    /* code page has changed, set global flag */
    ptmbci->mbcodepage = 0;
 
    /* clear flag to indicate single-byte code */
    ptmbci->ismbcodepage = 0;
 
    ptmbci->mblocalename = nullptr;
 
    for (i = 0; i < NUM_ULINFO; i++)
        ptmbci->mbulinfo[i] = 0;
 
    for ( i = 0 ; i < 257 ; i++ )
        ptmbci->mbctype[i] = __acrt_initial_multibyte_data.mbctype[i];
 
    for ( i = 0 ; i < 256 ; i++ )
        ptmbci->mbcasemap[i] = __acrt_initial_multibyte_data.mbcasemap[i];
}

Referenced by _setmbcp_nolock().

setSBUpLow()

static void setSBUpLow ( __crt_multibyte_data *  ptmbci )

static

Definition at line 598 of file mbctype.cpp.

{
    BYTE *  pbPair;
    UINT    ich;
    CPINFO  cpInfo;
    UCHAR   sbVector[256];
    UCHAR   upVector[256];
    UCHAR   lowVector[256];
    USHORT  wVector[512];
 
    //    test if codepage exists
    if (ptmbci->mbcodepage != CP_UTF8 && GetCPInfo(ptmbci->mbcodepage, &cpInfo) != 0)
    {
        // This code attempts to generate casing tables for characters 0-255
        // For DBCS codepages that will be basically ASCII casing but won't help DBCS mapping.
        // For SBCS codepages that will include the codepage-specific characters.
        // Mappings do not appear to include Turkish-i variations.
 
        //  if so, create vector 0-255
        for (ich = 0; ich < 256; ich++)
            sbVector[ich] = (UCHAR) ich;
 
        //  set byte 0 and any leading byte value to non-alpha char ' '
        sbVector[0] = (UCHAR)' ';
        for (pbPair = &cpInfo.LeadByte[0]; *pbPair; pbPair += 2)
            // make sure ich within a valid range
            for (ich = *pbPair; ich <= *(pbPair + 1) && ich < 256; ich++)
                sbVector[ich] = (UCHAR)' ';
 
        //  get char type for character vector
 
        __acrt_GetStringTypeA(nullptr, CT_CTYPE1, (LPCSTR)sbVector, 256, wVector,
                            ptmbci->mbcodepage, FALSE);
 
        //  get lower case mappings for character vector
 
        __acrt_LCMapStringA(nullptr, ptmbci->mblocalename, LCMAP_LOWERCASE, (LPCSTR)sbVector, 256,
                                    (LPSTR)lowVector, 256, ptmbci->mbcodepage, FALSE);
 
        //  get upper case mappings for character vector
 
        __acrt_LCMapStringA(nullptr, ptmbci->mblocalename, LCMAP_UPPERCASE, (LPCSTR)sbVector, 256,
                                    (LPSTR)upVector, 256, ptmbci->mbcodepage, FALSE);
 
        //  set _SBUP, _SBLOW in ptmbci->mbctype if type is upper. lower
        //  set mapping array with lower or upper mapping value
 
        for (ich = 0; ich < 256; ich++)
        {
            if (wVector[ich] & _UPPER)
            {
                // WARNING: +1 because the mbctype array starts with a -1 EOF character
                ptmbci->mbctype[ich + 1] |= _SBUP;
                ptmbci->mbcasemap[ich] = lowVector[ich];
            }
            else if (wVector[ich] & _LOWER)
            {
                // WARNING: +1 because the mbctype array starts with a -1 EOF character
                ptmbci->mbctype[ich + 1] |= _SBLOW;
                ptmbci->mbcasemap[ich] = upVector[ich];
            }
            else
                ptmbci->mbcasemap[ich] = 0;
        }
    }
    else
    {
        //  Either no codepage or UTF-8 (which looks a lot like ASCII in the lower bits)
        //  Set 'A'-'Z' as upper, 'a'-'z' as lower (eg: ASCII casing)
        for (ich = 0; ich < 256; ich++)
        {
            if (ich >= (UINT)'A' && ich <= (UINT)'Z')
            {
                // WARNING: +1 because the mbctype array starts with a -1 EOF character
                ptmbci->mbctype[ich + 1] |= _SBUP;
                ptmbci->mbcasemap[ich] = static_cast<unsigned char>(ich + ('a' - 'A'));
            }
            else if (ich >= (UINT)'a' && ich <= (UINT)'z')
            {
                // WARNING: +1 because the mbctype array starts with a -1 EOF character
                ptmbci->mbctype[ich + 1] |= _SBLOW;
                ptmbci->mbcasemap[ich] = static_cast<unsigned char>(ich - ('a' - 'A'));
            }
            else
                ptmbci->mbcasemap[ich] = 0;
        }
    }
}

Referenced by _setmbcp_nolock().

update_thread_multibyte_data_internal()

static __crt_multibyte_data *__cdecl update_thread_multibyte_data_internal ( __acrt_ptd *const  ptd, __crt_multibyte_data **const  current_multibyte_data  ) throw ( )

static

Definition at line 305 of file mbctype.cpp.

{
        __crt_multibyte_data* ptmbci = nullptr;
 
        if (__acrt_should_sync_with_global_locale(ptd) || ptd->_locale_info == nullptr)
        {
            __acrt_lock(__acrt_multibyte_cp_lock);
            __try
            {
                ptmbci = ptd->_multibyte_info;
                if (ptmbci != *current_multibyte_data)
                {
                    /*
                     * Decrement the reference count in the old mbc info structure
                     * and free it, if necessary
                     */
                    if (ptmbci != nullptr &&
                        InterlockedDecrement(&ptmbci->refcount) == 0 &&
                        ptmbci != &__acrt_initial_multibyte_data)
                    {
                        /*
                         * Free it
                         */
                        _free_crt(ptmbci);
                    }
 
                    /*
                     * Point to the current mbc info structure and increment its
                     * reference count.
                     */
                    ptmbci = ptd->_multibyte_info = *current_multibyte_data;
                    InterlockedIncrement(&ptmbci->refcount);
                }
            }
            __finally
            {
                __acrt_unlock(__acrt_multibyte_cp_lock);
            }
            __endtry
        }
        else
        {
            ptmbci = ptd->_multibyte_info;
        }
 
        if (!ptmbci)
        {
            abort();
        }
 
        return ptmbci;
}

Referenced by __acrt_update_thread_multibyte_data(), and setmbcp_internal().

Variable Documentation

__acrt_current_multibyte_data

__crt_state_management::dual_state_global<__crt_multibyte_data*> __acrt_current_multibyte_data

Definition at line 131 of file mbctype.cpp.

Referenced by __acrt_initialize_multibyte(), __acrt_update_multibyte_info(), __acrt_update_multibyte_info_explicit(), __acrt_update_thread_multibyte_data(), _setmbcp(), and uninitialize_allocated_memory().

__acrt_initial_multibyte_data

__crt_multibyte_data __acrt_initial_multibyte_data

Definition at line 42 of file mbctype.cpp.

Referenced by __acrt_initialize_multibyte(), _free_locale(), construct_ptd(), destroy_ptd(), setmbcp_internal(), setSBCS(), uninitialize_allocated_memory(), and update_thread_multibyte_data_internal().

__rgcode_page_info

code_page_info __rgcode_page_info[]

static

Definition at line 138 of file mbctype.cpp.

Referenced by _setmbcp_nolock().

__rgctypeflag

char __rgctypeflag[NUM_CTYPES] = { _MS, _MP, _M1, _M2 }

static

Definition at line 136 of file mbctype.cpp.

Referenced by _setmbcp_nolock().

_mb_locale_names

const wchar_t* const _mb_locale_names[]

Initial value:

=
{
    L"ja-JP",   
    L"zh-CN",   
    L"ko-KR",   
    L"zh-TW",   
}

Definition at line 222 of file mbctype.cpp.

Referenced by CPtoLocaleName().

_mbcasemap

__crt_state_management::dual_state_global<unsigned char*> _mbcasemap

Definition at line 128 of file mbctype.cpp.

Referenced by __acrt_initialize_multibyte(), __p__mbcasemap(), and setmbcp_internal().

_mbcasemaps

unsigned char _mbcasemaps[__crt_state_management::state_index_count][256]

static

Initial value:

=
{
    _MBCASEMAP_DEFAULT
 
 
 
}

Definition at line 116 of file mbctype.cpp.

Referenced by __acrt_initialize_multibyte(), and setmbcp_internal().

_mbctype

__crt_state_management::dual_state_global<unsigned char*> _mbctype

This file has no copyright assigned and is placed in the Public Domain. This file is part of the w64 mingw-runtime package. No warranty is given; refer to the file DISCLAIMER within this package.

Definition at line 125 of file mbctype.cpp.

Referenced by __acrt_initialize_multibyte(), __p__mbctype(), and setmbcp_internal().

_mbctypes

unsigned char _mbctypes[__crt_state_management::state_index_count][NUM_CHARS]

static

Initial value:

=
{
    _MBCTYPE_DEFAULT
 
 
 
}

Definition at line 93 of file mbctype.cpp.

Referenced by __acrt_initialize_multibyte(), and setmbcp_internal().

fSystemSet

int fSystemSet

static

Definition at line 134 of file mbctype.cpp.

Referenced by _setmbcp_nolock(), and getSystemCP().