/home/ntakagi/work/STLport-5.1.5/src/c_locale_win32/c_locale_win32.c Go to the documentation of this file. /* * Copyright (c) 1999 * Silicon Graphics Computer Systems, Inc. * * Copyright (c) 1999 * Boris Fomitchev * * Written 2000 * Anton Lapach * * 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 <windows.h> #include <limits.h> #if defined (_STLP_MSVC) || defined (__ICL) # include <memory.h> #endif #include <string.h> #include <locale.h> #include <stdlib.h> #include <stdio.h> #if defined (_STLP_USE_SAFE_STRING_FUNCTIONS) # define _STLP_STRCPY(D, S) strcpy_s(_STLP_ARRAY_AND_SIZE(D), S) # define _STLP_STRCPY2(D, DS, S) strcpy_s(D, DS, S) # define _STLP_RETURN_STRCPY2(D, DS, S) strcpy_s(D, DS, S); return D # define _STLP_STRNCPY(D, DS, S, C) strncpy_s(D, DS, S, C) # define _STLP_STRCAT(D, S) strcat_s(_STLP_ARRAY_AND_SIZE(D), S) # define _STLP_STRCAT2(D, DS, S) strcat_s(D, DS, S) # if !defined (_STLP_NO_WCHAR_T) # define _STLP_WCSNCPY(D, DS, S, C) wcsncpy_s(D, DS, S, C) # endif #else # define _STLP_STRCPY(D, S) strcpy(D, S) # define _STLP_STRCPY2(D, DS, S) strcpy(D, S) # define _STLP_RETURN_STRCPY2(D, DS, S) return strcpy(D, S) # define _STLP_STRNCPY(D, DS, S, C) strncpy(D, S, C) # define _STLP_STRCAT(D, S) strcat(D, S) # define _STLP_STRCAT2(D, DS, S) strcat(D, S) # if !defined (_STLP_NO_WCHAR_T) # define _STLP_WCSNCPY(D, DS, S, C) wcsncpy(D, S, C) # endif #endif #if defined (__cplusplus) extern "C" { #endif /* Framework functions */ /* locale :: "lang[_country[.code_page]]" | ".code_page" | "" | NULL */ #if !defined (_LEADBYTE) /* multibyte leadbyte */ # define _LEADBYTE 0x8000 #endif typedef struct _LOCALECONV { const char* name; const char* abbrev; } LOCALECONV; #define MAX_LANG_LEN 64 /* max language name length */ #define MAX_CTRY_LEN 64 /* max country name length */ #define MAX_MODIFIER_LEN 0 /* max modifier name length - n/a */ #define MAX_LC_LEN (MAX_LANG_LEN+MAX_CTRY_LEN+MAX_MODIFIER_LEN+3) /* max entire locale string length */ #define MAX_CP_LEN 5 /* max code page name length */ /* Metrowerks has different define here */ #if !defined (LC_MAX) # if defined (LC_LAST) # define LC_MAX LC_LAST # endif #endif /* non-NLS language string table */ static LOCALECONV __rg_language[] = { {"american", "ENU"}, {"american english", "ENU"}, {"american-english", "ENU"}, {"australian", "ENA"}, {"belgian", "NLB"}, {"canadian", "ENC"}, {"chh", "ZHH"}, {"chi", "ZHI"}, {"chinese", "CHS"}, {"chinese-hongkong", "ZHH"}, {"chinese-simplified", "CHS"}, {"chinese-singapore", "ZHI"}, {"chinese-traditional", "CHT"}, {"dutch-belgian", "NLB"}, {"english-american", "ENU"}, {"english-aus", "ENA"}, {"english-belize", "ENL"}, {"english-can", "ENC"}, {"english-caribbean", "ENB"}, {"english-ire", "ENI"}, {"english-jamaica", "ENJ"}, {"english-nz", "ENZ"}, {"english-south africa", "ENS"}, {"english-trinidad y tobago", "ENT"}, {"english-uk", "ENG"}, {"english-us", "ENU"}, {"english-usa", "ENU"}, {"french-belgian", "FRB"}, {"french-canadian", "FRC"}, {"french-luxembourg", "FRL"}, {"french-swiss", "FRS"}, {"german-austrian", "DEA"}, {"german-lichtenstein", "DEC"}, {"german-luxembourg", "DEL"}, {"german-swiss", "DES"}, {"irish-english", "ENI"}, {"italian-swiss", "ITS"}, {"norwegian", "NOR"}, {"norwegian-bokmal", "NOR"}, {"norwegian-nynorsk", "NON"}, {"portuguese-brazilian", "PTB"}, {"spanish-argentina", "ESS"}, {"spanish-bolivia", "ESB"}, {"spanish-chile", "ESL"}, {"spanish-colombia", "ESO"}, {"spanish-costa rica", "ESC"}, {"spanish-dominican republic", "ESD"}, {"spanish-ecuador", "ESF"}, {"spanish-el salvador", "ESE"}, {"spanish-guatemala", "ESG"}, {"spanish-honduras", "ESH"}, {"spanish-mexican", "ESM"}, {"spanish-modern", "ESN"}, {"spanish-nicaragua", "ESI"}, {"spanish-panama", "ESA"}, {"spanish-paraguay", "ESZ"}, {"spanish-peru", "ESR"}, {"spanish-puerto rico", "ESU"}, {"spanish-uruguay", "ESY"}, {"spanish-venezuela", "ESV"}, {"swedish-finland", "SVF"}, {"swiss", "DES"}, {"uk", "ENG"}, {"us", "ENU"}, {"usa", "ENU"} }; /* non-NLS country string table */ static LOCALECONV __rg_country[] = { {"america", "USA"}, {"britain", "GBR"}, {"china", "CHN"}, {"czech", "CZE"}, {"england", "GBR"}, {"great britain", "GBR"}, {"holland", "NLD"}, {"hong-kong", "HKG"}, {"new-zealand", "NZL"}, {"nz", "NZL"}, {"pr china", "CHN"}, {"pr-china", "CHN"}, {"puerto-rico", "PRI"}, {"slovak", "SVK"}, {"south africa", "ZAF"}, {"south korea", "KOR"}, {"south-africa", "ZAF"}, {"south-korea", "KOR"}, {"trinidad & tobago", "TTO"}, {"uk", "GBR"}, {"united-kingdom", "GBR"}, {"united-states", "USA"}, {"us", "USA"}, }; typedef struct _Locale_name_hint { LCID id; } _Locale_lcid_t; typedef struct _Locale_ctype { _Locale_lcid_t lc; UINT cp; unsigned int ctable[256]; } _Locale_ctype_t; typedef struct _Locale_numeric { _Locale_lcid_t lc; char cp[MAX_CP_LEN + 1]; char decimal_point[4]; char thousands_sep[4]; char *grouping; } _Locale_numeric_t; typedef struct _Locale_time { _Locale_lcid_t lc; char cp[MAX_CP_LEN + 1]; char *month[12]; char *abbrev_month[12]; char *dayofweek[7]; char *abbrev_dayofweek[7]; char *date_time_format; char *long_date_time_format; char *date_format; char *long_date_format; char *time_format; char am[9]; char pm[9]; } _Locale_time_t; typedef struct _Locale_collate { _Locale_lcid_t lc; char cp[MAX_CP_LEN + 1]; } _Locale_collate_t; typedef struct _Locale_monetary { _Locale_lcid_t lc; char cp[MAX_CP_LEN + 1]; char decimal_point[4]; char thousands_sep[4]; char *grouping; char int_curr_symbol[5]; /* 3 + 1 + 1 */ char curr_symbol[6]; char negative_sign[5]; char positive_sign[5]; int frac_digits; int int_frac_digits; } _Locale_monetary_t; typedef struct _Locale_messages { _Locale_lcid_t lc; char cp[MAX_CP_LEN + 1]; } _Locale_messages_t; /* Internal function */ static void __FixGrouping(char *grouping); static const char* __ConvertName(const char* lname, LOCALECONV* ConvTable, int TableSize); static int __ParseLocaleString(const char* lname, char* lang, char* ctry, char* page); static int __GetLCID(const char* lang, const char* ctry, LCID* lcid); static int __GetLCIDFromName(const char* lname, LCID* lcid, char *cp, _Locale_lcid_t *hint); static char const* __GetLocaleName(LCID lcid, const char* cp, char* buf); static char const* __Extract_locale_name(const char* loc, int category, char* buf); static char const* __TranslateToSystem(const char* lname, char* buf, _Locale_lcid_t* hint); static void __GetLocaleInfoUsingACP(LCID lcid, const char* cp, LCTYPE lctype, char* buf, int buf_size); static int __intGetACP(LCID lcid); static int __intGetOCP(LCID lcid); static int __GetDefaultCP(LCID lcid); static char* __ConvertToCP(int from_cp, int to_cp, const char *from, size_t size, size_t *ret_buf_size); static void my_ltoa(long __x, char* buf); void my_ltoa(long __x, char* buf) { char rbuf[64]; char* ptr = rbuf; if (__x == 0) *ptr++ = '0'; else { for (; __x != 0; __x /= 10) *ptr++ = (char)(__x % 10) + '0'; } while(ptr > rbuf) *buf++ = *--ptr; /* psw */ *buf = '\0'; } #if defined (__cplusplus) _STLP_BEGIN_NAMESPACE extern "C" { #endif _Locale_lcid_t* _Locale_get_ctype_hint(_Locale_ctype_t* ltype) { return (ltype != 0) ? &ltype->lc : 0; } _Locale_lcid_t* _Locale_get_numeric_hint(_Locale_numeric_t* lnumeric) { return (lnumeric != 0) ? &lnumeric->lc : 0; } _Locale_lcid_t* _Locale_get_time_hint(_Locale_time_t* ltime) { return (ltime != 0) ? &ltime->lc : 0; } _Locale_lcid_t* _Locale_get_collate_hint(_Locale_collate_t* lcollate) { return (lcollate != 0) ? &lcollate->lc : 0; } _Locale_lcid_t* _Locale_get_monetary_hint(_Locale_monetary_t* lmonetary) { return (lmonetary != 0) ? &lmonetary->lc : 0; } _Locale_lcid_t* _Locale_get_messages_hint(_Locale_messages_t* lmessages) { return (lmessages != 0) ? &lmessages->lc : 0; } void* _Locale_ctype_create(const char * name, _Locale_lcid_t* lc_hint) { char cname[_Locale_MAX_SIMPLE_NAME]; char cp_name[MAX_CP_LEN + 1]; int NativeCP; unsigned char Buffer[256]; unsigned char *ptr; unsigned short ctable[256]; CPINFO CPInfo; int i; wchar_t *wbuffer; int BufferSize; _Locale_ctype_t *ltype = (_Locale_ctype_t*)malloc(sizeof(_Locale_ctype_t)); if (!ltype) return ltype; memset(ltype, 0, sizeof(_Locale_ctype_t)); __Extract_locale_name(name, LC_CTYPE, cname); if (__GetLCIDFromName(cname, &ltype->lc.id, cp_name, lc_hint) == -1) { free(ltype); return NULL; } ltype->cp = atoi(cp_name); NativeCP = __GetDefaultCP(ltype->lc.id); /* Make table with all characters. */ for (i = 0; i < 256; ++i) Buffer[i] = (unsigned char)i; if (!GetCPInfo(NativeCP, &CPInfo)) { free(ltype); return NULL; } if (CPInfo.MaxCharSize > 1) { for (ptr = (unsigned char*)CPInfo.LeadByte; *ptr && *(ptr + 1); ptr+=2) for (i = *ptr; i <= *(ptr + 1); ++i) Buffer[i] = 0; } if ((UINT)NativeCP != ltype->cp) { OSVERSIONINFO ver_info; ver_info.dwOSVersionInfoSize = sizeof(ver_info); GetVersionEx(&ver_info); if (ver_info.dwPlatformId == VER_PLATFORM_WIN32_NT) { /* Convert character sequence to Unicode. */ BufferSize = MultiByteToWideChar(ltype->cp, MB_PRECOMPOSED, (const char*)Buffer, 256, NULL, 0); wbuffer = (wchar_t*)malloc(BufferSize*sizeof(wchar_t)); if (!MultiByteToWideChar(ltype->cp, MB_PRECOMPOSED, (const char*)Buffer, 256, wbuffer, BufferSize)) { free(wbuffer); free(ltype); return NULL; } GetStringTypeW(CT_CTYPE1, wbuffer, 256, ctable); for (i = 0; i < 256; ++i) ltype->ctable[i]=(unsigned int)ctable[i]; if (CPInfo.MaxCharSize > 1) { for (ptr = (unsigned char*)CPInfo.LeadByte; *ptr && *(ptr + 1); ptr+=2) for (i = *ptr; i <= *(ptr + 1); i++) ltype->ctable[i] = _LEADBYTE; } free(wbuffer); } else { unsigned char TargetBuffer[256]; GetStringTypeA(ltype->lc.id, CT_CTYPE1, (const char*)Buffer, 256, ctable); /* Convert character sequence to target code page. */ BufferSize = MultiByteToWideChar(NativeCP, MB_PRECOMPOSED, (const char*)Buffer, 256, NULL, 0); wbuffer = (wchar_t*)malloc(BufferSize*sizeof(wchar_t)); if (!MultiByteToWideChar(NativeCP, MB_PRECOMPOSED, (const char*)Buffer, 256, wbuffer, BufferSize)) { free(wbuffer); free(ltype); return NULL; } if (!WideCharToMultiByte(ltype->cp, WC_COMPOSITECHECK | WC_SEPCHARS, wbuffer, BufferSize, (char*)TargetBuffer, 256, NULL, FALSE)) { free(wbuffer); free(ltype); return NULL; } free(wbuffer); /* Translate ctype table. */ for (i = 0; i < 256; ++i) { if (!TargetBuffer[i]) continue; ltype->ctable[TargetBuffer[i]] = ctable[i]; } /* Mark lead byte. */ if (!GetCPInfo(ltype->cp, &CPInfo)) { free(ltype); return NULL; } if (CPInfo.MaxCharSize > 1) { for (ptr = (unsigned char*)CPInfo.LeadByte; *ptr && *(ptr + 1); ptr+=2) for (i = *ptr; i <= *(ptr + 1); ++i) ltype->ctable[i] = _LEADBYTE; } } } else { GetStringTypeA(ltype->lc.id, CT_CTYPE1, (const char*)Buffer, 256, ctable); for (i = 0; i < 256; ++i) ltype->ctable[i]=(unsigned int)ctable[i]; if (CPInfo.MaxCharSize > 1) { for (ptr = (unsigned char*)CPInfo.LeadByte; *ptr && *(ptr + 1); ptr+=2) for (i = *ptr; i <= *(ptr + 1); ++i) ltype->ctable[i] = _LEADBYTE; } } return ltype; } void* _Locale_numeric_create(const char * name, _Locale_lcid_t* lc_hint) { char *GroupingBuffer; char cname[_Locale_MAX_SIMPLE_NAME]; int BufferSize; _Locale_numeric_t *lnum = (_Locale_numeric_t*)malloc(sizeof(_Locale_numeric_t)); if (!lnum) return lnum; /* MS normal behavior for 'new' */ __Extract_locale_name(name, LC_NUMERIC, cname); if (__GetLCIDFromName(cname, &lnum->lc.id, lnum->cp, lc_hint) == -1) { free(lnum); return NULL; } __GetLocaleInfoUsingACP(lnum->lc.id, lnum->cp, LOCALE_SDECIMAL, lnum->decimal_point, 4); __GetLocaleInfoUsingACP(lnum->lc.id, lnum->cp, LOCALE_STHOUSAND, lnum->thousands_sep, 4); BufferSize = GetLocaleInfoA(lnum->lc.id, LOCALE_SGROUPING, NULL, 0); GroupingBuffer = (char*)malloc(BufferSize); if (!GroupingBuffer) { lnum->grouping = NULL; return lnum; } GetLocaleInfoA(lnum->lc.id, LOCALE_SGROUPING, GroupingBuffer, BufferSize); __FixGrouping(GroupingBuffer); lnum->grouping = GroupingBuffer; return lnum; } static int __ConvertDate(const char *NTDate, char *buffer, int buf_size) { /* This function will return an incomplete buffer if buffer is not long enough */ const char *cur_char; char *cur_output, *end_output; /* Correct time format. */ cur_char = NTDate; cur_output = buffer; end_output = cur_output + buf_size; buf_size = 0; while (*cur_char) { if (cur_output && (cur_output == end_output)) break; switch (*cur_char) { case 'd': { if (*(cur_char + 1) == 'd') { if (cur_output && (cur_output + 2 > end_output)) { *cur_output = 0; return ++buf_size; } if (*(cur_char + 2) == 'd') { if (*(cur_char + 3) == 'd') { if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = 'A'; } buf_size += 2; cur_char += 3; } else { if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = 'a'; } buf_size += 2; cur_char += 2; } } else { if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = 'd'; } buf_size += 2; cur_char++; } } else { if (cur_output && (cur_output + 3 > end_output)) { *cur_output = 0; return ++buf_size; } if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = '#'; *(cur_output++) = 'd'; } buf_size += 3; } } break; case 'M': { if (*(cur_char + 1) == 'M') { if (cur_output && (cur_output + 2 > end_output)) { *cur_output = 0; return ++buf_size; } if (*(cur_char + 2) == 'M') { if (*(cur_char + 3) == 'M') { if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = 'B'; } buf_size += 2; cur_char += 3; } else { if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = 'b'; } buf_size += 2; cur_char += 2; } } else { if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = 'm'; } buf_size += 2; cur_char++; } } else { if (cur_output && (cur_output + 3 > end_output)) { *cur_output = 0; return ++buf_size; } if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = '#'; *(cur_output++) = 'm'; } buf_size += 3; } } break; case 'y': { if (*(cur_char + 1) == 'y') { if (cur_output && (cur_output + 2 > end_output)) { *cur_output = 0; return ++buf_size; } if (*(cur_char + 2) == 'y' && *(cur_char + 3) == 'y') { if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = 'Y'; } buf_size += 2; cur_char += 3; } else { if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = 'y'; } buf_size += 2; cur_char++; } } else { if (cur_output && (cur_output + 3 > end_output)) { *cur_output = 0; return ++buf_size; } if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = '#'; *(cur_output++) = 'y'; } buf_size += 3; } } break; case '%': { if (cur_output && (cur_output + 2 > end_output)) { *cur_output = 0; return ++buf_size; } if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = '%'; } buf_size += 2; } break; case '\'': { ++cur_char; while (*cur_char != '\'' && *cur_char != 0 && (cur_output == NULL || cur_output != end_output)) { if (cur_output) { *cur_output++ = *cur_char; } ++cur_char; buf_size += 1; } } break; default: { if (cur_output) { *(cur_output++) = *cur_char; } buf_size += 1; } break; } if (*cur_char == 0) break; ++cur_char; } if (!cur_output || cur_output != end_output) { if (cur_output) *cur_output = 0; buf_size += 1; } else { /* We trunc result */ *(--cur_output) = 0; } return buf_size; } static int __ConvertTime(const char *NTTime, char *buffer, int buf_size) { const char *cur_char; char *cur_output, *end_output; cur_char = NTTime; cur_output = buffer; end_output = cur_output + buf_size; buf_size = 0; while (*cur_char) { switch(*cur_char) { case 'h': if (*(cur_char + 1) == 'h') { if (cur_output && (cur_output + 2 > end_output)) { *cur_output = 0; return ++buf_size; } if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = 'I'; } buf_size += 2; ++cur_char; } else { if (cur_output && (cur_output + 3 > end_output)) { *cur_output = 0; return ++buf_size; } if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = '#'; *(cur_output++) = 'I'; } buf_size += 3; } break; case 'H': if (*(cur_char + 1) == 'H') { if (cur_output && (cur_output + 2 > end_output)) { *cur_output = 0; return ++buf_size; } if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = 'H'; } buf_size += 2; ++cur_char; } else { if (cur_output && (cur_output + 3 > end_output)) { *cur_output = 0; return ++buf_size; } if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = '#'; *(cur_output++) = 'H'; } buf_size += 3; } break; case 'm': if (*(cur_char + 1) == 'm') { if (cur_output && (cur_output + 2 > end_output)) { *cur_output = 0; return ++buf_size; } if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = 'M'; } buf_size += 2; cur_char++; } else { if (cur_output && (cur_output + 3 > end_output)) { *cur_output = 0; return ++buf_size; } if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = '#'; *(cur_output++) = 'M'; } buf_size += 3; } break; case 's': if (*(cur_char + 1) == 's') { if (cur_output && (cur_output + 2 > end_output)) { *cur_output = 0; return ++buf_size; } if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = 'S'; } buf_size += 2; ++cur_char; } else { if (cur_output && (cur_output + 3 > end_output)) { *cur_output = 0; return ++buf_size; } if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = '#'; *(cur_output++) = 'S'; } buf_size += 3; } break; case 't': if (*(cur_char + 1) == 't') ++cur_char; if (cur_output && (cur_output + 2 > end_output)) { *cur_output = 0; return ++buf_size; } if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = 'p'; } buf_size += 2; break; case '%': if (cur_output && (cur_output + 2 > end_output)) { *cur_output = 0; return ++buf_size; } if (cur_output) { *(cur_output++)='%'; *(cur_output++)='%'; } buf_size += 2; break; case '\'': ++cur_char; while (*cur_char != '\'' && *cur_char != 0 && (!cur_output || (cur_output != end_output))) { if (cur_output) *cur_output++ = *cur_char; ++cur_char; buf_size += 1; } break; default: if (cur_output) { *(cur_output++) = *cur_char; } buf_size += 1; break; } if (*cur_char == 0) break; ++cur_char; } if (!cur_output || cur_output != end_output) { if (cur_output) *cur_output = 0; buf_size += 1; } else { /* We trunc result */ *(--cur_output) = 0; } return buf_size; } void* _Locale_time_create(const char * name, _Locale_lcid_t* lc_hint) { int size, month, dayofweek; size_t length; char fmt80[80]; char cname[_Locale_MAX_SIMPLE_NAME]; _Locale_time_t *ltime=(_Locale_time_t*)malloc(sizeof(_Locale_time_t)); if (!ltime) return ltime; memset(ltime, 0, sizeof(_Locale_time_t)); __Extract_locale_name(name, LC_TIME, cname); if (__GetLCIDFromName(cname, &ltime->lc.id, ltime->cp, lc_hint) == -1) { free(ltime); return NULL; } for (month = LOCALE_SMONTHNAME1; month <= LOCALE_SMONTHNAME12; ++month) { /* Small hack :-) */ size = GetLocaleInfoA(ltime->lc.id, month, NULL, 0); ltime->month[month - LOCALE_SMONTHNAME1] = (char*)malloc(size); if (!ltime->month[month - LOCALE_SMONTHNAME1]) { _Locale_time_destroy(ltime); return NULL; } __GetLocaleInfoUsingACP(ltime->lc.id, ltime->cp, month, ltime->month[month - LOCALE_SMONTHNAME1], size); } for (month = LOCALE_SABBREVMONTHNAME1; month <= LOCALE_SABBREVMONTHNAME12; ++month) { size = GetLocaleInfoA(ltime->lc.id, month, NULL, 0); ltime->abbrev_month[month - LOCALE_SABBREVMONTHNAME1] = (char*)malloc(size); if (!ltime->abbrev_month[month - LOCALE_SABBREVMONTHNAME1]) { _Locale_time_destroy(ltime); return NULL; } __GetLocaleInfoUsingACP(ltime->lc.id, ltime->cp, month, ltime->abbrev_month[month - LOCALE_SABBREVMONTHNAME1], size); } for (dayofweek = LOCALE_SDAYNAME1; dayofweek <= LOCALE_SDAYNAME7; ++dayofweek) { int dayindex = ( dayofweek != LOCALE_SDAYNAME7 ) ? dayofweek - LOCALE_SDAYNAME1 + 1 : 0; size = GetLocaleInfoA(ltime->lc.id, dayofweek, NULL, 0); ltime->dayofweek[dayindex] = (char*)malloc(size); if (!ltime->dayofweek[dayindex]) { _Locale_time_destroy(ltime); return NULL; } __GetLocaleInfoUsingACP(ltime->lc.id, ltime->cp, dayofweek, ltime->dayofweek[dayindex], size); } for (dayofweek = LOCALE_SABBREVDAYNAME1; dayofweek <= LOCALE_SABBREVDAYNAME7; ++dayofweek) { int dayindex = ( dayofweek != LOCALE_SABBREVDAYNAME7 ) ? dayofweek - LOCALE_SABBREVDAYNAME1 + 1 : 0; size = GetLocaleInfoA(ltime->lc.id, dayofweek, NULL, 0); ltime->abbrev_dayofweek[dayindex] = (char*)malloc(size); if (!ltime->abbrev_dayofweek[dayindex]) { _Locale_time_destroy(ltime); return NULL; } __GetLocaleInfoUsingACP(ltime->lc.id, ltime->cp, dayofweek, ltime->abbrev_dayofweek[dayindex], size); } __GetLocaleInfoUsingACP(ltime->lc.id, ltime->cp, LOCALE_SSHORTDATE, fmt80, 80); size = __ConvertDate(fmt80, NULL, 0); ltime->date_format = (char*)malloc(size); if (!ltime->date_format) { _Locale_time_destroy(ltime); return NULL; } __ConvertDate(fmt80, ltime->date_format, size); __GetLocaleInfoUsingACP(ltime->lc.id, ltime->cp, LOCALE_SLONGDATE, fmt80, 80); size = __ConvertDate(fmt80, NULL, 0); ltime->long_date_format = (char*)malloc(size); if (!ltime->long_date_format) { _Locale_time_destroy(ltime); return NULL; } __ConvertDate(fmt80, ltime->long_date_format, size); __GetLocaleInfoUsingACP(ltime->lc.id, ltime->cp, LOCALE_STIMEFORMAT, fmt80, 80); size = __ConvertTime(fmt80, NULL, 0); ltime->time_format = (char*)malloc(size); if (!ltime->time_format) { _Locale_time_destroy(ltime); return NULL; } __ConvertTime(fmt80, ltime->time_format, size); /* NT doesn't provide this information, we must simulate. */ length = strlen(ltime->date_format) + strlen(ltime->time_format) + 1 /* space */ + 1 /* trailing 0 */; ltime->date_time_format = (char*)malloc(length); if (!ltime->date_time_format) { _Locale_time_destroy(ltime); return NULL; } _STLP_STRCPY2(ltime->date_time_format, length, ltime->date_format); _STLP_STRCAT2(ltime->date_time_format, length, " "); _STLP_STRCAT2(ltime->date_time_format, length, ltime->time_format); /* NT doesn't provide this information, we must simulate. */ length = strlen(ltime->long_date_format) + strlen(ltime->time_format) + 1 /* space */ + 1 /* trailing 0 */; ltime->long_date_time_format = (char*)malloc(length); if (!ltime->long_date_time_format) { _Locale_time_destroy(ltime); return NULL; } _STLP_STRCPY2(ltime->long_date_time_format, length, ltime->long_date_format); _STLP_STRCAT2(ltime->long_date_time_format, length, " "); _STLP_STRCAT2(ltime->long_date_time_format, length, ltime->time_format); __GetLocaleInfoUsingACP(ltime->lc.id, ltime->cp, LOCALE_S1159, ltime->am, 9); __GetLocaleInfoUsingACP(ltime->lc.id, ltime->cp, LOCALE_S2359, ltime->pm, 9); return ltime; } void* _Locale_collate_create(const char * name, _Locale_lcid_t* lc_hint) { char cname[_Locale_MAX_SIMPLE_NAME]; _Locale_collate_t *lcol=(_Locale_collate_t*)malloc(sizeof(_Locale_collate_t)); if (!lcol) return lcol; memset(lcol, 0, sizeof(_Locale_collate_t)); __Extract_locale_name(name, LC_COLLATE, cname); if (__GetLCIDFromName(cname, &lcol->lc.id, lcol->cp, lc_hint) == -1) { free(lcol); return NULL; } return lcol; } void* _Locale_monetary_create(const char * name, _Locale_lcid_t* lc_hint) { char cname[_Locale_MAX_SIMPLE_NAME]; char *GroupingBuffer; int BufferSize; char FracDigits[3]; _Locale_monetary_t *lmon = (_Locale_monetary_t*)malloc(sizeof(_Locale_monetary_t)); if (!lmon) return lmon; memset(lmon, 0, sizeof(_Locale_monetary_t)); __Extract_locale_name(name, LC_MONETARY, cname); if (__GetLCIDFromName(cname, &lmon->lc.id, lmon->cp, lc_hint) == -1) { free(lmon); return NULL; } /* Extract information about monetary system */ __GetLocaleInfoUsingACP(lmon->lc.id, lmon->cp, LOCALE_SDECIMAL, lmon->decimal_point, 4); __GetLocaleInfoUsingACP(lmon->lc.id, lmon->cp, LOCALE_STHOUSAND, lmon->thousands_sep, 4); BufferSize = GetLocaleInfoA(lmon->lc.id, LOCALE_SGROUPING, NULL, 0); GroupingBuffer = (char*)malloc(BufferSize); if (!GroupingBuffer) { lmon->grouping = NULL; return lmon; } GetLocaleInfoA(lmon->lc.id, LOCALE_SGROUPING, GroupingBuffer, BufferSize); __FixGrouping(GroupingBuffer); lmon->grouping=GroupingBuffer; __GetLocaleInfoUsingACP(lmon->lc.id, lmon->cp, LOCALE_SCURRENCY, lmon->curr_symbol, 6); __GetLocaleInfoUsingACP(lmon->lc.id, lmon->cp, LOCALE_SNEGATIVESIGN, lmon->negative_sign, 5); __GetLocaleInfoUsingACP(lmon->lc.id, lmon->cp, LOCALE_SPOSITIVESIGN, lmon->positive_sign, 5); GetLocaleInfoA(lmon->lc.id, LOCALE_ICURRDIGITS, FracDigits, 3); lmon->frac_digits = atoi(FracDigits); GetLocaleInfoA(lmon->lc.id, LOCALE_IINTLCURRDIGITS, FracDigits, 3); lmon->int_frac_digits = atoi(FracDigits); __GetLocaleInfoUsingACP(lmon->lc.id, lmon->cp, LOCALE_SINTLSYMBOL, lmon->int_curr_symbol, 5); /* Even if Platform SDK documentation says that the returned symbol should * be a 3 letters symbol followed by a seperation character, experimentation * has shown that no seperation character is ever appended. We are adding it * ourself to conform to the POSIX specification. */ if (lmon->int_curr_symbol[3] == 0) { lmon->int_curr_symbol[3] = ' '; lmon->int_curr_symbol[4] = 0; } return lmon; } void* _Locale_messages_create(const char *name, _Locale_lcid_t* lc_hint) { char cname[_Locale_MAX_SIMPLE_NAME]; _Locale_messages_t *lmes=(_Locale_messages_t*)malloc(sizeof(_Locale_messages_t)); if (!lmes) return lmes; memset(lmes, 0, sizeof(_Locale_messages_t)); _Locale_extract_messages_name(name, cname, lc_hint); if (__GetLCIDFromName(cname, &lmes->lc.id, lmes->cp, lc_hint) == -1) { free(lmes); return NULL; } return lmes; } static const char* _Locale_common_default(char* buf) { char cp[MAX_CP_LEN + 1]; int CodePage = __GetDefaultCP(LOCALE_USER_DEFAULT); my_ltoa(CodePage, cp); return __GetLocaleName(LOCALE_USER_DEFAULT, cp, buf); } const char* _Locale_ctype_default(char* buf) { return _Locale_common_default(buf); } const char* _Locale_numeric_default(char * buf) { return _Locale_common_default(buf); } const char* _Locale_time_default(char* buf) { return _Locale_common_default(buf); } const char* _Locale_collate_default(char* buf) { return _Locale_common_default(buf); } const char* _Locale_monetary_default(char* buf) { return _Locale_common_default(buf); } const char* _Locale_messages_default(char* buf) { return _Locale_common_default(buf); } char const* _Locale_ctype_name(const void* loc, char* buf) { char cp_buf[MAX_CP_LEN + 1]; _Locale_ctype_t* ltype = (_Locale_ctype_t*)loc; my_ltoa(ltype->cp, cp_buf); return __GetLocaleName(ltype->lc.id, cp_buf, buf); } char const* _Locale_numeric_name(const void* loc, char* buf) { _Locale_numeric_t* lnum = (_Locale_numeric_t*)loc; return __GetLocaleName(lnum->lc.id, lnum->cp, buf); } char const* _Locale_time_name(const void* loc, char* buf) { _Locale_time_t* ltime = (_Locale_time_t*)loc; return __GetLocaleName(ltime->lc.id, ltime->cp, buf); } char const* _Locale_collate_name(const void* loc, char* buf) { _Locale_collate_t* lcol = (_Locale_collate_t*)loc; return __GetLocaleName(lcol->lc.id, lcol->cp, buf); } char const* _Locale_monetary_name(const void* loc, char* buf) { _Locale_monetary_t* lmon = (_Locale_monetary_t*)loc; return __GetLocaleName(lmon->lc.id, lmon->cp, buf); } char const* _Locale_messages_name(const void* loc, char* buf) { _Locale_messages_t* lmes = (_Locale_messages_t*)loc; return __GetLocaleName(lmes->lc.id, lmes->cp, buf); } void _Locale_ctype_destroy(void* loc) { _Locale_ctype_t *ltype = (_Locale_ctype_t*)loc; if (!ltype) return; free(ltype); } void _Locale_numeric_destroy(void* loc) { _Locale_numeric_t *lnum = (_Locale_numeric_t *)loc; if (!lnum) return; if (lnum->grouping) free(lnum->grouping); free(lnum); } void _Locale_time_destroy(void* loc) { int i; _Locale_time_t* ltime = (_Locale_time_t*)loc; if (!ltime) return; for (i = 0; i < 12; ++i) { if (ltime->month[i]) free(ltime->month[i]); if (ltime->abbrev_month[i]) free(ltime->abbrev_month[i]); } for (i = 0; i < 7; ++i) { if (ltime->dayofweek[i]) free(ltime->dayofweek[i]); if (ltime->abbrev_dayofweek[i]) free(ltime->abbrev_dayofweek[i]); } if (ltime->date_format) free(ltime->date_format); if (ltime->long_date_format) free(ltime->long_date_format); if (ltime->time_format) free(ltime->time_format); if (ltime->date_time_format) free(ltime->date_time_format); if (ltime->long_date_time_format) free(ltime->long_date_time_format); free(ltime); } void _Locale_collate_destroy(void* loc) { _Locale_collate_t* lcol=(_Locale_collate_t*)loc; if (!lcol) return; free(lcol); } void _Locale_monetary_destroy(void* loc) { _Locale_monetary_t *lmon = (_Locale_monetary_t*)loc; if (!lmon) return; if (lmon->grouping) free(lmon->grouping); free(lmon); } void _Locale_messages_destroy(void* loc) { _Locale_messages_t* lmes = (_Locale_messages_t*)loc; if (!lmes) return; free(lmes); } static char const* _Locale_extract_category_name(const char* cname, int category, char* buf, _Locale_lcid_t* hint) { char lname[_Locale_MAX_SIMPLE_NAME]; __Extract_locale_name(cname, category, lname); if (lname[0] == 'C' && lname[1] == 0) { _STLP_RETURN_STRCPY2(buf, _Locale_MAX_SIMPLE_NAME, lname); } return __TranslateToSystem(lname, buf, hint); } char const* _Locale_extract_ctype_name(const char* cname, char* buf, _Locale_lcid_t* hint) { return _Locale_extract_category_name(cname, LC_CTYPE, buf, hint); } char const* _Locale_extract_numeric_name(const char* cname, char* buf, _Locale_lcid_t* hint) { return _Locale_extract_category_name(cname, LC_NUMERIC, buf, hint); } char const* _Locale_extract_time_name(const char* cname, char* buf, _Locale_lcid_t* hint) { return _Locale_extract_category_name(cname, LC_TIME, buf, hint); } char const* _Locale_extract_collate_name(const char* cname, char* buf, _Locale_lcid_t* hint) { return _Locale_extract_category_name(cname, LC_COLLATE, buf, hint); } char const* _Locale_extract_monetary_name(const char* cname, char* buf, _Locale_lcid_t* hint) { return _Locale_extract_category_name(cname, LC_MONETARY, buf, hint); } char const* _Locale_extract_messages_name(const char* cname, char* buf, _Locale_lcid_t* hint) { if (cname[0] == 'L' && cname[1] == 'C' && cname[2] == '_') { _STLP_RETURN_STRCPY2(buf, _Locale_MAX_SIMPLE_NAME, "C"); } if (cname[0] == 'C' && cname[1] == 0) { _STLP_RETURN_STRCPY2(buf, _Locale_MAX_SIMPLE_NAME, cname); } return __TranslateToSystem(cname, buf, hint); } char const* _Locale_compose_name(char* buf, const char* _ctype, const char* numeric, const char* time, const char* _collate, const char* monetary, const char* messages, const char* default_name) { (void) default_name; if (!strcmp(_ctype, numeric) && !strcmp(_ctype, time) && !strcmp(_ctype, _collate) && !strcmp(_ctype, monetary) && !strcmp(_ctype, messages)) { _STLP_RETURN_STRCPY2(buf, _Locale_MAX_COMPOSITE_NAME, _ctype); } _STLP_STRCPY2(buf, _Locale_MAX_COMPOSITE_NAME, "LC_CTYPE="); _STLP_STRCAT2(buf, _Locale_MAX_COMPOSITE_NAME, _ctype); _STLP_STRCAT2(buf, _Locale_MAX_COMPOSITE_NAME, ";"); _STLP_STRCAT2(buf, _Locale_MAX_COMPOSITE_NAME, "LC_TIME="); _STLP_STRCAT2(buf, _Locale_MAX_COMPOSITE_NAME, time); _STLP_STRCAT2(buf, _Locale_MAX_COMPOSITE_NAME, ";"); _STLP_STRCAT2(buf, _Locale_MAX_COMPOSITE_NAME, "LC_NUMERIC="); _STLP_STRCAT2(buf, _Locale_MAX_COMPOSITE_NAME, numeric); _STLP_STRCAT2(buf, _Locale_MAX_COMPOSITE_NAME, ";"); _STLP_STRCAT2(buf, _Locale_MAX_COMPOSITE_NAME, "LC_COLLATE="); _STLP_STRCAT2(buf, _Locale_MAX_COMPOSITE_NAME, _collate); _STLP_STRCAT2(buf, _Locale_MAX_COMPOSITE_NAME, ";"); _STLP_STRCAT2(buf, _Locale_MAX_COMPOSITE_NAME, "LC_MONETARY="); _STLP_STRCAT2(buf, _Locale_MAX_COMPOSITE_NAME, monetary); _STLP_STRCAT2(buf, _Locale_MAX_COMPOSITE_NAME, ";"); _STLP_STRCAT2(buf, _Locale_MAX_COMPOSITE_NAME, "LC_MESSAGES="); _STLP_STRCAT2(buf, _Locale_MAX_COMPOSITE_NAME, messages); _STLP_STRCAT2(buf, _Locale_MAX_COMPOSITE_NAME, ";"); return buf; } /* ctype */ const _Locale_mask_t* _Locale_ctype_table(_Locale_ctype_t* ltype) { _STLP_STATIC_ASSERT(sizeof(_Locale_mask_t) == sizeof(unsigned int)) return (const _Locale_mask_t*)ltype->ctable; } int _Locale_toupper(_Locale_ctype_t* ltype, int c) { char buf[2], out_buf[2]; buf[0] = (char)c; buf[1] = 0; if ((UINT)__GetDefaultCP(ltype->lc.id) == ltype->cp) { LCMapStringA(ltype->lc.id, LCMAP_LINGUISTIC_CASING | LCMAP_UPPERCASE, buf, 2, out_buf, 2); return out_buf[0]; } else { wchar_t wbuf[2]; MultiByteToWideChar(ltype->cp, MB_PRECOMPOSED, buf, 2, wbuf, 2); WideCharToMultiByte(__GetDefaultCP(ltype->lc.id), WC_COMPOSITECHECK | WC_SEPCHARS, wbuf, 2, buf, 2, NULL, FALSE); LCMapStringA(ltype->lc.id, LCMAP_LINGUISTIC_CASING | LCMAP_UPPERCASE, buf, 2, out_buf, 2); MultiByteToWideChar(__GetDefaultCP(ltype->lc.id), MB_PRECOMPOSED, out_buf, 2, wbuf, 2); WideCharToMultiByte(ltype->cp, WC_COMPOSITECHECK | WC_SEPCHARS, wbuf, 2, out_buf, 2, NULL, FALSE); return out_buf[0]; } } int _Locale_tolower(_Locale_ctype_t* ltype, int c) { char buf[2], out_buf[2]; buf[0] = (char)c; buf[1] = 0; if ((UINT)__GetDefaultCP(ltype->lc.id) == ltype->cp) { LCMapStringA(ltype->lc.id, LCMAP_LINGUISTIC_CASING | LCMAP_LOWERCASE, buf, 2, out_buf, 2); return out_buf[0]; } else { wchar_t wbuf[2]; MultiByteToWideChar(ltype->cp, MB_PRECOMPOSED, buf, 2, wbuf, 2); WideCharToMultiByte(__GetDefaultCP(ltype->lc.id), WC_COMPOSITECHECK | WC_SEPCHARS, wbuf, 2, buf, 2, NULL, FALSE); LCMapStringA(ltype->lc.id, LCMAP_LINGUISTIC_CASING | LCMAP_LOWERCASE, buf, 2, out_buf, 2); MultiByteToWideChar(__GetDefaultCP(ltype->lc.id), MB_PRECOMPOSED, out_buf, 2, wbuf, 2); WideCharToMultiByte(ltype->cp, WC_COMPOSITECHECK | WC_SEPCHARS, wbuf, 2, out_buf, 2, NULL, FALSE); return out_buf[0]; } } #if !defined (_STLP_NO_WCHAR_T) _Locale_mask_t _Locale_wchar_ctype(_Locale_ctype_t* ltype, wint_t c, _Locale_mask_t which_bits) { wchar_t buf[2]; WORD out[2]; buf[0] = c; buf[1] = 0; GetStringTypeW(CT_CTYPE1, buf, -1, out); (void*)ltype; return (_Locale_mask_t)out[0] & which_bits; } wint_t _Locale_wchar_tolower(_Locale_ctype_t* ltype, wint_t c) { wchar_t in_c = c; wchar_t res; LCMapStringW(ltype->lc.id, LCMAP_LOWERCASE, &in_c, 1, &res, 1); return res; } wint_t _Locale_wchar_toupper(_Locale_ctype_t* ltype, wint_t c) { wchar_t in_c = c; wchar_t res; LCMapStringW(ltype->lc.id, LCMAP_UPPERCASE, &in_c, 1, &res, 1); return res; } #endif #if !defined (_STLP_NO_MBSTATE_T) int _Locale_mb_cur_max (_Locale_ctype_t * ltype) { CPINFO CPInfo; if (!GetCPInfo(ltype->cp, &CPInfo)) return 0; return CPInfo.MaxCharSize; } int _Locale_mb_cur_min (_Locale_ctype_t *dummy) { (void*)dummy; return 1; } int _Locale_is_stateless (_Locale_ctype_t * ltype) { CPINFO CPInfo; GetCPInfo(ltype->cp, &CPInfo); return (CPInfo.MaxCharSize == 1) ? 1 : 0; } #if defined (__BORLANDC__) && defined (__cplusplus) /* Weird Borland compiler behavior, even if native wint_t is imported to * STLport namespace in _cwchar.h, wint_t is still usable when scoped with * the Standard namespace (std::wint_t). As following WEOF macro is expended * to (std::wint_t)(0xFFFF) compilation failed. Repeating import avoid this * problem.*/ using __std_alias::wint_t; #endif wint_t _Locale_btowc(_Locale_ctype_t * ltype, int c) { wchar_t wc; if (c == EOF) return WEOF; MultiByteToWideChar(ltype->cp, MB_PRECOMPOSED, (char*)&c, 1, &wc, 1); return (wint_t)wc; } int _Locale_wctob(_Locale_ctype_t * ltype, wint_t wc) { char c; if (WideCharToMultiByte(ltype->cp, WC_COMPOSITECHECK | WC_DEFAULTCHAR, (wchar_t*)&wc, 1, &c, 1, NULL, NULL) == 0) return WEOF; /* Not single byte or error conversion. */ return (int)c; } static int __isleadbyte(int c, unsigned int *ctable) { return (ctable[(unsigned char)(c)] & _LEADBYTE); } static size_t __mbtowc(_Locale_ctype_t *l, wchar_t *dst, char src, mbstate_t *shift_state) { int result; if (*shift_state == 0) { if (__isleadbyte(src, l->ctable)) { ((unsigned char*)shift_state)[0] = src; return (size_t)-2; } else { result = MultiByteToWideChar(l->cp, MB_PRECOMPOSED, &src, 1, dst, 1); if (result == 0) return (size_t)-1; return 1; } } else { ((unsigned char*)shift_state)[1] = src; result = MultiByteToWideChar(l->cp, MB_PRECOMPOSED, (const char*)shift_state, 2, dst, 1); *shift_state = 0; if (result == 0) return (size_t)-1; return 1; } } #if !defined (_STLP_NO_WCHAR_T) size_t _Locale_mbtowc(_Locale_ctype_t *ltype, wchar_t *to, const char *from, size_t n, mbstate_t *shift_state) { CPINFO ci; int result; (void*)shift_state; GetCPInfo(ltype->cp, &ci); if (ci.MaxCharSize == 1) { /* Single byte encoding. */ *shift_state = (mbstate_t)0; result = MultiByteToWideChar(ltype->cp, MB_PRECOMPOSED, from, 1, to, 1); if (result == 0) return (size_t)-1; return result; } else { /* Multi byte encoding. */ size_t retval = 0, count = 0; while(n--) { retval = __mbtowc(ltype, to, *from, shift_state); if (retval == -2) { from++; count++; } else if (retval == -1) return -1; else return count+retval; } if (retval == -2) return (size_t)-2; return n; } } size_t _Locale_wctomb(_Locale_ctype_t *ltype, char *to, size_t n, const wchar_t c, mbstate_t *shift_state) { int size = \ WideCharToMultiByte(ltype->cp, WC_COMPOSITECHECK | WC_SEPCHARS, &c, 1, NULL, 0, NULL, NULL); if ((size_t)size > n) return (size_t)-2; if (n > INT_MAX) /* Limiting the output buf size to INT_MAX seems like reasonable to transform a single wchar_t. */ n = INT_MAX; size = \ WideCharToMultiByte(ltype->cp, WC_COMPOSITECHECK | WC_SEPCHARS, &c, 1, to, (int)n, NULL, NULL); if (size == 0) return (size_t)-1; (void*)shift_state; return (size_t)size; } #endif size_t _Locale_unshift(_Locale_ctype_t *ltype, mbstate_t *st, char *buf, size_t n, char **next) { (void*)ltype; if (*st == 0) { *next = buf; return 0; } else { if (n < 1) { *next = buf; return (size_t)-2; } *next = buf + 1; return 1; } } #endif /* _STLP_NO_MBSTATE_T */ #ifndef CSTR_EQUAL /* VC5SP3*/ # define CSTR_EQUAL 2 #endif #ifndef CSTR_LESS_THAN /* VC5SP3 */ # define CSTR_LESS_THAN 1 #endif static DWORD max_DWORD = 0xffffffff; static DWORD trim_size_t_to_DWORD(size_t n) { return n < (size_t)max_DWORD ? (DWORD)n : max_DWORD; } /* Collate */ /* This function takes care of the potential size_t DWORD different size. */ static int _Locale_strcmp_auxA(_Locale_collate_t* lcol, const char* s1, size_t n1, const char* s2, size_t n2) { int result = CSTR_EQUAL; while (n1 > 0 || n2 > 0) { DWORD size1 = trim_size_t_to_DWORD(n1); DWORD size2 = trim_size_t_to_DWORD(n2); result = CompareStringA(lcol->lc.id, 0, s1, size1, s2, size2); if (result != CSTR_EQUAL) break; n1 -= size1; n2 -= size2; } return result; } int _Locale_strcmp(_Locale_collate_t* lcol, const char* s1, size_t n1, const char* s2, size_t n2) { int result; if (__GetDefaultCP(lcol->lc.id) == atoi(lcol->cp)) { result = _Locale_strcmp_auxA(lcol, s1, n1, s2, n2); } else { char *buf1, *buf2; size_t size1, size2; buf1 = __ConvertToCP(atoi(lcol->cp), __GetDefaultCP(lcol->lc.id), s1, n1, &size1); buf2 = __ConvertToCP(atoi(lcol->cp), __GetDefaultCP(lcol->lc.id), s2, n2, &size2); result = _Locale_strcmp_auxA(lcol, buf1, size1, buf2, size2); free(buf1); free(buf2); } return (result == CSTR_EQUAL) ? 0 : (result == CSTR_LESS_THAN) ? -1 : 1; } #if !defined (_STLP_NO_WCHAR_T) /* This function takes care of the potential size_t DWORD different size. */ static int _Locale_strcmp_auxW(_Locale_collate_t* lcol, const wchar_t* s1, size_t n1, const wchar_t* s2, size_t n2) { int result = CSTR_EQUAL; while (n1 > 0 || n2 > 0) { DWORD size1 = trim_size_t_to_DWORD(n1); DWORD size2 = trim_size_t_to_DWORD(n2); result = CompareStringW(lcol->lc.id, 0, s1, size1, s2, size2); if (result != CSTR_EQUAL) break; n1 -= size1; n2 -= size2; } return result; } int _Locale_strwcmp(_Locale_collate_t* lcol, const wchar_t* s1, size_t n1, const wchar_t* s2, size_t n2) { int result; result = _Locale_strcmp_auxW(lcol, s1, n1, s2, n2); return (result == CSTR_EQUAL) ? 0 : (result == CSTR_LESS_THAN) ? -1 : 1; } #endif size_t _Locale_strxfrm(_Locale_collate_t* lcol, char* dst, size_t dst_size, const char* src, size_t src_size) { int result; /* The Windows API do not support transformation of very long strings (src_size > INT_MAX) * In this case the result will just be the input string: */ if (src_size > INT_MAX) { if (dst != 0) { _STLP_STRNCPY(dst, dst_size, src, src_size); } return src_size; } if (dst_size > INT_MAX) { /* now that we know that src_size <= INT_MAX we can safely decrease dst_size to INT_MAX. */ dst_size = INT_MAX; } if (__GetDefaultCP(lcol->lc.id) == atoi(lcol->cp)) result = LCMapStringA(lcol->lc.id, LCMAP_SORTKEY, src, (int)src_size, dst, (int)dst_size); else { char *buf; size_t size; buf = __ConvertToCP(atoi(lcol->cp), __GetDefaultCP(lcol->lc.id), src, src_size, &size); result = LCMapStringA(lcol->lc.id, LCMAP_SORTKEY, buf, (int)size, dst, (int)dst_size); free(buf); } return result != 0 ? result - 1 : 0; } #if !defined (_STLP_NO_WCHAR_T) size_t _Locale_strwxfrm(_Locale_collate_t* lcol, wchar_t* dst, size_t dst_size, const wchar_t* src, size_t src_size) { int result; /* see _Locale_strxfrm: */ if (src_size > INT_MAX) { if (dst != 0) { _STLP_WCSNCPY(dst, dst_size, src, src_size); } return src_size; } if (dst_size > INT_MAX) { dst_size = INT_MAX; } result = LCMapStringW(lcol->lc.id, LCMAP_SORTKEY, src, (int)src_size, dst, (int)dst_size); return result != 0 ? result - 1 : 0; } #endif /* Numeric */ static const char* __true_name = "true"; static const char* __false_name = "false"; char _Locale_decimal_point(_Locale_numeric_t* lnum) { return lnum->decimal_point[0]; } char _Locale_thousands_sep(_Locale_numeric_t* lnum) { return lnum->thousands_sep[0]; } const char* _Locale_grouping(_Locale_numeric_t * lnum) { if (!lnum->grouping) return ""; else return lnum->grouping; } const char * _Locale_true(_Locale_numeric_t * lnum) { (void*)lnum; return __true_name; /* NT does't provide information about this */ } const char * _Locale_false(_Locale_numeric_t * lnum) { (void*)lnum; return __false_name; /* NT does't provide information about this */ } /* Monetary */ const char* _Locale_int_curr_symbol(_Locale_monetary_t * lmon) { return lmon->int_curr_symbol; } const char* _Locale_currency_symbol(_Locale_monetary_t * lmon) { return lmon->curr_symbol; } char _Locale_mon_decimal_point(_Locale_monetary_t * lmon) { return lmon->decimal_point[0]; } char _Locale_mon_thousands_sep(_Locale_monetary_t * lmon) { return lmon->thousands_sep[0]; } const char* _Locale_mon_grouping(_Locale_monetary_t * lmon) { if (!lmon->grouping) return ""; else return lmon->grouping; } const char* _Locale_positive_sign(_Locale_monetary_t * lmon) { return lmon->positive_sign; } const char* _Locale_negative_sign(_Locale_monetary_t * lmon) { return lmon->negative_sign; } char _Locale_int_frac_digits(_Locale_monetary_t * lmon) { return (char)lmon->int_frac_digits; } char _Locale_frac_digits(_Locale_monetary_t * lmon) { return (char)lmon->frac_digits; } int _Locale_p_cs_precedes(_Locale_monetary_t * lmon) { char loc_data[2]; GetLocaleInfoA(lmon->lc.id, LOCALE_IPOSSYMPRECEDES, loc_data, 2); if (loc_data[0] == '0') return 0; else if (loc_data[0] == '1') return 1; else return -1; } int _Locale_p_sep_by_space(_Locale_monetary_t * lmon) { char loc_data[2]; GetLocaleInfoA(lmon->lc.id, LOCALE_IPOSSEPBYSPACE, loc_data, 2); if (loc_data[0] == '0') return 0; else if (loc_data[0] == '1') return 1; else return -1; } int _Locale_p_sign_posn(_Locale_monetary_t * lmon) { char loc_data[2]; GetLocaleInfoA(lmon->lc.id, LOCALE_IPOSSIGNPOSN, loc_data, 2); return atoi(loc_data); } int _Locale_n_cs_precedes(_Locale_monetary_t * lmon) { char loc_data[2]; GetLocaleInfoA(lmon->lc.id, LOCALE_INEGSYMPRECEDES, loc_data, 2); if (loc_data[0] == '0') return 0; else if (loc_data[0] == '1') return 1; else return -1; } int _Locale_n_sep_by_space(_Locale_monetary_t * lmon) { char loc_data[2]; GetLocaleInfoA(lmon->lc.id, LOCALE_INEGSEPBYSPACE, loc_data, 2); if (loc_data[0] == '0') return 0; else if (loc_data[0] == '1') return 1; else return -1; } int _Locale_n_sign_posn(_Locale_monetary_t * lmon) { char loc_data[2]; GetLocaleInfoA(lmon->lc.id, LOCALE_INEGSIGNPOSN, loc_data, 2); return atoi(loc_data); } /* Time */ const char * _Locale_full_monthname(_Locale_time_t * ltime, int month) { const char **names = (const char**)ltime->month; return names[month]; } const char * _Locale_abbrev_monthname(_Locale_time_t * ltime, int month) { const char **names = (const char**)ltime->abbrev_month; return names[month]; } const char * _Locale_full_dayofweek(_Locale_time_t * ltime, int day) { const char **names = (const char**)ltime->dayofweek; return names[day]; } const char * _Locale_abbrev_dayofweek(_Locale_time_t * ltime, int day) { const char **names = (const char**)ltime->abbrev_dayofweek; return names[day]; } const char* _Locale_d_t_fmt(_Locale_time_t* ltime) { return ltime->date_time_format; } const char* _Locale_long_d_t_fmt(_Locale_time_t* ltime) { return ltime->long_date_time_format; } const char* _Locale_d_fmt(_Locale_time_t* ltime) { return ltime->date_format; } const char* _Locale_long_d_fmt(_Locale_time_t* ltime) { return ltime->long_date_format; } const char* _Locale_t_fmt(_Locale_time_t* ltime) { return ltime->time_format; } const char* _Locale_am_str(_Locale_time_t* ltime) { return ltime->am; } const char* _Locale_pm_str(_Locale_time_t* ltime) { return ltime->pm; } /* Messages */ int _Locale_catopen(_Locale_messages_t* __DUMMY_PAR1, const char* __DUMMY_PAR) { (void*)__DUMMY_PAR1; (void*)__DUMMY_PAR; return -1; } void _Locale_catclose(_Locale_messages_t* __DUMMY_PAR1, int __DUMMY_PAR) { (void*)__DUMMY_PAR1; (void*)&__DUMMY_PAR; } const char* _Locale_catgets(_Locale_messages_t* __DUMMY_PAR1, int __DUMMY_PAR2, int __DUMMY_PAR3, int __DUMMY_PAR4, const char *dfault) { (void*)__DUMMY_PAR1; (void*)&__DUMMY_PAR2; (void*)&__DUMMY_PAR3; (void*)&__DUMMY_PAR4; return dfault; } #ifdef __cplusplus } /* extern C */ _STLP_END_NAMESPACE #endif void __FixGrouping(char *grouping) { /* This converts NT version which uses '0' instead of 0, etc ; to ANSI */ while (*grouping) { if (*grouping >= '0' && *grouping <= '9') { *grouping = *grouping - '0'; ++grouping; } else if (*grouping == ';') { /* remove ';' */ char *tmp = grouping; for (; *tmp; ++tmp) *tmp = *(tmp + 1); } else ++grouping; } } const char* __ConvertName(const char* lname, LOCALECONV* ConvTable, int TableSize) { int i; int cmp; int low = 0; int high = TableSize - 1; /* typical binary search - do until no more to search or match */ while (low <= high) { i = (low + high) / 2; if ((cmp = lstrcmpiA(lname, (*(ConvTable + i)).name)) == 0) return (*(ConvTable + i)).abbrev; else if (cmp < 0) high = i - 1; else low = i + 1; } return lname; } int __ParseLocaleString(const char* lname, char* lang, char* ctry, char* page) { int param = 0; size_t len; size_t tmpLen; if (lname[0] == 0) return 0; /* We look for the first country separator '_' */ len = strcspn(lname, "_"); if (lname[len] == '_') { if (len == 0 || len > MAX_LANG_LEN) return -1; /* empty lang is invalid*/ _STLP_STRNCPY(lang, MAX_LANG_LEN + 1, lname, len); lname += len + 1; ++param; } /* We look for the last code page separator '.' */ len = -1; tmpLen = strcspn(lname, "."); while (lname[tmpLen] == '.') { len = tmpLen; ++tmpLen; tmpLen += strcspn(lname + tmpLen, "."); } if (len != -1) { /* Means that we found a '.' */ if (param == 0) { /* We have no lang yet so we have to fill it first, no country */ if (len > MAX_LANG_LEN) return -1; if (len == 0) { /* No language nor country, only code page */ ++param; } else { _STLP_STRNCPY(lang, MAX_LANG_LEN + 1, lname, len); } ++param; } else { /* We already have a lang so we are now looking for the country: */ if (len == 0) return -1; /* We forbid locale name with the "_." motif in it */ if (len > MAX_CTRY_LEN) return -1; _STLP_STRNCPY(ctry, MAX_CTRY_LEN + 1, lname, len); } ++param; lname += len + 1; } /* We look for ',' for compatibility with POSIX */ len = strcspn(lname, ","); switch (param) { case 0: if (len > MAX_LANG_LEN) return -1; _STLP_STRNCPY(lang, MAX_LANG_LEN + 1, lname, len); break; case 1: if (len > MAX_CTRY_LEN) return -1; _STLP_STRNCPY(ctry, MAX_CTRY_LEN + 1, lname, len); break; default: if (len > MAX_CP_LEN) return -1; _STLP_STRNCPY(page, MAX_CP_LEN + 1, lname, len); break; } /* ',' POSIX modifier is not used in NT */ return 0; } /* Data necessary for find LCID*/ static CRITICAL_SECTION __criticalSection; static int __FindFlag; static LCID __FndLCID; static const char* __FndLang; static const char* __FndCtry; void _Locale_init() { InitializeCriticalSection(&__criticalSection); } void _Locale_final() { DeleteCriticalSection(&__criticalSection); } static LCID LocaleFromHex(const char* locale) { unsigned long result = 0; int digit; while (*locale) { result <<= 4; digit = (*locale >= '0' && *locale <= '9') ? *locale - '0': (*locale >= 'A' && *locale <= 'F') ? (*locale - 'A') + 10 : (*locale - 'a') + 10; result += digit; ++locale; } return (LCID)result; } static BOOL CALLBACK EnumLocalesProcA(LPSTR locale) { LCID lcid = LocaleFromHex(locale); int LangFlag = 0, CtryFlag = !__FndCtry; static char Lang[MAX_LANG_LEN], Ctry[MAX_CTRY_LEN]; GetLocaleInfoA(lcid, LOCALE_SENGLANGUAGE, Lang, MAX_LANG_LEN); if (lstrcmpiA(Lang, __FndLang) != 0) { GetLocaleInfoA(lcid, LOCALE_SABBREVLANGNAME, Lang, MAX_LANG_LEN); if (lstrcmpiA(Lang, __FndLang) != 0) { GetLocaleInfoA(lcid, LOCALE_SISO639LANGNAME, Lang, MAX_LANG_LEN); if (lstrcmpiA(Lang, __FndLang) == 0) LangFlag = 1; } else LangFlag = 1; } else LangFlag = 1; if (__FndCtry) { GetLocaleInfoA(lcid, LOCALE_SENGCOUNTRY, Ctry, MAX_CTRY_LEN); if (lstrcmpiA(Ctry, __FndCtry) != 0) { GetLocaleInfoA(lcid, LOCALE_SABBREVCTRYNAME, Ctry, MAX_CTRY_LEN); if (lstrcmpiA(Ctry, __FndCtry) != 0) { GetLocaleInfoA(lcid, LOCALE_SISO3166CTRYNAME, Ctry, MAX_CTRY_LEN); if (lstrcmpiA(Ctry, __FndCtry) == 0) CtryFlag = 1; } else CtryFlag = 1; } else CtryFlag = 1; } if (LangFlag && CtryFlag) { __FindFlag = 1; __FndLCID = lcid; return FALSE; } return TRUE; } int __GetLCID(const char* lang, const char* ctry, LCID* lcid) { int ret; EnterCriticalSection(&__criticalSection); __FindFlag = 0; __FndLang = lang; __FndCtry = ctry; EnumSystemLocalesA(EnumLocalesProcA, LCID_INSTALLED); if (__FindFlag != 0) *lcid = __FndLCID; ret = __FindFlag != 0 ? 0 : -1; LeaveCriticalSection(&__criticalSection); return ret; } int __GetLCIDFromName(const char* lname, LCID* lcid, char* cp, _Locale_lcid_t *hint) { char lang[MAX_LANG_LEN + 1], ctry[MAX_CTRY_LEN + 1], page[MAX_CP_LEN + 1]; int result = 0; if (lname == NULL || lname[0] == 0) { *lcid = LOCALE_USER_DEFAULT; return 0; } memset(lang, 0, MAX_LANG_LEN + 1); memset(ctry, 0, MAX_CTRY_LEN + 1); memset(page, 0, MAX_CP_LEN + 1); if (__ParseLocaleString(lname, lang, ctry, page) == -1) return -1; if (hint != 0) { *lcid = hint->id; } else { if (lang[0] == 0 && ctry[0] == 0) *lcid = LOCALE_USER_DEFAULT; /* Only code page given. */ else { if (ctry[0] == 0) result = __GetLCID(__ConvertName(lang, __rg_language, sizeof(__rg_language) / sizeof(LOCALECONV)), NULL, lcid); else { result = __GetLCID(__ConvertName(lang, __rg_language, sizeof(__rg_language) / sizeof(LOCALECONV)), __ConvertName(ctry, __rg_country, sizeof(__rg_country) / sizeof(LOCALECONV)), lcid); if (result != 0) { /* Non NLS mapping might introduce problem with some locales when only one entry is mapped, * the lang or the country (example: chinese locales like 'chinese_taiwan' gives 'CHS_taiwan' * that do not exists in system). This is why we are giving this locale an other chance by * calling __GetLCID without the mapping. */ result = __GetLCID(lang, ctry, lcid); } } } } if (result == 0) { /* Handling code page */ if (lstrcmpiA(page, "ACP") == 0 || page[0] == 0) my_ltoa(__intGetACP(*lcid), cp); else if (lstrcmpiA(page, "OCP") == 0) my_ltoa(__intGetOCP(*lcid), cp); else _STLP_STRNCPY(cp, MAX_CP_LEN + 1, page, 5); /* Code page must be an integer value, * 0 returned by __intGetACP and 1 returned by __intGetOCP are invalid * values. */ if (cp[1] == 0 && (cp[0] == '0' || cp[1] == '1')) return -1; else if (atoi(cp) == 0) return -1; } return result; } char const* __GetLocaleName(LCID lcid, const char* cp, char* buf) { char lang[MAX_LANG_LEN + 1], ctry[MAX_CTRY_LEN + 1]; GetLocaleInfoA(lcid, LOCALE_SENGLANGUAGE, lang, MAX_LANG_LEN); GetLocaleInfoA(lcid, LOCALE_SENGCOUNTRY, ctry, MAX_CTRY_LEN); _STLP_STRCPY2(buf, _Locale_MAX_SIMPLE_NAME, lang); _STLP_STRCAT2(buf, _Locale_MAX_SIMPLE_NAME, "_"); _STLP_STRCAT2(buf, _Locale_MAX_SIMPLE_NAME, ctry); _STLP_STRCAT2(buf, _Locale_MAX_SIMPLE_NAME, "."); _STLP_STRCAT2(buf, _Locale_MAX_SIMPLE_NAME, cp); return buf; } static const char* __loc_categories[]= { "LC_ALL", "LC_COLLATE", "LC_CTYPE", "LC_MONETARY", "LC_NUMERIC", "LC_TIME" }; char const* __Extract_locale_name(const char* loc, int category, char* buf) { char *expr; size_t len_name; buf[0] = 0; #if defined (__BORLANDC__) if (category < LC_MIN || category > LC_MAX) return NULL; switch (category) { case 0xFF: category = 0; break; case 0x01: category = 1; break; case 0x02: category = 2; break; case 0x04: category = 3; break; case 0x10: category = 4; break; case 0x20: category = 5; break; default : category = 0; } #else if (category < LC_ALL || category > LC_MAX) return NULL; #endif if (loc[0] == 'L' && loc[1] == 'C' && loc[2] == '_') { expr = strstr((char*)loc, __loc_categories[category]); if (expr == NULL) return NULL; /* Category not found. */ expr = strchr(expr, '='); if (expr == NULL) return NULL; ++expr; len_name = strcspn(expr, ";"); len_name = len_name > _Locale_MAX_SIMPLE_NAME ? _Locale_MAX_SIMPLE_NAME : len_name; _STLP_STRNCPY(buf, _Locale_MAX_SIMPLE_NAME, expr, len_name); buf[len_name] = 0; return buf; } else { _STLP_STRNCPY(buf, _Locale_MAX_SIMPLE_NAME, loc, _Locale_MAX_SIMPLE_NAME); return buf; } } char const* __TranslateToSystem(const char* lname, char* buf, _Locale_lcid_t* hint) { LCID lcid; char cp[MAX_CP_LEN + 1]; if (__GetLCIDFromName(lname, &lcid, cp, hint) != 0) return NULL; return __GetLocaleName(lcid, cp, buf); } void __GetLocaleInfoUsingACP(LCID lcid, const char* cp, LCTYPE lctype, char* buf, int buf_size) { wchar_t *Buffer; int BufferSize; GetLocaleInfoA(lcid, lctype, buf, buf_size); BufferSize = MultiByteToWideChar(CP_ACP, 0, buf, -1, NULL, 0); Buffer = (wchar_t*)malloc(sizeof(wchar_t) * (BufferSize + 1)); MultiByteToWideChar(CP_ACP, 0, buf, -1, Buffer, BufferSize); WideCharToMultiByte(atoi(cp), 0, Buffer, -1, buf, buf_size, NULL, NULL); free(Buffer); } /* Return 0 if ANSI code page not used */ int __intGetACP(LCID lcid) { char cp[6]; GetLocaleInfoA(lcid, LOCALE_IDEFAULTANSICODEPAGE, cp, 6); return atoi(cp); } /* Return 1 if OEM code page not used */ int __intGetOCP(LCID lcid) { char cp[6]; GetLocaleInfoA(lcid, LOCALE_IDEFAULTCODEPAGE, cp, 6); return atoi(cp); } int __GetDefaultCP(LCID lcid) { int cp = __intGetACP(lcid); if (cp == 0) return __intGetOCP(lcid); else return cp; } static int trim_size_t_to_int(size_t n) { return n < (size_t)INT_MAX ? (int)n : INT_MAX; } char* __ConvertToCP(int from_cp, int to_cp, const char *from, size_t size, size_t *ret_buf_size) { size_t wbuffer_size, buffer_size, from_offset, wbuf_offset; int from_size, to_size, wbuf_size; wchar_t *wbuffer; char* buffer; size_t orig_size = size; wbuffer_size = 0; from_offset = 0; while (size > 0) { from_size = trim_size_t_to_int(size); wbuffer_size += MultiByteToWideChar(from_cp, MB_PRECOMPOSED, from + from_offset, from_size, NULL, 0); from_offset += from_size; size -= from_size; } wbuffer = (wchar_t*)malloc(sizeof(wchar_t)*wbuffer_size); size = orig_size; wbuf_offset = 0; from_offset = 0; while (size > 0) { from_size = trim_size_t_to_int(size); wbuf_size = trim_size_t_to_int(wbuffer_size - wbuf_offset); wbuf_offset += MultiByteToWideChar(from_cp, MB_PRECOMPOSED, from + from_offset, from_size, wbuffer + wbuf_offset, wbuf_size); from_offset += from_size; size -= from_size; } buffer_size = 0; wbuf_offset = 0; size = wbuffer_size; while (size > 0) { wbuf_size = trim_size_t_to_int(size); buffer_size += WideCharToMultiByte(to_cp, WC_COMPOSITECHECK | WC_SEPCHARS, wbuffer + wbuf_offset, wbuf_size, NULL, 0, NULL, FALSE); wbuf_offset += wbuf_size; size -= wbuf_size; } buffer = (char*)malloc(buffer_size); *ret_buf_size = buffer_size; size = wbuffer_size; wbuf_offset = 0; while (size > 0) { wbuf_size = trim_size_t_to_int(size); to_size = trim_size_t_to_int(buffer_size); buffer_size -= WideCharToMultiByte(to_cp, WC_COMPOSITECHECK | WC_SEPCHARS, wbuffer + wbuf_offset, wbuf_size, buffer, to_size, NULL, FALSE); wbuf_offset += wbuf_size; size -= wbuf_size; } free(wbuffer); return buffer; } #ifdef __cplusplus } #endif

• ソフトウェア開発
• ホームページ制作
• Doxygen Source Document
• Tcl Source Document