locale.h File Reference

#include <crtdefs.h>

Include dependency graph for locale.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	MSVCRT_threadlocaleinfostruct
struct	MSVCRT_threadmbcinfostruct
struct	MSVCRT_localeinfo_struct
struct	__lc_time_data

Macros
#define	MSVCRT_lconv   lconv
#define	MSVCRT_locale   __get_MSVCRT_locale()

Typedefs
typedef struct MSVCRT_threadlocaleinfostruct	MSVCRT_threadlocinfo
typedef struct MSVCRT_threadmbcinfostruct	MSVCRT_threadmbcinfo
typedef struct MSVCRT_threadlocaleinfostruct *	MSVCRT_pthreadlocinfo
typedef struct MSVCRT_threadmbcinfostruct *	MSVCRT_pthreadmbcinfo
typedef struct MSVCRT_localeinfo_struct	MSVCRT__locale_tstruct
typedef struct MSVCRT_localeinfo_struct *	MSVCRT__locale_t
typedef struct __lc_time_data	MSVCRT___lc_time_data

Functions
int	_setmbcp_l (int, LCID, MSVCRT_pthreadmbcinfo) DECLSPEC_HIDDEN
MSVCRT_pthreadmbcinfo	get_mbcinfo (void) DECLSPEC_HIDDEN
LCID	MSVCRT_locale_to_LCID (const char *, unsigned short *) DECLSPEC_HIDDEN
void	__init_global_locale ()
FORCEINLINE MSVCRT__locale_t	__get_MSVCRT_locale ()
MSVCRT_pthreadlocinfo	get_locinfo (void)
void __cdecl	MSVCRT__free_locale (MSVCRT__locale_t)
void	free_locinfo (MSVCRT_pthreadlocinfo)
void	free_mbcinfo (MSVCRT_pthreadmbcinfo)

Variables
MSVCRT__locale_t	global_locale

Macro Definition Documentation

MSVCRT_lconv

#define MSVCRT_lconv   lconv

Definition at line 42 of file locale.h.

MSVCRT_locale

MSVCRT__locale_t MSVCRT_locale   __get_MSVCRT_locale()

Definition at line 80 of file locale.h.

Referenced by __init_global_locale(), _configthreadlocale(), _setmbcp_l(), get_locinfo(), get_mbcinfo(), msvcrt_get_thread_data(), and setlocale().

Typedef Documentation

MSVCRT___lc_time_data

typedef struct __lc_time_data MSVCRT___lc_time_data

MSVCRT__locale_t

typedef struct MSVCRT_localeinfo_struct * MSVCRT__locale_t

MSVCRT__locale_tstruct

typedef struct MSVCRT_localeinfo_struct MSVCRT__locale_tstruct

MSVCRT_pthreadlocinfo

typedef struct MSVCRT_threadlocaleinfostruct* MSVCRT_pthreadlocinfo

Definition at line 44 of file locale.h.

MSVCRT_pthreadmbcinfo

typedef struct MSVCRT_threadmbcinfostruct* MSVCRT_pthreadmbcinfo

Definition at line 45 of file locale.h.

MSVCRT_threadlocinfo

typedef struct MSVCRT_threadlocaleinfostruct MSVCRT_threadlocinfo

MSVCRT_threadmbcinfo

typedef struct MSVCRT_threadmbcinfostruct MSVCRT_threadmbcinfo

Function Documentation

__get_MSVCRT_locale()

FORCEINLINE MSVCRT__locale_t __get_MSVCRT_locale

(

)

Definition at line 81 of file locale.h.

{
    if(!global_locale)
        __init_global_locale();
    return global_locale;
}

__init_global_locale()

void __init_global_locale

(

)

Definition at line 1498 of file locale.c.

{
    unsigned i;
 
    LOCK_LOCALE;
    /* Someone created it before us */
    if(global_locale)
        return;
    global_locale = MSVCRT__create_locale(0, "C");
 
    __lc_codepage = MSVCRT_locale->locinfo->lc_codepage;
    MSVCRT___lc_collate_cp = MSVCRT_locale->locinfo->lc_collate_cp;
    __mb_cur_max = MSVCRT_locale->locinfo->mb_cur_max;
    for(i=LC_MIN; i<=LC_MAX; i++)
        MSVCRT___lc_handle[i] = MSVCRT_locale->locinfo->lc_handle[i];
    _setmbcp(_MB_CP_ANSI);
    UNLOCK_LOCALE;
}

Referenced by __get_MSVCRT_locale().

_setmbcp_l()

int _setmbcp_l	(	int	cp,
		LCID	lcid,
		MSVCRT_pthreadmbcinfo	mbcinfo
	)

Definition at line 52 of file _setmbcp.c.

{
  const char format[] = ".%d";
 
  int newcp;
  CPINFO cpi;
  BYTE *bytes;
  WORD chartypes[256];
  char bufA[256];
  WCHAR bufW[256];
  int charcount;
  int ret;
  int i;
 
  if(!mbcinfo)
      mbcinfo = get_mbcinfo();
 
  switch (cp)
  {
    case _MB_CP_ANSI:
      newcp = GetACP();
      break;
    case _MB_CP_OEM:
      newcp = GetOEMCP();
      break;
    case _MB_CP_LOCALE:
      newcp = get_locinfo()->lc_codepage;
      if(newcp)
          break;
      /* fall through (C locale) */
    case _MB_CP_SBCS:
      newcp = 20127;   /* ASCII */
      break;
    default:
      newcp = cp;
      break;
  }
 
  if(lcid == -1) {
    sprintf(bufA, format, newcp);
    mbcinfo->mblcid = MSVCRT_locale_to_LCID(bufA, NULL);
  } else {
    mbcinfo->mblcid = lcid;
  }
 
  if(mbcinfo->mblcid == -1)
  {
    WARN("Can't assign LCID to codepage (%d)\n", mbcinfo->mblcid);
    mbcinfo->mblcid = 0;
  }
 
  if (!GetCPInfo(newcp, &cpi))
  {
    WARN("Codepage %d not found\n", newcp);
    *_errno() = EINVAL;
    return -1;
  }
 
  /* setup the _mbctype */
  memset(mbcinfo->mbctype, 0, sizeof(unsigned char[257]));
  memset(mbcinfo->mbcasemap, 0, sizeof(unsigned char[256]));
 
  bytes = cpi.LeadByte;
  while (bytes[0] || bytes[1])
  {
    for (i = bytes[0]; i <= bytes[1]; i++)
      mbcinfo->mbctype[i + 1] |= _M1;
    bytes += 2;
  }
 
  if (cpi.MaxCharSize > 1)
  {
    /* trail bytes not available through kernel32 but stored in a structure in msvcrt */
    struct cp_extra_info_t *cpextra = g_cpextrainfo;
 
    mbcinfo->ismbcodepage = 1;
    while (TRUE)
    {
      if (cpextra->cp == 0 || cpextra->cp == newcp)
      {
        if (cpextra->cp == 0)
          FIXME("trail bytes data not available for DBCS codepage %d - assuming all bytes\n", newcp);
 
        bytes = cpextra->TrailBytes;
        while (bytes[0] || bytes[1])
        {
          for (i = bytes[0]; i <= bytes[1]; i++)
            mbcinfo->mbctype[i + 1] |= _M2;
          bytes += 2;
        }
        break;
      }
      cpextra++;
    }
  }
  else
    mbcinfo->ismbcodepage = 0;
 
  /* we can't use GetStringTypeA directly because we don't have a locale - only a code page
   */
  charcount = 0;
  for (i = 0; i < 256; i++)
    if (!(mbcinfo->mbctype[i + 1] & _M1))
      bufA[charcount++] = i;
 
  ret = MultiByteToWideChar(newcp, 0, bufA, charcount, bufW, charcount);
  if (ret != charcount)
    ERR("MultiByteToWideChar of chars failed for cp %d, ret=%d (exp %d), error=%d\n", newcp, ret, charcount, GetLastError());
 
  GetStringTypeW(CT_CTYPE1, bufW, charcount, chartypes);
 
  charcount = 0;
  for (i = 0; i < 256; i++)
    if (!(mbcinfo->mbctype[i + 1] & _M1))
    {
      if (chartypes[charcount] & C1_UPPER)
      {
        mbcinfo->mbctype[i + 1] |= _SBUP;
        bufW[charcount] = tolowerW(bufW[charcount]);
      }
      else if (chartypes[charcount] & C1_LOWER)
      {
    mbcinfo->mbctype[i + 1] |= _SBLOW;
        bufW[charcount] = toupperW(bufW[charcount]);
      }
      charcount++;
    }
 
  ret = WideCharToMultiByte(newcp, 0, bufW, charcount, bufA, charcount, NULL, NULL);
  if (ret != charcount)
    ERR("WideCharToMultiByte failed for cp %d, ret=%d (exp %d), error=%d\n", newcp, ret, charcount, GetLastError());
 
  charcount = 0;
  for (i = 0; i < 256; i++)
  {
    if(!(mbcinfo->mbctype[i + 1] & _M1))
    {
      if(mbcinfo->mbctype[i] & (C1_UPPER|C1_LOWER))
        mbcinfo->mbcasemap[i] = bufA[charcount];
      charcount++;
    }
  }
 
  if (newcp == 932)   /* CP932 only - set _MP and _MS */
  {
    /* On Windows it's possible to calculate the _MP and _MS from CT_CTYPE1
     * and CT_CTYPE3. But as of Wine 0.9.43 we return wrong values what makes
     * it hard. As this is set only for codepage 932 we hardcode it what gives
     * also faster execution.
     */
    for (i = 161; i <= 165; i++)
      mbcinfo->mbctype[i + 1] |= _MP;
    for (i = 166; i <= 223; i++)
      mbcinfo->mbctype[i + 1] |= _MS;
  }
 
  mbcinfo->mbcodepage = newcp;
  if(global_locale && mbcinfo == MSVCRT_locale->mbcinfo)
    memcpy(_mbctype, MSVCRT_locale->mbcinfo->mbctype, sizeof(_mbctype));
 
  return 0;
}

Referenced by _setmbcp().

free_locinfo()

void free_locinfo

(

MSVCRT_pthreadlocinfo

locinfo

)

Definition at line 643 of file locale.c.

{
    int i;
 
    if(!locinfo)
        return;
 
    if(InterlockedDecrement(&locinfo->refcount))
        return;
 
    for(i=MSVCRT_LC_MIN+1; i<=MSVCRT_LC_MAX; i++) {
        MSVCRT_free(locinfo->lc_category[i].locale);
        MSVCRT_free(locinfo->lc_category[i].refcount);
    }
 
    if(locinfo->lconv) {
        MSVCRT_free(locinfo->lconv->decimal_point);
        MSVCRT_free(locinfo->lconv->thousands_sep);
        MSVCRT_free(locinfo->lconv->grouping);
        MSVCRT_free(locinfo->lconv->int_curr_symbol);
        MSVCRT_free(locinfo->lconv->currency_symbol);
        MSVCRT_free(locinfo->lconv->mon_decimal_point);
        MSVCRT_free(locinfo->lconv->mon_thousands_sep);
        MSVCRT_free(locinfo->lconv->mon_grouping);
        MSVCRT_free(locinfo->lconv->positive_sign);
        MSVCRT_free(locinfo->lconv->negative_sign);
    }
    MSVCRT_free(locinfo->lconv_intl_refcount);
    MSVCRT_free(locinfo->lconv_num_refcount);
    MSVCRT_free(locinfo->lconv_mon_refcount);
    MSVCRT_free(locinfo->lconv);
 
    MSVCRT_free(locinfo->ctype1_refcount);
    MSVCRT_free(locinfo->ctype1);
 
    MSVCRT_free(locinfo->pclmap);
    MSVCRT_free(locinfo->pcumap);
 
    MSVCRT_free(locinfo->lc_time_curr);
 
    MSVCRT_free(locinfo);
}

Referenced by _configthreadlocale(), and MSVCRT__free_locale().

free_mbcinfo()

void free_mbcinfo

(

MSVCRT_pthreadmbcinfo

mbcinfo

)

Definition at line 687 of file locale.c.

{
    if(!mbcinfo)
        return;
 
    if(InterlockedDecrement(&mbcinfo->refcount))
        return;
 
    MSVCRT_free(mbcinfo);
}

Referenced by _configthreadlocale(), and MSVCRT__free_locale().

get_locinfo()

MSVCRT_pthreadlocinfo get_locinfo

(

void

)

Definition at line 356 of file locale.c.

                                        {
    thread_data_t *data = msvcrt_get_thread_data();
 
    if(!data || !data->have_locale)
        return MSVCRT_locale->locinfo;
 
    return data->locinfo;
}

get_mbcinfo()

MSVCRT_pthreadmbcinfo get_mbcinfo

(

void

)

Definition at line 366 of file locale.c.

                                        {
    thread_data_t *data = msvcrt_get_thread_data();
 
    if(!data || !data->have_locale)
        return MSVCRT_locale->mbcinfo;
 
    return data->mbcinfo;
}

MSVCRT__free_locale()

void __cdecl MSVCRT__free_locale

(

MSVCRT__locale_t

locale

)

Definition at line 713 of file locale.c.

{
    if (!locale)
        return;
 
    free_locinfo(locale->locinfo);
    free_mbcinfo(locale->mbcinfo);
    MSVCRT_free(locale);
}

Referenced by MSVCRT__create_locale(), and setlocale().

MSVCRT_locale_to_LCID()

LCID MSVCRT_locale_to_LCID	(	const char *	locale,
		unsigned short *	codepage
	)

Definition at line 210 of file locale.c.

{
    LCID lcid;
    locale_search_t search;
    const char *cp, *region;
 
    memset(&search, 0, sizeof(locale_search_t));
 
    cp = strchr(locale, '.');
    region = strchr(locale, '_');
 
    lstrcpynA(search.search_language, locale, MAX_ELEM_LEN);
    if(region) {
        lstrcpynA(search.search_country, region+1, MAX_ELEM_LEN);
        if(region-locale < MAX_ELEM_LEN)
            search.search_language[region-locale] = '\0';
    } else
        search.search_country[0] = '\0';
 
    if(cp) {
        lstrcpynA(search.search_codepage, cp+1, MAX_ELEM_LEN);
        if(region && cp-region-1<MAX_ELEM_LEN)
          search.search_country[cp-region-1] = '\0';
        if(cp-locale < MAX_ELEM_LEN)
            search.search_language[cp-locale] = '\0';
    } else
        search.search_codepage[0] = '\0';
 
    if(!search.search_country[0] && !search.search_codepage[0])
        remap_synonym(search.search_language);
 
    EnumResourceLanguagesA(GetModuleHandleA("KERNEL32"), (LPSTR)RT_STRING,
            (LPCSTR)LOCALE_ILANGUAGE,find_best_locale_proc,
            (LONG_PTR)&search);
 
    if (!search.match_flags)
        return -1;
 
    /* If we were given something that didn't match, fail */
    if (search.search_country[0] && !(search.match_flags & FOUND_COUNTRY))
        return -1;
 
    lcid =  MAKELCID(search.found_lang_id, SORT_DEFAULT);
 
    /* Populate partial locale, translating LCID to locale string elements */
    if (!(search.match_flags & FOUND_CODEPAGE)) {
        /* Even if a codepage is not enumerated for a locale
         * it can be set if valid */
        if (search.search_codepage[0]) {
            if (IsValidCodePage(atoi(search.search_codepage)))
                memcpy(search.found_codepage,search.search_codepage,MAX_ELEM_LEN);
            else {
                /* Special codepage values: OEM & ANSI */
                if (!strcasecmp(search.search_codepage,"OCP")) {
                    GetLocaleInfoA(lcid, LOCALE_IDEFAULTCODEPAGE,
                            search.found_codepage, MAX_ELEM_LEN);
                } else if (!strcasecmp(search.search_codepage,"ACP")) {
                    GetLocaleInfoA(lcid, LOCALE_IDEFAULTANSICODEPAGE,
                            search.found_codepage, MAX_ELEM_LEN);
                } else
                    return -1;
 
                if (!atoi(search.found_codepage))
                    return -1;
            }
        } else {
            /* Prefer ANSI codepages if present */
            GetLocaleInfoA(lcid, LOCALE_IDEFAULTANSICODEPAGE,
                    search.found_codepage, MAX_ELEM_LEN);
            if (!search.found_codepage[0] || !atoi(search.found_codepage))
                GetLocaleInfoA(lcid, LOCALE_IDEFAULTCODEPAGE,
                        search.found_codepage, MAX_ELEM_LEN);
        }
    }
    if (codepage)
        *codepage = atoi(search.found_codepage);
 
    return lcid;
}

Referenced by MSVCRT__create_locale().

Variable Documentation

global_locale

MSVCRT__locale_t global_locale

extern

Definition at line 1497 of file locale.c.

Referenced by __get_MSVCRT_locale(), __init_global_locale(), _setmbcp_l(), DllMain(), and msvcrt_init_exception().