The Tor Browser / file comparison

comparison: build/stlport/src/c_locale_win32/c_wlocale_win32.c

build/stlport/src/c_locale_win32/c_wlocale_win32.c

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:0a14648798ae
1 /*
2 * Copyright (c) 2007 2008
3 * Francois Dumont
4 *
5 * This material is provided "as is", with absolutely no warranty expressed
6 * or implied. Any use is at your own risk.
7 *
8 * Permission to use or copy this software for any purpose is hereby granted
9 * without fee, provided the above notices are retained on all copies.
10 * Permission to modify the code and to distribute modified code is granted,
11 * provided the above notices are retained, and a notice that the code was
12 * modified is included with the above copyright notice.
13 *
14 */
15
16 #if defined (_STLP_USE_SAFE_STRING_FUNCTIONS)
17 # define _STLP_WCSNCPY(D, DS, S, C) wcsncpy_s(D, DS, S, C)
18 #else
19 # define _STLP_WCSNCPY(D, DS, S, C) wcsncpy(D, S, C)
20 #endif
21
22 static const wchar_t* __wtrue_name = L"true";
23 static const wchar_t* __wfalse_name = L"false";
24
25 typedef struct _Locale_codecvt {
26 _Locale_lcid_t lc;
27 UINT cp;
28 unsigned char cleads[256 / CHAR_BIT];
29 unsigned char max_char_size;
30 DWORD mbtowc_flags;
31 DWORD wctomb_flags;
32 } _Locale_codecvt_t;
33
34 /* Ctype */
35 _Locale_mask_t _WLocale_ctype(_Locale_ctype_t* ltype, wint_t c,
36 _Locale_mask_t which_bits) {
37 wchar_t buf[2];
38 WORD out[2];
39 buf[0] = c; buf[1] = 0;
40 GetStringTypeW(CT_CTYPE1, buf, -1, out);
41 _STLP_MARK_PARAMETER_AS_UNUSED(ltype)
42 return (_Locale_mask_t)(MapCtypeMask(out[0]) & which_bits);
43 }
44
45 wint_t _WLocale_tolower(_Locale_ctype_t* ltype, wint_t c) {
46 wchar_t in_c = c;
47 wchar_t res;
48
49 LCMapStringW(ltype->lc.id, LCMAP_LOWERCASE, &in_c, 1, &res, 1);
50 return res;
51 }
52
53 wint_t _WLocale_toupper(_Locale_ctype_t* ltype, wint_t c) {
54 wchar_t in_c = c;
55 wchar_t res;
56
57 LCMapStringW(ltype->lc.id, LCMAP_UPPERCASE, &in_c, 1, &res, 1);
58 return res;
59 }
60
61 _Locale_codecvt_t* _Locale_codecvt_create(const char * name, _Locale_lcid_t* lc_hint, int *__err_code) {
62 char cp_name[MAX_CP_LEN + 1];
63 unsigned char *ptr;
64 CPINFO CPInfo;
65 int i;
66
67 _Locale_codecvt_t *lcodecvt = (_Locale_codecvt_t*)malloc(sizeof(_Locale_codecvt_t));
68
69 if (!lcodecvt) { *__err_code = _STLP_LOC_NO_MEMORY; return lcodecvt; }
70 memset(lcodecvt, 0, sizeof(_Locale_codecvt_t));
71
72 if (__GetLCIDFromName(name, &lcodecvt->lc.id, cp_name, lc_hint) == -1)
73 { free(lcodecvt); *__err_code = _STLP_LOC_UNKNOWN_NAME; return NULL; }
74
75 lcodecvt->cp = atoi(cp_name);
76 if (!GetCPInfo(lcodecvt->cp, &CPInfo)) { free(lcodecvt); return NULL; }
77
78 if (lcodecvt->cp != CP_UTF7 && lcodecvt->cp != CP_UTF8) {
79 lcodecvt->mbtowc_flags = MB_PRECOMPOSED;
80 lcodecvt->wctomb_flags = WC_COMPOSITECHECK | WC_SEPCHARS;
81 }
82 lcodecvt->max_char_size = CPInfo.MaxCharSize;
83
84 if (CPInfo.MaxCharSize > 1) {
85 for (ptr = (unsigned char*)CPInfo.LeadByte; *ptr && *(ptr + 1); ptr += 2)
86 for (i = *ptr; i <= *(ptr + 1); ++i) lcodecvt->cleads[i / CHAR_BIT] |= (0x01 << i % CHAR_BIT);
87 }
88
89 return lcodecvt;
90 }
91
92 char const* _Locale_codecvt_name(const _Locale_codecvt_t* lcodecvt, char* buf) {
93 char cp_buf[MAX_CP_LEN + 1];
94 my_ltoa(lcodecvt->cp, cp_buf);
95 return __GetLocaleName(lcodecvt->lc.id, cp_buf, buf);
96 }
97
98 void _Locale_codecvt_destroy(_Locale_codecvt_t* lcodecvt) {
99 if (!lcodecvt) return;
100
101 free(lcodecvt);
102 }
103
104 int _WLocale_mb_cur_max (_Locale_codecvt_t * lcodecvt)
105 { return lcodecvt->max_char_size; }
106
107 int _WLocale_mb_cur_min (_Locale_codecvt_t *lcodecvt) {
108 _STLP_MARK_PARAMETER_AS_UNUSED(lcodecvt)
109 return 1;
110 }
111
112 int _WLocale_is_stateless (_Locale_codecvt_t * lcodecvt)
113 { return (lcodecvt->max_char_size == 1) ? 1 : 0; }
114
115 static int __isleadbyte(int i, unsigned char *ctable) {
116 unsigned char c = (unsigned char)i;
117 return (ctable[c / CHAR_BIT] & (0x01 << c % CHAR_BIT));
118 }
119
120 static int __mbtowc(_Locale_codecvt_t *l, wchar_t *dst, const char *from, unsigned int count) {
121 int result;
122
123 if (l->cp == CP_UTF7 || l->cp == CP_UTF8) {
124 result = MultiByteToWideChar(l->cp, l->mbtowc_flags, from, count, dst, 1);
125 if (result == 0) {
126 switch (GetLastError()) {
127 case ERROR_NO_UNICODE_TRANSLATION:
128 return -2;
129 default:
130 return -1;
131 }
132 }
133 }
134 else {
135 if (count == 1 && __isleadbyte(*from, l->cleads)) return (size_t)-2;
136 result = MultiByteToWideChar(l->cp, l->mbtowc_flags, from, count, dst, 1);
137 if (result == 0) return -1;
138 }
139
140 return result;
141 }
142
143 size_t _WLocale_mbtowc(_Locale_codecvt_t *lcodecvt, wchar_t *to,
144 const char *from, size_t n, mbstate_t *shift_state) {
145 int result;
146 _STLP_MARK_PARAMETER_AS_UNUSED(shift_state)
147 if (lcodecvt->max_char_size == 1) { /* Single byte encoding. */
148 result = MultiByteToWideChar(lcodecvt->cp, lcodecvt->mbtowc_flags, from, 1, to, 1);
149 if (result == 0) return (size_t)-1;
150 return result;
151 }
152 else { /* Multi byte encoding. */
153 int retval;
154 unsigned int count = 1;
155 while (n--) {
156 retval = __mbtowc(lcodecvt, to, from, count);
157 if (retval == -2)
158 { if (++count > ((unsigned int)lcodecvt->max_char_size)) return (size_t)-1; }
159 else if (retval == -1)
160 { return (size_t)-1; }
161 else
162 { return count; }
163 }
164 return (size_t)-2;
165 }
166 }
167
168 size_t _WLocale_wctomb(_Locale_codecvt_t *lcodecvt, char *to, size_t n,
169 const wchar_t c, mbstate_t *shift_state) {
170 int size = WideCharToMultiByte(lcodecvt->cp, lcodecvt->wctomb_flags, &c, 1, NULL, 0, NULL, NULL);
171
172 if (!size) return (size_t)-1;
173 if ((size_t)size > n) return (size_t)-2;
174
175 if (n > INT_MAX)
176 /* Limiting the output buf size to INT_MAX seems like reasonable to transform a single wchar_t. */
177 n = INT_MAX;
178
179 WideCharToMultiByte(lcodecvt->cp, lcodecvt->wctomb_flags, &c, 1, to, (int)n, NULL, NULL);
180
181 _STLP_MARK_PARAMETER_AS_UNUSED(shift_state)
182 return (size_t)size;
183 }
184
185 size_t _WLocale_unshift(_Locale_codecvt_t *lcodecvt, mbstate_t *st,
186 char *buf, size_t n, char **next) {
187 /* _WLocale_wctomb do not even touch to st, there is nothing to unshift in this localization implementation. */
188 _STLP_MARK_PARAMETER_AS_UNUSED(lcodecvt)
189 _STLP_MARK_PARAMETER_AS_UNUSED(st)
190 _STLP_MARK_PARAMETER_AS_UNUSED(&n)
191 *next = buf;
192 return 0;
193 }
194
195 /* Collate */
196 /* This function takes care of the potential size_t DWORD different size. */
197 static int _WLocale_strcmp_aux(_Locale_collate_t* lcol,
198 const wchar_t* s1, size_t n1,
199 const wchar_t* s2, size_t n2) {
200 int result = CSTR_EQUAL;
201 while (n1 > 0 || n2 > 0) {
202 DWORD size1 = trim_size_t_to_DWORD(n1);
203 DWORD size2 = trim_size_t_to_DWORD(n2);
204 result = CompareStringW(lcol->lc.id, 0, s1, size1, s2, size2);
205 if (result != CSTR_EQUAL)
206 break;
207 n1 -= size1;
208 n2 -= size2;
209 }
210 return result;
211 }
212
213 int _WLocale_strcmp(_Locale_collate_t* lcol,
214 const wchar_t* s1, size_t n1,
215 const wchar_t* s2, size_t n2) {
216 int result;
217 result = _WLocale_strcmp_aux(lcol, s1, n1, s2, n2);
218 return (result == CSTR_EQUAL) ? 0 : (result == CSTR_LESS_THAN) ? -1 : 1;
219 }
220
221 size_t _WLocale_strxfrm(_Locale_collate_t* lcol,
222 wchar_t* dst, size_t dst_size,
223 const wchar_t* src, size_t src_size) {
224 int result, i;
225
226 /* see _Locale_strxfrm: */
227 if (src_size > INT_MAX) {
228 if (dst != 0) {
229 _STLP_WCSNCPY(dst, dst_size, src, src_size);
230 }
231 return src_size;
232 }
233 if (dst_size > INT_MAX) {
234 dst_size = INT_MAX;
235 }
236 result = LCMapStringW(lcol->lc.id, LCMAP_SORTKEY, src, (int)src_size, dst, (int)dst_size);
237 if (result != 0 && dst != 0) {
238 for (i = result - 1; i >= 0; --i) {
239 dst[i] = ((unsigned char*)dst)[i];
240 }
241 }
242 return result != 0 ? result - 1 : 0;
243 }
244
245 /* Numeric */
246 wchar_t _WLocale_decimal_point(_Locale_numeric_t* lnum) {
247 wchar_t buf[4];
248 GetLocaleInfoW(lnum->lc.id, LOCALE_SDECIMAL, buf, 4);
249 return buf[0];
250 }
251
252 wchar_t _WLocale_thousands_sep(_Locale_numeric_t* lnum) {
253 wchar_t buf[4];
254 GetLocaleInfoW(lnum->lc.id, LOCALE_STHOUSAND, buf, 4);
255 return buf[0];
256 }
257
258 const wchar_t * _WLocale_true(_Locale_numeric_t* lnum, wchar_t* buf, size_t bufSize) {
259 _STLP_MARK_PARAMETER_AS_UNUSED(lnum)
260 _STLP_MARK_PARAMETER_AS_UNUSED(buf)
261 _STLP_MARK_PARAMETER_AS_UNUSED(&bufSize)
262 return __wtrue_name;
263 }
264
265 const wchar_t * _WLocale_false(_Locale_numeric_t* lnum, wchar_t* buf, size_t bufSize) {
266 _STLP_MARK_PARAMETER_AS_UNUSED(lnum)
267 _STLP_MARK_PARAMETER_AS_UNUSED(buf)
268 _STLP_MARK_PARAMETER_AS_UNUSED(&bufSize)
269 return __wfalse_name;
270 }
271
272 /* Monetary */
273 const wchar_t* _WLocale_int_curr_symbol(_Locale_monetary_t * lmon, wchar_t* buf, size_t bufSize)
274 { GetLocaleInfoW(lmon->lc.id, LOCALE_SINTLSYMBOL, buf, (int)bufSize); return buf; }
275
276 const wchar_t* _WLocale_currency_symbol(_Locale_monetary_t * lmon, wchar_t* buf, size_t bufSize)
277 { GetLocaleInfoW(lmon->lc.id, LOCALE_SCURRENCY, buf, (int)bufSize); return buf; }
278
279 wchar_t _WLocale_mon_decimal_point(_Locale_monetary_t * lmon)
280 { return lmon->decimal_point[0]; }
281
282 wchar_t _WLocale_mon_thousands_sep(_Locale_monetary_t * lmon)
283 { return lmon->thousands_sep[0]; }
284
285 const wchar_t* _WLocale_positive_sign(_Locale_monetary_t * lmon, wchar_t* buf, size_t bufSize)
286 { GetLocaleInfoW(lmon->lc.id, LOCALE_SPOSITIVESIGN, buf, (int)bufSize); return buf; }
287
288 const wchar_t* _WLocale_negative_sign(_Locale_monetary_t * lmon, wchar_t* buf, size_t bufSize)
289 { GetLocaleInfoW(lmon->lc.id, LOCALE_SNEGATIVESIGN, buf, (int)bufSize); return buf; }
290
291 /* Time */
292 const wchar_t * _WLocale_full_monthname(_Locale_time_t * ltime, int month,
293 wchar_t* buf, size_t bufSize)
294 { GetLocaleInfoW(ltime->lc.id, LOCALE_SMONTHNAME1 + month, buf, (int)bufSize); return buf; }
295
296 const wchar_t * _WLocale_abbrev_monthname(_Locale_time_t * ltime, int month,
297 wchar_t* buf, size_t bufSize)
298 { GetLocaleInfoW(ltime->lc.id, LOCALE_SABBREVMONTHNAME1 + month, buf, (int)bufSize); return buf; }
299
300 const wchar_t * _WLocale_full_dayofweek(_Locale_time_t * ltime, int day,
301 wchar_t* buf, size_t bufSize)
302 { GetLocaleInfoW(ltime->lc.id, LOCALE_SDAYNAME1 + day, buf, (int)bufSize); return buf; }
303
304 const wchar_t * _WLocale_abbrev_dayofweek(_Locale_time_t * ltime, int day,
305 wchar_t* buf, size_t bufSize)
306 { GetLocaleInfoW(ltime->lc.id, LOCALE_SABBREVDAYNAME1 + day, buf, (int)bufSize); return buf; }
307
308 const wchar_t* _WLocale_am_str(_Locale_time_t* ltime,
309 wchar_t* buf, size_t bufSize)
310 { GetLocaleInfoW(ltime->lc.id, LOCALE_S1159, buf, (int)bufSize); return buf; }
311
312 const wchar_t* _WLocale_pm_str(_Locale_time_t* ltime,
313 wchar_t* buf, size_t bufSize)
314 { GetLocaleInfoW(ltime->lc.id, LOCALE_S2359, buf, (int)bufSize); return buf; }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial