?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel32/tests/pipe: Enable compilation with long types.
[wine.git] / dlls / kernelbase / locale.c
blob2f2154a0e7ca6aac5e4074a64f5b939803048373
1 /*
2 * Locale support
3 *
4 * Copyright 1995 Martin von Loewis
5 * Copyright 1998 David Lee Lambert
6 * Copyright 2000 Julio César Gázquez
7 * Copyright 2003 Jon Griffiths
8 * Copyright 2005 Dmitry Timoshkov
9 * Copyright 2002, 2019 Alexandre Julliard
10 *
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
15 *
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 */
25
26 #include <stdarg.h>
27 #include <stdlib.h>
28
29 #include "ntstatus.h"
30 #define WIN32_NO_STATUS
31 #define WINNORMALIZEAPI
32 #include "windef.h"
33 #include "winbase.h"
34 #include "winreg.h"
35 #include "winnls.h"
36 #include "winuser.h"
37 #include "winternl.h"
38 #include "kernelbase.h"
39 #include "wine/debug.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(nls);
42
43 #define CALINFO_MAX_YEAR 2029
44
45 extern const unsigned int collation_table[] DECLSPEC_HIDDEN;
46
47 static HANDLE kernel32_handle;
48
49 static const struct registry_value
50 {
51 DWORD lctype;
52 const WCHAR *name;
53 } registry_values[] =
54 {
55 { LOCALE_ICALENDARTYPE, L"iCalendarType" },
56 { LOCALE_ICURRDIGITS, L"iCurrDigits" },
57 { LOCALE_ICURRENCY, L"iCurrency" },
58 { LOCALE_IDIGITS, L"iDigits" },
59 { LOCALE_IFIRSTDAYOFWEEK, L"iFirstDayOfWeek" },
60 { LOCALE_IFIRSTWEEKOFYEAR, L"iFirstWeekOfYear" },
61 { LOCALE_ILZERO, L"iLZero" },
62 { LOCALE_IMEASURE, L"iMeasure" },
63 { LOCALE_INEGCURR, L"iNegCurr" },
64 { LOCALE_INEGNUMBER, L"iNegNumber" },
65 { LOCALE_IPAPERSIZE, L"iPaperSize" },
66 { LOCALE_ITIME, L"iTime" },
67 { LOCALE_S1159, L"s1159" },
68 { LOCALE_S2359, L"s2359" },
69 { LOCALE_SCURRENCY, L"sCurrency" },
70 { LOCALE_SDATE, L"sDate" },
71 { LOCALE_SDECIMAL, L"sDecimal" },
72 { LOCALE_SGROUPING, L"sGrouping" },
73 { LOCALE_SLIST, L"sList" },
74 { LOCALE_SLONGDATE, L"sLongDate" },
75 { LOCALE_SMONDECIMALSEP, L"sMonDecimalSep" },
76 { LOCALE_SMONGROUPING, L"sMonGrouping" },
77 { LOCALE_SMONTHOUSANDSEP, L"sMonThousandSep" },
78 { LOCALE_SNEGATIVESIGN, L"sNegativeSign" },
79 { LOCALE_SPOSITIVESIGN, L"sPositiveSign" },
80 { LOCALE_SSHORTDATE, L"sShortDate" },
81 { LOCALE_STHOUSAND, L"sThousand" },
82 { LOCALE_STIME, L"sTime" },
83 { LOCALE_STIMEFORMAT, L"sTimeFormat" },
84 { LOCALE_SYEARMONTH, L"sYearMonth" },
85 /* The following are not listed under MSDN as supported,
86 * but seem to be used and also stored in the registry.
87 */
88 { LOCALE_SNAME, L"LocaleName" },
89 { LOCALE_ICOUNTRY, L"iCountry" },
90 { LOCALE_IDATE, L"iDate" },
91 { LOCALE_ILDATE, L"iLDate" },
92 { LOCALE_ITLZERO, L"iTLZero" },
93 { LOCALE_SCOUNTRY, L"sCountry" },
94 { LOCALE_SABBREVLANGNAME, L"sLanguage" },
95 { LOCALE_IDIGITSUBSTITUTION, L"Numshape" },
96 { LOCALE_SNATIVEDIGITS, L"sNativeDigits" },
97 { LOCALE_ITIMEMARKPOSN, L"iTimePrefix" },
98 };
99
100 static WCHAR *registry_cache[ARRAY_SIZE(registry_values)];
101
102 static const struct { UINT cp; const WCHAR *name; } codepage_names[] =
103 {
104 { 37, L"IBM EBCDIC US Canada" },
105 { 424, L"IBM EBCDIC Hebrew" },
106 { 437, L"OEM United States" },
107 { 500, L"IBM EBCDIC International" },
108 { 708, L"Arabic ASMO" },
109 { 720, L"Arabic (Transparent ASMO)" },
110 { 737, L"OEM Greek 437G" },
111 { 775, L"OEM Baltic" },
112 { 850, L"OEM Multilingual Latin 1" },
113 { 852, L"OEM Slovak Latin 2" },
114 { 855, L"OEM Cyrillic" },
115 { 856, L"Hebrew PC" },
116 { 857, L"OEM Turkish" },
117 { 860, L"OEM Portuguese" },
118 { 861, L"OEM Icelandic" },
119 { 862, L"OEM Hebrew" },
120 { 863, L"OEM Canadian French" },
121 { 864, L"OEM Arabic" },
122 { 865, L"OEM Nordic" },
123 { 866, L"OEM Russian" },
124 { 869, L"OEM Greek" },
125 { 874, L"ANSI/OEM Thai" },
126 { 875, L"IBM EBCDIC Greek" },
127 { 878, L"Russian KOI8" },
128 { 932, L"ANSI/OEM Japanese Shift-JIS" },
129 { 936, L"ANSI/OEM Simplified Chinese GBK" },
130 { 949, L"ANSI/OEM Korean Unified Hangul" },
131 { 950, L"ANSI/OEM Traditional Chinese Big5" },
132 { 1006, L"IBM Arabic" },
133 { 1026, L"IBM EBCDIC Latin 5 Turkish" },
134 { 1250, L"ANSI Eastern Europe" },
135 { 1251, L"ANSI Cyrillic" },
136 { 1252, L"ANSI Latin 1" },
137 { 1253, L"ANSI Greek" },
138 { 1254, L"ANSI Turkish" },
139 { 1255, L"ANSI Hebrew" },
140 { 1256, L"ANSI Arabic" },
141 { 1257, L"ANSI Baltic" },
142 { 1258, L"ANSI/OEM Viet Nam" },
143 { 1361, L"Korean Johab" },
144 { 10000, L"Mac Roman" },
145 { 10001, L"Mac Japanese" },
146 { 10002, L"Mac Traditional Chinese" },
147 { 10003, L"Mac Korean" },
148 { 10004, L"Mac Arabic" },
149 { 10005, L"Mac Hebrew" },
150 { 10006, L"Mac Greek" },
151 { 10007, L"Mac Cyrillic" },
152 { 10008, L"Mac Simplified Chinese" },
153 { 10010, L"Mac Romanian" },
154 { 10017, L"Mac Ukrainian" },
155 { 10021, L"Mac Thai" },
156 { 10029, L"Mac Latin 2" },
157 { 10079, L"Mac Icelandic" },
158 { 10081, L"Mac Turkish" },
159 { 10082, L"Mac Croatian" },
160 { 20127, L"US-ASCII (7bit)" },
161 { 20866, L"Russian KOI8" },
162 { 20932, L"EUC-JP" },
163 { 20949, L"Korean Wansung" },
164 { 21866, L"Ukrainian KOI8" },
165 { 28591, L"ISO 8859-1 Latin 1" },
166 { 28592, L"ISO 8859-2 Latin 2 (East European)" },
167 { 28593, L"ISO 8859-3 Latin 3 (South European)" },
168 { 28594, L"ISO 8859-4 Latin 4 (Baltic old)" },
169 { 28595, L"ISO 8859-5 Cyrillic" },
170 { 28596, L"ISO 8859-6 Arabic" },
171 { 28597, L"ISO 8859-7 Greek" },
172 { 28598, L"ISO 8859-8 Hebrew" },
173 { 28599, L"ISO 8859-9 Latin 5 (Turkish)" },
174 { 28600, L"ISO 8859-10 Latin 6 (Nordic)" },
175 { 28601, L"ISO 8859-11 Latin (Thai)" },
176 { 28603, L"ISO 8859-13 Latin 7 (Baltic)" },
177 { 28604, L"ISO 8859-14 Latin 8 (Celtic)" },
178 { 28605, L"ISO 8859-15 Latin 9 (Euro)" },
179 { 28606, L"ISO 8859-16 Latin 10 (Balkan)" },
180 { 65000, L"Unicode (UTF-7)" },
181 { 65001, L"Unicode (UTF-8)" }
182 };
183
184 /* Unicode expanded ligatures */
185 static const WCHAR ligatures[][5] =
186 {
187 { 0x00c6, 'A','E',0 },
188 { 0x00de, 'T','H',0 },
189 { 0x00df, 's','s',0 },
190 { 0x00e6, 'a','e',0 },
191 { 0x00fe, 't','h',0 },
192 { 0x0132, 'I','J',0 },
193 { 0x0133, 'i','j',0 },
194 { 0x0152, 'O','E',0 },
195 { 0x0153, 'o','e',0 },
196 { 0x01c4, 'D',0x017d,0 },
197 { 0x01c5, 'D',0x017e,0 },
198 { 0x01c6, 'd',0x017e,0 },
199 { 0x01c7, 'L','J',0 },
200 { 0x01c8, 'L','j',0 },
201 { 0x01c9, 'l','j',0 },
202 { 0x01ca, 'N','J',0 },
203 { 0x01cb, 'N','j',0 },
204 { 0x01cc, 'n','j',0 },
205 { 0x01e2, 0x0100,0x0112,0 },
206 { 0x01e3, 0x0101,0x0113,0 },
207 { 0x01f1, 'D','Z',0 },
208 { 0x01f2, 'D','z',0 },
209 { 0x01f3, 'd','z',0 },
210 { 0x01fc, 0x00c1,0x00c9,0 },
211 { 0x01fd, 0x00e1,0x00e9,0 },
212 { 0x05f0, 0x05d5,0x05d5,0 },
213 { 0x05f1, 0x05d5,0x05d9,0 },
214 { 0x05f2, 0x05d9,0x05d9,0 },
215 { 0xfb00, 'f','f',0 },
216 { 0xfb01, 'f','i',0 },
217 { 0xfb02, 'f','l',0 },
218 { 0xfb03, 'f','f','i',0 },
219 { 0xfb04, 'f','f','l',0 },
220 { 0xfb05, 0x017f,'t',0 },
221 { 0xfb06, 's','t',0 },
222 };
223
224 enum locationkind { LOCATION_NATION = 0, LOCATION_REGION, LOCATION_BOTH };
225
226 struct geoinfo
227 {
228 GEOID id;
229 WCHAR iso2W[3];
230 WCHAR iso3W[4];
231 GEOID parent;
232 int uncode;
233 enum locationkind kind;
234 };
235
236 static const struct geoinfo geoinfodata[] =
237 {
238 { 2, L"AG", L"ATG", 10039880, 28 }, /* Antigua and Barbuda */
239 { 3, L"AF", L"AFG", 47614, 4 }, /* Afghanistan */
240 { 4, L"DZ", L"DZA", 42487, 12 }, /* Algeria */
241 { 5, L"AZ", L"AZE", 47611, 31 }, /* Azerbaijan */
242 { 6, L"AL", L"ALB", 47610, 8 }, /* Albania */
243 { 7, L"AM", L"ARM", 47611, 51 }, /* Armenia */
244 { 8, L"AD", L"AND", 47610, 20 }, /* Andorra */
245 { 9, L"AO", L"AGO", 42484, 24 }, /* Angola */
246 { 10, L"AS", L"ASM", 26286, 16 }, /* American Samoa */
247 { 11, L"AR", L"ARG", 31396, 32 }, /* Argentina */
248 { 12, L"AU", L"AUS", 10210825, 36 }, /* Australia */
249 { 14, L"AT", L"AUT", 10210824, 40 }, /* Austria */
250 { 17, L"BH", L"BHR", 47611, 48 }, /* Bahrain */
251 { 18, L"BB", L"BRB", 10039880, 52 }, /* Barbados */
252 { 19, L"BW", L"BWA", 10039883, 72 }, /* Botswana */
253 { 20, L"BM", L"BMU", 23581, 60 }, /* Bermuda */
254 { 21, L"BE", L"BEL", 10210824, 56 }, /* Belgium */
255 { 22, L"BS", L"BHS", 10039880, 44 }, /* Bahamas, The */
256 { 23, L"BD", L"BGD", 47614, 50 }, /* Bangladesh */
257 { 24, L"BZ", L"BLZ", 27082, 84 }, /* Belize */
258 { 25, L"BA", L"BIH", 47610, 70 }, /* Bosnia and Herzegovina */
259 { 26, L"BO", L"BOL", 31396, 68 }, /* Bolivia */
260 { 27, L"MM", L"MMR", 47599, 104 }, /* Myanmar */
261 { 28, L"BJ", L"BEN", 42483, 204 }, /* Benin */
262 { 29, L"BY", L"BLR", 47609, 112 }, /* Belarus */
263 { 30, L"SB", L"SLB", 20900, 90 }, /* Solomon Islands */
264 { 32, L"BR", L"BRA", 31396, 76 }, /* Brazil */
265 { 34, L"BT", L"BTN", 47614, 64 }, /* Bhutan */
266 { 35, L"BG", L"BGR", 47609, 100 }, /* Bulgaria */
267 { 37, L"BN", L"BRN", 47599, 96 }, /* Brunei */
268 { 38, L"BI", L"BDI", 47603, 108 }, /* Burundi */
269 { 39, L"CA", L"CAN", 23581, 124 }, /* Canada */
270 { 40, L"KH", L"KHM", 47599, 116 }, /* Cambodia */
271 { 41, L"TD", L"TCD", 42484, 148 }, /* Chad */
272 { 42, L"LK", L"LKA", 47614, 144 }, /* Sri Lanka */
273 { 43, L"CG", L"COG", 42484, 178 }, /* Congo */
274 { 44, L"CD", L"COD", 42484, 180 }, /* Congo (DRC) */
275 { 45, L"CN", L"CHN", 47600, 156 }, /* China */
276 { 46, L"CL", L"CHL", 31396, 152 }, /* Chile */
277 { 49, L"CM", L"CMR", 42484, 120 }, /* Cameroon */
278 { 50, L"KM", L"COM", 47603, 174 }, /* Comoros */
279 { 51, L"CO", L"COL", 31396, 170 }, /* Colombia */
280 { 54, L"CR", L"CRI", 27082, 188 }, /* Costa Rica */
281 { 55, L"CF", L"CAF", 42484, 140 }, /* Central African Republic */
282 { 56, L"CU", L"CUB", 10039880, 192 }, /* Cuba */
283 { 57, L"CV", L"CPV", 42483, 132 }, /* Cape Verde */
284 { 59, L"CY", L"CYP", 47611, 196 }, /* Cyprus */
285 { 61, L"DK", L"DNK", 10039882, 208 }, /* Denmark */
286 { 62, L"DJ", L"DJI", 47603, 262 }, /* Djibouti */
287 { 63, L"DM", L"DMA", 10039880, 212 }, /* Dominica */
288 { 65, L"DO", L"DOM", 10039880, 214 }, /* Dominican Republic */
289 { 66, L"EC", L"ECU", 31396, 218 }, /* Ecuador */
290 { 67, L"EG", L"EGY", 42487, 818 }, /* Egypt */
291 { 68, L"IE", L"IRL", 10039882, 372 }, /* Ireland */
292 { 69, L"GQ", L"GNQ", 42484, 226 }, /* Equatorial Guinea */
293 { 70, L"EE", L"EST", 10039882, 233 }, /* Estonia */
294 { 71, L"ER", L"ERI", 47603, 232 }, /* Eritrea */
295 { 72, L"SV", L"SLV", 27082, 222 }, /* El Salvador */
296 { 73, L"ET", L"ETH", 47603, 231 }, /* Ethiopia */
297 { 75, L"CZ", L"CZE", 47609, 203 }, /* Czech Republic */
298 { 77, L"FI", L"FIN", 10039882, 246 }, /* Finland */
299 { 78, L"FJ", L"FJI", 20900, 242 }, /* Fiji Islands */
300 { 80, L"FM", L"FSM", 21206, 583 }, /* Micronesia */
301 { 81, L"FO", L"FRO", 10039882, 234 }, /* Faroe Islands */
302 { 84, L"FR", L"FRA", 10210824, 250 }, /* France */
303 { 86, L"GM", L"GMB", 42483, 270 }, /* Gambia, The */
304 { 87, L"GA", L"GAB", 42484, 266 }, /* Gabon */
305 { 88, L"GE", L"GEO", 47611, 268 }, /* Georgia */
306 { 89, L"GH", L"GHA", 42483, 288 }, /* Ghana */
307 { 90, L"GI", L"GIB", 47610, 292 }, /* Gibraltar */
308 { 91, L"GD", L"GRD", 10039880, 308 }, /* Grenada */
309 { 93, L"GL", L"GRL", 23581, 304 }, /* Greenland */
310 { 94, L"DE", L"DEU", 10210824, 276 }, /* Germany */
311 { 98, L"GR", L"GRC", 47610, 300 }, /* Greece */
312 { 99, L"GT", L"GTM", 27082, 320 }, /* Guatemala */
313 { 100, L"GN", L"GIN", 42483, 324 }, /* Guinea */
314 { 101, L"GY", L"GUY", 31396, 328 }, /* Guyana */
315 { 103, L"HT", L"HTI", 10039880, 332 }, /* Haiti */
316 { 104, L"HK", L"HKG", 47600, 344 }, /* Hong Kong S.A.R. */
317 { 106, L"HN", L"HND", 27082, 340 }, /* Honduras */
318 { 108, L"HR", L"HRV", 47610, 191 }, /* Croatia */
319 { 109, L"HU", L"HUN", 47609, 348 }, /* Hungary */
320 { 110, L"IS", L"ISL", 10039882, 352 }, /* Iceland */
321 { 111, L"ID", L"IDN", 47599, 360 }, /* Indonesia */
322 { 113, L"IN", L"IND", 47614, 356 }, /* India */
323 { 114, L"IO", L"IOT", 39070, 86 }, /* British Indian Ocean Territory */
324 { 116, L"IR", L"IRN", 47614, 364 }, /* Iran */
325 { 117, L"IL", L"ISR", 47611, 376 }, /* Israel */
326 { 118, L"IT", L"ITA", 47610, 380 }, /* Italy */
327 { 119, L"CI", L"CIV", 42483, 384 }, /* Côte d'Ivoire */
328 { 121, L"IQ", L"IRQ", 47611, 368 }, /* Iraq */
329 { 122, L"JP", L"JPN", 47600, 392 }, /* Japan */
330 { 124, L"JM", L"JAM", 10039880, 388 }, /* Jamaica */
331 { 125, L"SJ", L"SJM", 10039882, 744 }, /* Jan Mayen */
332 { 126, L"JO", L"JOR", 47611, 400 }, /* Jordan */
333 { 127, L"XX", L"XX", 161832256 }, /* Johnston Atoll */
334 { 129, L"KE", L"KEN", 47603, 404 }, /* Kenya */
335 { 130, L"KG", L"KGZ", 47590, 417 }, /* Kyrgyzstan */
336 { 131, L"KP", L"PRK", 47600, 408 }, /* North Korea */
337 { 133, L"KI", L"KIR", 21206, 296 }, /* Kiribati */
338 { 134, L"KR", L"KOR", 47600, 410 }, /* Korea */
339 { 136, L"KW", L"KWT", 47611, 414 }, /* Kuwait */
340 { 137, L"KZ", L"KAZ", 47590, 398 }, /* Kazakhstan */
341 { 138, L"LA", L"LAO", 47599, 418 }, /* Laos */
342 { 139, L"LB", L"LBN", 47611, 422 }, /* Lebanon */
343 { 140, L"LV", L"LVA", 10039882, 428 }, /* Latvia */
344 { 141, L"LT", L"LTU", 10039882, 440 }, /* Lithuania */
345 { 142, L"LR", L"LBR", 42483, 430 }, /* Liberia */
346 { 143, L"SK", L"SVK", 47609, 703 }, /* Slovakia */
347 { 145, L"LI", L"LIE", 10210824, 438 }, /* Liechtenstein */
348 { 146, L"LS", L"LSO", 10039883, 426 }, /* Lesotho */
349 { 147, L"LU", L"LUX", 10210824, 442 }, /* Luxembourg */
350 { 148, L"LY", L"LBY", 42487, 434 }, /* Libya */
351 { 149, L"MG", L"MDG", 47603, 450 }, /* Madagascar */
352 { 151, L"MO", L"MAC", 47600, 446 }, /* Macao S.A.R. */
353 { 152, L"MD", L"MDA", 47609, 498 }, /* Moldova */
354 { 154, L"MN", L"MNG", 47600, 496 }, /* Mongolia */
355 { 156, L"MW", L"MWI", 47603, 454 }, /* Malawi */
356 { 157, L"ML", L"MLI", 42483, 466 }, /* Mali */
357 { 158, L"MC", L"MCO", 10210824, 492 }, /* Monaco */
358 { 159, L"MA", L"MAR", 42487, 504 }, /* Morocco */
359 { 160, L"MU", L"MUS", 47603, 480 }, /* Mauritius */
360 { 162, L"MR", L"MRT", 42483, 478 }, /* Mauritania */
361 { 163, L"MT", L"MLT", 47610, 470 }, /* Malta */
362 { 164, L"OM", L"OMN", 47611, 512 }, /* Oman */
363 { 165, L"MV", L"MDV", 47614, 462 }, /* Maldives */
364 { 166, L"MX", L"MEX", 27082, 484 }, /* Mexico */
365 { 167, L"MY", L"MYS", 47599, 458 }, /* Malaysia */
366 { 168, L"MZ", L"MOZ", 47603, 508 }, /* Mozambique */
367 { 173, L"NE", L"NER", 42483, 562 }, /* Niger */
368 { 174, L"VU", L"VUT", 20900, 548 }, /* Vanuatu */
369 { 175, L"NG", L"NGA", 42483, 566 }, /* Nigeria */
370 { 176, L"NL", L"NLD", 10210824, 528 }, /* Netherlands */
371 { 177, L"NO", L"NOR", 10039882, 578 }, /* Norway */
372 { 178, L"NP", L"NPL", 47614, 524 }, /* Nepal */
373 { 180, L"NR", L"NRU", 21206, 520 }, /* Nauru */
374 { 181, L"SR", L"SUR", 31396, 740 }, /* Suriname */
375 { 182, L"NI", L"NIC", 27082, 558 }, /* Nicaragua */
376 { 183, L"NZ", L"NZL", 10210825, 554 }, /* New Zealand */
377 { 184, L"PS", L"PSE", 47611, 275 }, /* Palestinian Authority */
378 { 185, L"PY", L"PRY", 31396, 600 }, /* Paraguay */
379 { 187, L"PE", L"PER", 31396, 604 }, /* Peru */
380 { 190, L"PK", L"PAK", 47614, 586 }, /* Pakistan */
381 { 191, L"PL", L"POL", 47609, 616 }, /* Poland */
382 { 192, L"PA", L"PAN", 27082, 591 }, /* Panama */
383 { 193, L"PT", L"PRT", 47610, 620 }, /* Portugal */
384 { 194, L"PG", L"PNG", 20900, 598 }, /* Papua New Guinea */
385 { 195, L"PW", L"PLW", 21206, 585 }, /* Palau */
386 { 196, L"GW", L"GNB", 42483, 624 }, /* Guinea-Bissau */
387 { 197, L"QA", L"QAT", 47611, 634 }, /* Qatar */
388 { 198, L"RE", L"REU", 47603, 638 }, /* Reunion */
389 { 199, L"MH", L"MHL", 21206, 584 }, /* Marshall Islands */
390 { 200, L"RO", L"ROU", 47609, 642 }, /* Romania */
391 { 201, L"PH", L"PHL", 47599, 608 }, /* Philippines */
392 { 202, L"PR", L"PRI", 10039880, 630 }, /* Puerto Rico */
393 { 203, L"RU", L"RUS", 47609, 643 }, /* Russia */
394 { 204, L"RW", L"RWA", 47603, 646 }, /* Rwanda */
395 { 205, L"SA", L"SAU", 47611, 682 }, /* Saudi Arabia */
396 { 206, L"PM", L"SPM", 23581, 666 }, /* St. Pierre and Miquelon */
397 { 207, L"KN", L"KNA", 10039880, 659 }, /* St. Kitts and Nevis */
398 { 208, L"SC", L"SYC", 47603, 690 }, /* Seychelles */
399 { 209, L"ZA", L"ZAF", 10039883, 710 }, /* South Africa */
400 { 210, L"SN", L"SEN", 42483, 686 }, /* Senegal */
401 { 212, L"SI", L"SVN", 47610, 705 }, /* Slovenia */
402 { 213, L"SL", L"SLE", 42483, 694 }, /* Sierra Leone */
403 { 214, L"SM", L"SMR", 47610, 674 }, /* San Marino */
404 { 215, L"SG", L"SGP", 47599, 702 }, /* Singapore */
405 { 216, L"SO", L"SOM", 47603, 706 }, /* Somalia */
406 { 217, L"ES", L"ESP", 47610, 724 }, /* Spain */
407 { 218, L"LC", L"LCA", 10039880, 662 }, /* St. Lucia */
408 { 219, L"SD", L"SDN", 42487, 736 }, /* Sudan */
409 { 220, L"SJ", L"SJM", 10039882, 744 }, /* Svalbard */
410 { 221, L"SE", L"SWE", 10039882, 752 }, /* Sweden */
411 { 222, L"SY", L"SYR", 47611, 760 }, /* Syria */
412 { 223, L"CH", L"CHE", 10210824, 756 }, /* Switzerland */
413 { 224, L"AE", L"ARE", 47611, 784 }, /* United Arab Emirates */
414 { 225, L"TT", L"TTO", 10039880, 780 }, /* Trinidad and Tobago */
415 { 227, L"TH", L"THA", 47599, 764 }, /* Thailand */
416 { 228, L"TJ", L"TJK", 47590, 762 }, /* Tajikistan */
417 { 231, L"TO", L"TON", 26286, 776 }, /* Tonga */
418 { 232, L"TG", L"TGO", 42483, 768 }, /* Togo */
419 { 233, L"ST", L"STP", 42484, 678 }, /* São Tomé and Príncipe */
420 { 234, L"TN", L"TUN", 42487, 788 }, /* Tunisia */
421 { 235, L"TR", L"TUR", 47611, 792 }, /* Turkey */
422 { 236, L"TV", L"TUV", 26286, 798 }, /* Tuvalu */
423 { 237, L"TW", L"TWN", 47600, 158 }, /* Taiwan */
424 { 238, L"TM", L"TKM", 47590, 795 }, /* Turkmenistan */
425 { 239, L"TZ", L"TZA", 47603, 834 }, /* Tanzania */
426 { 240, L"UG", L"UGA", 47603, 800 }, /* Uganda */
427 { 241, L"UA", L"UKR", 47609, 804 }, /* Ukraine */
428 { 242, L"GB", L"GBR", 10039882, 826 }, /* United Kingdom */
429 { 244, L"US", L"USA", 23581, 840 }, /* United States */
430 { 245, L"BF", L"BFA", 42483, 854 }, /* Burkina Faso */
431 { 246, L"UY", L"URY", 31396, 858 }, /* Uruguay */
432 { 247, L"UZ", L"UZB", 47590, 860 }, /* Uzbekistan */
433 { 248, L"VC", L"VCT", 10039880, 670 }, /* St. Vincent and the Grenadines */
434 { 249, L"VE", L"VEN", 31396, 862 }, /* Bolivarian Republic of Venezuela */
435 { 251, L"VN", L"VNM", 47599, 704 }, /* Vietnam */
436 { 252, L"VI", L"VIR", 10039880, 850 }, /* Virgin Islands */
437 { 253, L"VA", L"VAT", 47610, 336 }, /* Vatican City */
438 { 254, L"NA", L"NAM", 10039883, 516 }, /* Namibia */
439 { 257, L"EH", L"ESH", 42487, 732 }, /* Western Sahara (disputed) */
440 { 258, L"XX", L"XX", 161832256 }, /* Wake Island */
441 { 259, L"WS", L"WSM", 26286, 882 }, /* Samoa */
442 { 260, L"SZ", L"SWZ", 10039883, 748 }, /* Swaziland */
443 { 261, L"YE", L"YEM", 47611, 887 }, /* Yemen */
444 { 263, L"ZM", L"ZMB", 47603, 894 }, /* Zambia */
445 { 264, L"ZW", L"ZWE", 47603, 716 }, /* Zimbabwe */
446 { 269, L"CS", L"SCG", 47610, 891 }, /* Serbia and Montenegro (Former) */
447 { 270, L"ME", L"MNE", 47610, 499 }, /* Montenegro */
448 { 271, L"RS", L"SRB", 47610, 688 }, /* Serbia */
449 { 273, L"CW", L"CUW", 10039880, 531 }, /* Curaçao */
450 { 276, L"SS", L"SSD", 42487, 728 }, /* South Sudan */
451 { 300, L"AI", L"AIA", 10039880, 660 }, /* Anguilla */
452 { 301, L"AQ", L"ATA", 39070, 10 }, /* Antarctica */
453 { 302, L"AW", L"ABW", 10039880, 533 }, /* Aruba */
454 { 303, L"XX", L"XX", 343 }, /* Ascension Island */
455 { 304, L"XX", L"XX", 10210825 }, /* Ashmore and Cartier Islands */
456 { 305, L"XX", L"XX", 161832256 }, /* Baker Island */
457 { 306, L"BV", L"BVT", 39070, 74 }, /* Bouvet Island */
458 { 307, L"KY", L"CYM", 10039880, 136 }, /* Cayman Islands */
459 { 308, L"XX", L"XX", 10210824, 830, LOCATION_BOTH }, /* Channel Islands */
460 { 309, L"CX", L"CXR", 12, 162 }, /* Christmas Island */
461 { 310, L"XX", L"XX", 27114 }, /* Clipperton Island */
462 { 311, L"CC", L"CCK", 10210825, 166 }, /* Cocos (Keeling) Islands */
463 { 312, L"CK", L"COK", 26286, 184 }, /* Cook Islands */
464 { 313, L"XX", L"XX", 10210825 }, /* Coral Sea Islands */
465 { 314, L"XX", L"XX", 114 }, /* Diego Garcia */
466 { 315, L"FK", L"FLK", 31396, 238 }, /* Falkland Islands (Islas Malvinas) */
467 { 317, L"GF", L"GUF", 31396, 254 }, /* French Guiana */
468 { 318, L"PF", L"PYF", 26286, 258 }, /* French Polynesia */
469 { 319, L"TF", L"ATF", 39070, 260 }, /* French Southern and Antarctic Lands */
470 { 321, L"GP", L"GLP", 10039880, 312 }, /* Guadeloupe */
471 { 322, L"GU", L"GUM", 21206, 316 }, /* Guam */
472 { 323, L"XX", L"XX", 39070 }, /* Guantanamo Bay */
473 { 324, L"GG", L"GGY", 308, 831 }, /* Guernsey */
474 { 325, L"HM", L"HMD", 39070, 334 }, /* Heard Island and McDonald Islands */
475 { 326, L"XX", L"XX", 161832256 }, /* Howland Island */
476 { 327, L"XX", L"XX", 161832256 }, /* Jarvis Island */
477 { 328, L"JE", L"JEY", 308, 832 }, /* Jersey */
478 { 329, L"XX", L"XX", 161832256 }, /* Kingman Reef */
479 { 330, L"MQ", L"MTQ", 10039880, 474 }, /* Martinique */
480 { 331, L"YT", L"MYT", 47603, 175 }, /* Mayotte */
481 { 332, L"MS", L"MSR", 10039880, 500 }, /* Montserrat */
482 { 333, L"AN", L"ANT", 10039880, 530, LOCATION_BOTH }, /* Netherlands Antilles (Former) */
483 { 334, L"NC", L"NCL", 20900, 540 }, /* New Caledonia */
484 { 335, L"NU", L"NIU", 26286, 570 }, /* Niue */
485 { 336, L"NF", L"NFK", 10210825, 574 }, /* Norfolk Island */
486 { 337, L"MP", L"MNP", 21206, 580 }, /* Northern Mariana Islands */
487 { 338, L"XX", L"XX", 161832256 }, /* Palmyra Atoll */
488 { 339, L"PN", L"PCN", 26286, 612 }, /* Pitcairn Islands */
489 { 340, L"XX", L"XX", 337 }, /* Rota Island */
490 { 341, L"XX", L"XX", 337 }, /* Saipan */
491 { 342, L"GS", L"SGS", 39070, 239 }, /* South Georgia and the South Sandwich Islands */
492 { 343, L"SH", L"SHN", 42483, 654 }, /* St. Helena */
493 { 346, L"XX", L"XX", 337 }, /* Tinian Island */
494 { 347, L"TK", L"TKL", 26286, 772 }, /* Tokelau */
495 { 348, L"XX", L"XX", 343 }, /* Tristan da Cunha */
496 { 349, L"TC", L"TCA", 10039880, 796 }, /* Turks and Caicos Islands */
497 { 351, L"VG", L"VGB", 10039880, 92 }, /* Virgin Islands, British */
498 { 352, L"WF", L"WLF", 26286, 876 }, /* Wallis and Futuna */
499 { 742, L"XX", L"XX", 39070, 2, LOCATION_REGION }, /* Africa */
500 { 2129, L"XX", L"XX", 39070, 142, LOCATION_REGION }, /* Asia */
501 { 10541, L"XX", L"XX", 39070, 150, LOCATION_REGION }, /* Europe */
502 { 15126, L"IM", L"IMN", 10039882, 833 }, /* Man, Isle of */
503 { 19618, L"MK", L"MKD", 47610, 807 }, /* Macedonia, Former Yugoslav Republic of */
504 { 20900, L"XX", L"XX", 27114, 54, LOCATION_REGION }, /* Melanesia */
505 { 21206, L"XX", L"XX", 27114, 57, LOCATION_REGION }, /* Micronesia */
506 { 21242, L"XX", L"XX", 161832256 }, /* Midway Islands */
507 { 23581, L"XX", L"XX", 10026358, 21, LOCATION_REGION }, /* Northern America */
508 { 26286, L"XX", L"XX", 27114, 61, LOCATION_REGION }, /* Polynesia */
509 { 27082, L"XX", L"XX", 161832257, 13, LOCATION_REGION }, /* Central America */
510 { 27114, L"XX", L"XX", 39070, 9, LOCATION_REGION }, /* Oceania */
511 { 30967, L"SX", L"SXM", 10039880, 534 }, /* Sint Maarten (Dutch part) */
512 { 31396, L"XX", L"XX", 161832257, 5, LOCATION_REGION }, /* South America */
513 { 31706, L"MF", L"MAF", 10039880, 663 }, /* Saint Martin (French part) */
514 { 39070, L"XX", L"XX", 39070, 1, LOCATION_REGION }, /* World */
515 { 42483, L"XX", L"XX", 742, 11, LOCATION_REGION }, /* Western Africa */
516 { 42484, L"XX", L"XX", 742, 17, LOCATION_REGION }, /* Middle Africa */
517 { 42487, L"XX", L"XX", 742, 15, LOCATION_REGION }, /* Northern Africa */
518 { 47590, L"XX", L"XX", 2129, 143, LOCATION_REGION }, /* Central Asia */
519 { 47599, L"XX", L"XX", 2129, 35, LOCATION_REGION }, /* South-Eastern Asia */
520 { 47600, L"XX", L"XX", 2129, 30, LOCATION_REGION }, /* Eastern Asia */
521 { 47603, L"XX", L"XX", 742, 14, LOCATION_REGION }, /* Eastern Africa */
522 { 47609, L"XX", L"XX", 10541, 151, LOCATION_REGION }, /* Eastern Europe */
523 { 47610, L"XX", L"XX", 10541, 39, LOCATION_REGION }, /* Southern Europe */
524 { 47611, L"XX", L"XX", 2129, 145, LOCATION_REGION }, /* Middle East */
525 { 47614, L"XX", L"XX", 2129, 34, LOCATION_REGION }, /* Southern Asia */
526 { 7299303, L"TL", L"TLS", 47599, 626 }, /* Democratic Republic of Timor-Leste */
527 { 9914689, L"XK", L"XKS", 47610, 906 }, /* Kosovo */
528 { 10026358, L"XX", L"XX", 39070, 19, LOCATION_REGION }, /* Americas */
529 { 10028789, L"AX", L"ALA", 10039882, 248 }, /* Åland Islands */
530 { 10039880, L"XX", L"XX", 161832257, 29, LOCATION_REGION }, /* Caribbean */
531 { 10039882, L"XX", L"XX", 10541, 154, LOCATION_REGION }, /* Northern Europe */
532 { 10039883, L"XX", L"XX", 742, 18, LOCATION_REGION }, /* Southern Africa */
533 { 10210824, L"XX", L"XX", 10541, 155, LOCATION_REGION }, /* Western Europe */
534 { 10210825, L"XX", L"XX", 27114, 53, LOCATION_REGION }, /* Australia and New Zealand */
535 { 161832015, L"BL", L"BLM", 10039880, 652 }, /* Saint Barthélemy */
536 { 161832256, L"UM", L"UMI", 27114, 581 }, /* U.S. Minor Outlying Islands */
537 { 161832257, L"XX", L"XX", 10026358, 419, LOCATION_REGION }, /* Latin America and the Caribbean */
538 { 161832258, L"BG", L"BES", 10039880, 535 }, /* Bonaire, Sint Eustatius and Saba */
539 };
540
541 /* NLS normalization file */
542 struct norm_table
543 {
544 WCHAR name[13]; /* 00 file name */
545 USHORT checksum[3]; /* 1a checksum? */
546 USHORT version[4]; /* 20 Unicode version */
547 USHORT form; /* 28 normalization form */
548 USHORT len_factor; /* 2a factor for length estimates */
549 USHORT unknown1; /* 2c */
550 USHORT decomp_size; /* 2e decomposition hash size */
551 USHORT comp_size; /* 30 composition hash size */
552 USHORT unknown2; /* 32 */
553 USHORT classes; /* 34 combining classes table offset */
554 USHORT props_level1; /* 36 char properties table level 1 offset */
555 USHORT props_level2; /* 38 char properties table level 2 offset */
556 USHORT decomp_hash; /* 3a decomposition hash table offset */
557 USHORT decomp_map; /* 3c decomposition character map table offset */
558 USHORT decomp_seq; /* 3e decomposition character sequences offset */
559 USHORT comp_hash; /* 40 composition hash table offset */
560 USHORT comp_seq; /* 42 composition character sequences offset */
561 /* BYTE[] combining class values */
562 /* BYTE[0x2200] char properties index level 1 */
563 /* BYTE[] char properties index level 2 */
564 /* WORD[] decomposition hash table */
565 /* WORD[] decomposition character map */
566 /* WORD[] decomposition character sequences */
567 /* WORD[] composition hash table */
568 /* WORD[] composition character sequences */
569 };
570
571 static NLSTABLEINFO nls_info;
572 static UINT unix_cp = CP_UTF8;
573 static UINT mac_cp = 10000;
574 static HKEY intl_key;
575 static HKEY nls_key;
576 static HKEY tz_key;
577
578 static CPTABLEINFO codepages[128];
579 static unsigned int nb_codepages;
580
581 static struct norm_table *norm_info;
582
583 struct sortguid
584 {
585 GUID id; /* sort GUID */
586 DWORD flags; /* flags */
587 DWORD compr; /* offset to compression table */
588 DWORD except; /* exception table offset in sortkey table */
589 DWORD ling_except; /* exception table offset for linguistic casing */
590 DWORD casemap; /* linguistic casemap table offset */
591 };
592
593 #define FLAG_HAS_3_BYTE_WEIGHTS 0x01
594 #define FLAG_REVERSEDIACRITICS 0x10
595 #define FLAG_DOUBLECOMPRESSION 0x20
596 #define FLAG_INVERSECASING 0x40
597
598 static const struct sortguid *current_locale_sort;
599
600 static const GUID default_sort_guid = { 0x00000001, 0x57ee, 0x1e5c, { 0x00, 0xb4, 0xd0, 0x00, 0x0b, 0xb1, 0xe1, 0x1e }};
601
602 static struct
603 {
604 DWORD *keys; /* sortkey table, indexed by char */
605 USHORT *casemap; /* casemap table, in l_intl.nls format */
606 WORD *ctypes; /* CT_CTYPE1,2,3 values */
607 BYTE *ctype_idx; /* index to map char to ctypes array entry */
608 DWORD version; /* NLS version */
609 DWORD guid_count; /* number of sort GUIDs */
610 struct sortguid *guids; /* table of sort GUIDs */
611 } sort;
612
613 static CRITICAL_SECTION locale_section;
614 static CRITICAL_SECTION_DEBUG critsect_debug =
615 {
616 0, 0, &locale_section,
617 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
618 0, 0, { (DWORD_PTR)(__FILE__ ": locale_section") }
619 };
620 static CRITICAL_SECTION locale_section = { &critsect_debug, -1, 0, 0, 0, 0 };
621
622
623 static void init_sortkeys( DWORD *ptr )
624 {
625 WORD *ctype;
626 DWORD *table;
627
628 sort.keys = (DWORD *)((char *)ptr + ptr[0]);
629 sort.casemap = (USHORT *)((char *)ptr + ptr[1]);
630
631 ctype = (WORD *)((char *)ptr + ptr[2]);
632 sort.ctypes = ctype + 2;
633 sort.ctype_idx = (BYTE *)ctype + ctype[1] + 2;
634
635 table = (DWORD *)((char *)ptr + ptr[3]);
636 sort.version = table[0];
637 sort.guid_count = table[1];
638 sort.guids = (struct sortguid *)(table + 2);
639 }
640
641
642 static const struct sortguid *find_sortguid( const GUID *guid )
643 {
644 int pos, ret, min = 0, max = sort.guid_count - 1;
645
646 while (min <= max)
647 {
648 pos = (min + max) / 2;
649 ret = memcmp( guid, &sort.guids[pos].id, sizeof(*guid) );
650 if (!ret) return &sort.guids[pos];
651 if (ret > 0) min = pos + 1;
652 else max = pos - 1;
653 }
654 ERR( "no sort found for %s\n", debugstr_guid( guid ));
655 return NULL;
656 }
657
658
659 static const struct sortguid *get_language_sort( const WCHAR *locale )
660 {
661 WCHAR *p, *end, buffer[LOCALE_NAME_MAX_LENGTH], guidstr[39];
662 const struct sortguid *ret;
663 UNICODE_STRING str;
664 GUID guid;
665 HKEY key = 0;
666 DWORD size, type;
667
668 if (locale == LOCALE_NAME_USER_DEFAULT)
669 {
670 if (current_locale_sort) return current_locale_sort;
671 GetUserDefaultLocaleName( buffer, ARRAY_SIZE( buffer ));
672 }
673 else lstrcpynW( buffer, locale, LOCALE_NAME_MAX_LENGTH );
674
675 if (buffer[0] && !RegOpenKeyExW( nls_key, L"Sorting\\Ids", 0, KEY_READ, &key ))
676 {
677 for (;;)
678 {
679 size = sizeof(guidstr);
680 if (!RegQueryValueExW( key, buffer, NULL, &type, (BYTE *)guidstr, &size ) && type == REG_SZ)
681 {
682 RtlInitUnicodeString( &str, guidstr );
683 if (!RtlGUIDFromString( &str, &guid ))
684 {
685 ret = find_sortguid( &guid );
686 goto done;
687 }
688 break;
689 }
690 for (p = end = buffer; *p; p++) if (*p == '-' || *p == '_') end = p;
691 if (end == buffer) break;
692 *end = 0;
693 }
694 }
695 ret = find_sortguid( &default_sort_guid );
696 done:
697 RegCloseKey( key );
698 return ret;
699 }
700
701
702 static LCID locale_to_lcid( WCHAR *win_name )
703 {
704 WCHAR *p;
705 LCID lcid;
706
707 if (!RtlLocaleNameToLcid( win_name, &lcid, 0 )) return lcid;
708
709 /* try neutral name */
710 if ((p = wcsrchr( win_name, '-' )))
711 {
712 *p = 0;
713 if (!RtlLocaleNameToLcid( win_name, &lcid, 2 ))
714 {
715 if (SUBLANGID(lcid) == SUBLANG_NEUTRAL)
716 lcid = MAKELANGID( PRIMARYLANGID(lcid), SUBLANG_DEFAULT );
717 return lcid;
718 }
719 }
720 return 0;
721 }
722
723 /***********************************************************************
724 * init_locale
725 */
726 void init_locale(void)
727 {
728 UINT ansi_cp = 0, oem_cp = 0;
729 USHORT *ansi_ptr, *oem_ptr;
730 void *sort_ptr;
731 LCID user_lcid = 0, system_lcid = 0;
732 WCHAR bufferW[LOCALE_NAME_MAX_LENGTH];
733 DYNAMIC_TIME_ZONE_INFORMATION timezone;
734 GEOID geoid = GEOID_NOT_AVAILABLE;
735 DWORD count, dispos, i;
736 SIZE_T size;
737 HKEY hkey;
738
739 if (GetEnvironmentVariableW( L"WINEUNIXCP", bufferW, ARRAY_SIZE(bufferW) ))
740 unix_cp = wcstoul( bufferW, NULL, 10 );
741 if (GetEnvironmentVariableW( L"WINELOCALE", bufferW, ARRAY_SIZE(bufferW) ))
742 system_lcid = locale_to_lcid( bufferW );
743 if (GetEnvironmentVariableW( L"WINEUSERLOCALE", bufferW, ARRAY_SIZE(bufferW) ))
744 user_lcid = locale_to_lcid( bufferW );
745 if (!system_lcid) system_lcid = MAKELCID( MAKELANGID(LANG_ENGLISH,SUBLANG_DEFAULT), SORT_DEFAULT );
746 if (!user_lcid) user_lcid = system_lcid;
747
748 NtSetDefaultUILanguage( LANGIDFROMLCID(user_lcid) );
749 NtSetDefaultLocale( TRUE, user_lcid );
750 NtSetDefaultLocale( FALSE, system_lcid );
751
752 kernel32_handle = GetModuleHandleW( L"kernel32.dll" );
753
754 GetLocaleInfoW( LOCALE_SYSTEM_DEFAULT, LOCALE_IDEFAULTANSICODEPAGE | LOCALE_RETURN_NUMBER,
755 (WCHAR *)&ansi_cp, sizeof(ansi_cp)/sizeof(WCHAR) );
756 GetLocaleInfoW( LOCALE_SYSTEM_DEFAULT, LOCALE_IDEFAULTMACCODEPAGE | LOCALE_RETURN_NUMBER,
757 (WCHAR *)&mac_cp, sizeof(mac_cp)/sizeof(WCHAR) );
758 GetLocaleInfoW( LOCALE_SYSTEM_DEFAULT, LOCALE_IDEFAULTCODEPAGE | LOCALE_RETURN_NUMBER,
759 (WCHAR *)&oem_cp, sizeof(oem_cp)/sizeof(WCHAR) );
760
761 NtGetNlsSectionPtr( 9, 0, NULL, &sort_ptr, &size );
762 NtGetNlsSectionPtr( 12, NormalizationC, NULL, (void **)&norm_info, &size );
763 init_sortkeys( sort_ptr );
764
765 if (!ansi_cp || NtGetNlsSectionPtr( 11, ansi_cp, NULL, (void **)&ansi_ptr, &size ))
766 NtGetNlsSectionPtr( 11, 1252, NULL, (void **)&ansi_ptr, &size );
767 if (!oem_cp || NtGetNlsSectionPtr( 11, oem_cp, 0, (void **)&oem_ptr, &size ))
768 NtGetNlsSectionPtr( 11, 437, NULL, (void **)&oem_ptr, &size );
769 NtCurrentTeb()->Peb->AnsiCodePageData = ansi_ptr;
770 NtCurrentTeb()->Peb->OemCodePageData = oem_ptr;
771 NtCurrentTeb()->Peb->UnicodeCaseTableData = sort.casemap;
772 RtlInitNlsTables( ansi_ptr, oem_ptr, sort.casemap, &nls_info );
773 RtlResetRtlTranslations( &nls_info );
774
775 RegCreateKeyExW( HKEY_LOCAL_MACHINE, L"System\\CurrentControlSet\\Control\\Nls",
776 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &nls_key, NULL );
777 RegCreateKeyExW( HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones",
778 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &tz_key, NULL );
779 RegCreateKeyExW( HKEY_CURRENT_USER, L"Control Panel\\International",
780 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &intl_key, NULL );
781
782 current_locale_sort = get_language_sort( LOCALE_NAME_USER_DEFAULT );
783
784 if (GetDynamicTimeZoneInformation( &timezone ) != TIME_ZONE_ID_INVALID &&
785 !RegCreateKeyExW( HKEY_LOCAL_MACHINE, L"System\\CurrentControlSet\\Control\\TimeZoneInformation",
786 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, NULL ))
787 {
788 RegSetValueExW( hkey, L"StandardName", 0, REG_SZ, (BYTE *)timezone.StandardName,
789 (lstrlenW(timezone.StandardName) + 1) * sizeof(WCHAR) );
790 RegSetValueExW( hkey, L"TimeZoneKeyName", 0, REG_SZ, (BYTE *)timezone.TimeZoneKeyName,
791 (lstrlenW(timezone.TimeZoneKeyName) + 1) * sizeof(WCHAR) );
792 RegCloseKey( hkey );
793 }
794
795 if (!RegCreateKeyExW( intl_key, L"Geo", 0, NULL, 0, KEY_ALL_ACCESS, NULL, &hkey, &dispos ))
796 {
797 if (dispos == REG_CREATED_NEW_KEY)
798 {
799 GetLocaleInfoW( LOCALE_USER_DEFAULT, LOCALE_IGEOID | LOCALE_RETURN_NUMBER,
800 (WCHAR *)&geoid, sizeof(geoid) / sizeof(WCHAR) );
801 SetUserGeoID( geoid );
802 }
803 RegCloseKey( hkey );
804 }
805
806 /* Update registry contents if the user locale has changed.
807 * This simulates the action of the Windows control panel. */
808
809 count = sizeof(bufferW);
810 if (!RegQueryValueExW( intl_key, L"Locale", NULL, NULL, (BYTE *)bufferW, &count ))
811 {
812 if (wcstoul( bufferW, NULL, 16 ) == user_lcid) return; /* already set correctly */
813 TRACE( "updating registry, locale changed %s -> %08lx\n", debugstr_w(bufferW), user_lcid );
814 }
815 else TRACE( "updating registry, locale changed none -> %08lx\n", user_lcid );
816 swprintf( bufferW, ARRAY_SIZE(bufferW), L"%08x", user_lcid );
817 RegSetValueExW( intl_key, L"Locale", 0, REG_SZ,
818 (BYTE *)bufferW, (lstrlenW(bufferW) + 1) * sizeof(WCHAR) );
819
820 for (i = 0; i < ARRAY_SIZE(registry_values); i++)
821 {
822 GetLocaleInfoW( LOCALE_USER_DEFAULT, registry_values[i].lctype | LOCALE_NOUSEROVERRIDE,
823 bufferW, ARRAY_SIZE( bufferW ));
824 RegSetValueExW( intl_key, registry_values[i].name, 0, REG_SZ,
825 (BYTE *)bufferW, (lstrlenW(bufferW) + 1) * sizeof(WCHAR) );
826 }
827
828 if (geoid == GEOID_NOT_AVAILABLE)
829 {
830 GetLocaleInfoW( LOCALE_USER_DEFAULT, LOCALE_IGEOID | LOCALE_RETURN_NUMBER,
831 (WCHAR *)&geoid, sizeof(geoid) / sizeof(WCHAR) );
832 SetUserGeoID( geoid );
833 }
834
835 if (!RegCreateKeyExW( nls_key, L"Codepage",
836 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, NULL ))
837 {
838 count = swprintf( bufferW, ARRAY_SIZE(bufferW), L"%03d", ansi_cp );
839 RegSetValueExW( hkey, L"ACP", 0, REG_SZ, (BYTE *)bufferW, (count + 1) * sizeof(WCHAR) );
840 count = swprintf( bufferW, ARRAY_SIZE(bufferW), L"%03d", oem_cp );
841 RegSetValueExW( hkey, L"OEMCP", 0, REG_SZ, (BYTE *)bufferW, (count + 1) * sizeof(WCHAR) );
842 count = swprintf( bufferW, ARRAY_SIZE(bufferW), L"%03d", mac_cp );
843 RegSetValueExW( hkey, L"MACCP", 0, REG_SZ, (BYTE *)bufferW, (count + 1) * sizeof(WCHAR) );
844 RegCloseKey( hkey );
845 }
846 }
847
848
849 static inline USHORT get_table_entry( const USHORT *table, WCHAR ch )
850 {
851 return table[table[table[ch >> 8] + ((ch >> 4) & 0x0f)] + (ch & 0xf)];
852 }
853
854
855 static inline WCHAR casemap( const USHORT *table, WCHAR ch )
856 {
857 return ch + table[table[table[ch >> 8] + ((ch >> 4) & 0x0f)] + (ch & 0x0f)];
858 }
859
860
861 static inline WORD get_char_type( DWORD type, WCHAR ch )
862 {
863 const BYTE *ptr = sort.ctype_idx + ((const WORD *)sort.ctype_idx)[ch >> 8];
864 ptr = sort.ctype_idx + ((const WORD *)ptr)[(ch >> 4) & 0x0f] + (ch & 0x0f);
865 return sort.ctypes[*ptr * 3 + type / 2];
866 }
867
868
869 static BYTE rol( BYTE val, BYTE count )
870 {
871 return (val << count) | (val >> (8 - count));
872 }
873
874
875 static BYTE get_char_props( const struct norm_table *info, unsigned int ch )
876 {
877 const BYTE *level1 = (const BYTE *)((const USHORT *)info + info->props_level1);
878 const BYTE *level2 = (const BYTE *)((const USHORT *)info + info->props_level2);
879 BYTE off = level1[ch / 128];
880
881 if (!off || off >= 0xfb) return rol( off, 5 );
882 return level2[(off - 1) * 128 + ch % 128];
883 }
884
885
886 static const WCHAR *get_decomposition( WCHAR ch, unsigned int *ret_len )
887 {
888 const struct pair { WCHAR src; USHORT dst; } *pairs;
889 const USHORT *hash_table = (const USHORT *)norm_info + norm_info->decomp_hash;
890 const WCHAR *ret;
891 unsigned int i, pos, end, len, hash;
892
893 *ret_len = 1;
894 hash = ch % norm_info->decomp_size;
895 pos = hash_table[hash];
896 if (pos >> 13)
897 {
898 if (get_char_props( norm_info, ch ) != 0xbf) return NULL;
899 ret = (const USHORT *)norm_info + norm_info->decomp_seq + (pos & 0x1fff);
900 len = pos >> 13;
901 }
902 else
903 {
904 pairs = (const struct pair *)((const USHORT *)norm_info + norm_info->decomp_map);
905
906 /* find the end of the hash bucket */
907 for (i = hash + 1; i < norm_info->decomp_size; i++) if (!(hash_table[i] >> 13)) break;
908 if (i < norm_info->decomp_size) end = hash_table[i];
909 else for (end = pos; pairs[end].src; end++) ;
910
911 for ( ; pos < end; pos++)
912 {
913 if (pairs[pos].src != (WCHAR)ch) continue;
914 ret = (const USHORT *)norm_info + norm_info->decomp_seq + (pairs[pos].dst & 0x1fff);
915 len = pairs[pos].dst >> 13;
916 break;
917 }
918 if (pos >= end) return NULL;
919 }
920
921 if (len == 7) while (ret[len]) len++;
922 if (!ret[0]) len = 0; /* ignored char */
923 *ret_len = len;
924 return ret;
925 }
926
927
928 static WCHAR compose_chars( WCHAR ch1, WCHAR ch2 )
929 {
930 const USHORT *table = (const USHORT *)norm_info + norm_info->comp_hash;
931 const WCHAR *chars = (const USHORT *)norm_info + norm_info->comp_seq;
932 unsigned int hash, start, end, i;
933 WCHAR ch[3];
934
935 hash = (ch1 + 95 * ch2) % norm_info->comp_size;
936 start = table[hash];
937 end = table[hash + 1];
938 while (start < end)
939 {
940 for (i = 0; i < 3; i++, start++)
941 {
942 ch[i] = chars[start];
943 if (IS_HIGH_SURROGATE( ch[i] )) start++;
944 }
945 if (ch[0] == ch1 && ch[1] == ch2) return ch[2];
946 }
947 return 0;
948 }
949
950
951 static UINT get_lcid_codepage( LCID lcid, ULONG flags )
952 {
953 UINT ret = GetACP();
954
955 if (!(flags & LOCALE_USE_CP_ACP) && lcid != GetSystemDefaultLCID())
956 GetLocaleInfoW( lcid, LOCALE_IDEFAULTANSICODEPAGE | LOCALE_RETURN_NUMBER,
957 (WCHAR *)&ret, sizeof(ret)/sizeof(WCHAR) );
958 return ret;
959 }
960
961
962 static BOOL is_genitive_name_supported( LCTYPE lctype )
963 {
964 switch (LOWORD(lctype))
965 {
966 case LOCALE_SMONTHNAME1:
967 case LOCALE_SMONTHNAME2:
968 case LOCALE_SMONTHNAME3:
969 case LOCALE_SMONTHNAME4:
970 case LOCALE_SMONTHNAME5:
971 case LOCALE_SMONTHNAME6:
972 case LOCALE_SMONTHNAME7:
973 case LOCALE_SMONTHNAME8:
974 case LOCALE_SMONTHNAME9:
975 case LOCALE_SMONTHNAME10:
976 case LOCALE_SMONTHNAME11:
977 case LOCALE_SMONTHNAME12:
978 case LOCALE_SMONTHNAME13:
979 return TRUE;
980 default:
981 return FALSE;
982 }
983 }
984
985
986 static int get_value_base_by_lctype( LCTYPE lctype )
987 {
988 return lctype == LOCALE_ILANGUAGE || lctype == LOCALE_IDEFAULTLANGUAGE ? 16 : 10;
989 }
990
991
992 static const struct registry_value *get_locale_registry_value( DWORD lctype )
993 {
994 unsigned int i;
995
996 for (i = 0; i < ARRAY_SIZE( registry_values ); i++)
997 if (registry_values[i].lctype == lctype) return &registry_values[i];
998 return NULL;
999 }
1000
1001
1002 static INT get_registry_locale_info( const struct registry_value *registry_value, LPWSTR buffer, INT len )
1003 {
1004 DWORD size, index = registry_value - registry_values;
1005 INT ret;
1006
1007 RtlEnterCriticalSection( &locale_section );
1008
1009 if (!registry_cache[index])
1010 {
1011 size = len * sizeof(WCHAR);
1012 ret = RegQueryValueExW( intl_key, registry_value->name, NULL, NULL, (BYTE *)buffer, &size );
1013 if (!ret)
1014 {
1015 if (buffer && (registry_cache[index] = HeapAlloc( GetProcessHeap(), 0, size + sizeof(WCHAR) )))
1016 {
1017 memcpy( registry_cache[index], buffer, size );
1018 registry_cache[index][size / sizeof(WCHAR)] = 0;
1019 }
1020 RtlLeaveCriticalSection( &locale_section );
1021 return size / sizeof(WCHAR);
1022 }
1023 else
1024 {
1025 RtlLeaveCriticalSection( &locale_section );
1026 if (ret == ERROR_FILE_NOT_FOUND) return -1;
1027 if (ret == ERROR_MORE_DATA) SetLastError( ERROR_INSUFFICIENT_BUFFER );
1028 else SetLastError( ret );
1029 return 0;
1030 }
1031 }
1032
1033 ret = lstrlenW( registry_cache[index] ) + 1;
1034 if (buffer)
1035 {
1036 if (ret > len)
1037 {
1038 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1039 ret = 0;
1040 }
1041 else lstrcpyW( buffer, registry_cache[index] );
1042 }
1043 RtlLeaveCriticalSection( &locale_section );
1044 return ret;
1045 }
1046
1047
1048 static const CPTABLEINFO *get_codepage_table( UINT codepage )
1049 {
1050 unsigned int i;
1051 USHORT *ptr;
1052 SIZE_T size;
1053
1054 switch (codepage)
1055 {
1056 case CP_ACP:
1057 return &nls_info.AnsiTableInfo;
1058 case CP_OEMCP:
1059 return &nls_info.OemTableInfo;
1060 case CP_MACCP:
1061 codepage = mac_cp;
1062 break;
1063 case CP_THREAD_ACP:
1064 if (NtCurrentTeb()->CurrentLocale == GetUserDefaultLCID()) return &nls_info.AnsiTableInfo;
1065 codepage = get_lcid_codepage( NtCurrentTeb()->CurrentLocale, 0 );
1066 if (!codepage) return &nls_info.AnsiTableInfo;
1067 break;
1068 default:
1069 if (codepage == nls_info.AnsiTableInfo.CodePage) return &nls_info.AnsiTableInfo;
1070 if (codepage == nls_info.OemTableInfo.CodePage) return &nls_info.OemTableInfo;
1071 break;
1072 }
1073
1074 RtlEnterCriticalSection( &locale_section );
1075
1076 for (i = 0; i < nb_codepages; i++) if (codepages[i].CodePage == codepage) goto done;
1077
1078 if (i == ARRAY_SIZE( codepages ))
1079 {
1080 RtlLeaveCriticalSection( &locale_section );
1081 ERR( "too many codepages\n" );
1082 return NULL;
1083 }
1084 if (NtGetNlsSectionPtr( 11, codepage, NULL, (void **)&ptr, &size ))
1085 {
1086 RtlLeaveCriticalSection( &locale_section );
1087 SetLastError( ERROR_INVALID_PARAMETER );
1088 return NULL;
1089 }
1090 RtlInitCodePageTable( ptr, &codepages[i] );
1091 nb_codepages++;
1092 done:
1093 RtlLeaveCriticalSection( &locale_section );
1094 return &codepages[i];
1095 }
1096
1097
1098 static const WCHAR *get_ligature( WCHAR wc )
1099 {
1100 int low = 0, high = ARRAY_SIZE( ligatures ) -1;
1101 while (low <= high)
1102 {
1103 int pos = (low + high) / 2;
1104 if (ligatures[pos][0] < wc) low = pos + 1;
1105 else if (ligatures[pos][0] > wc) high = pos - 1;
1106 else return ligatures[pos] + 1;
1107 }
1108 return NULL;
1109 }
1110
1111
1112 static NTSTATUS expand_ligatures( const WCHAR *src, int srclen, WCHAR *dst, int *dstlen )
1113 {
1114 int i, len, pos = 0;
1115 NTSTATUS ret = STATUS_SUCCESS;
1116 const WCHAR *expand;
1117
1118 for (i = 0; i < srclen; i++)
1119 {
1120 if (!(expand = get_ligature( src[i] )))
1121 {
1122 expand = src + i;
1123 len = 1;
1124 }
1125 else len = lstrlenW( expand );
1126
1127 if (*dstlen && ret == STATUS_SUCCESS)
1128 {
1129 if (pos + len <= *dstlen) memcpy( dst + pos, expand, len * sizeof(WCHAR) );
1130 else ret = STATUS_BUFFER_TOO_SMALL;
1131 }
1132 pos += len;
1133 }
1134 *dstlen = pos;
1135 return ret;
1136 }
1137
1138
1139 static NTSTATUS fold_digits( const WCHAR *src, int srclen, WCHAR *dst, int *dstlen )
1140 {
1141 extern const WCHAR wine_digitmap[] DECLSPEC_HIDDEN;
1142 int i, len = *dstlen;
1143
1144 *dstlen = srclen;
1145 if (!len) return STATUS_SUCCESS;
1146 if (srclen > len) return STATUS_BUFFER_TOO_SMALL;
1147 for (i = 0; i < srclen; i++)
1148 {
1149 WCHAR digit = get_table_entry( wine_digitmap, src[i] );
1150 dst[i] = digit ? digit : src[i];
1151 }
1152 return STATUS_SUCCESS;
1153 }
1154
1155
1156 static NTSTATUS fold_string( DWORD flags, const WCHAR *src, int srclen, WCHAR *dst, int *dstlen )
1157 {
1158 NTSTATUS ret;
1159 WCHAR *tmp;
1160
1161 switch (flags)
1162 {
1163 case MAP_PRECOMPOSED:
1164 return RtlNormalizeString( NormalizationC, src, srclen, dst, dstlen );
1165 case MAP_FOLDCZONE:
1166 case MAP_PRECOMPOSED | MAP_FOLDCZONE:
1167 return RtlNormalizeString( NormalizationKC, src, srclen, dst, dstlen );
1168 case MAP_COMPOSITE:
1169 return RtlNormalizeString( NormalizationD, src, srclen, dst, dstlen );
1170 case MAP_COMPOSITE | MAP_FOLDCZONE:
1171 return RtlNormalizeString( NormalizationKD, src, srclen, dst, dstlen );
1172 case MAP_FOLDDIGITS:
1173 return fold_digits( src, srclen, dst, dstlen );
1174 case MAP_EXPAND_LIGATURES:
1175 case MAP_EXPAND_LIGATURES | MAP_FOLDCZONE:
1176 return expand_ligatures( src, srclen, dst, dstlen );
1177 case MAP_FOLDDIGITS | MAP_PRECOMPOSED:
1178 if (!(tmp = RtlAllocateHeap( GetProcessHeap(), 0, srclen * sizeof(WCHAR) )))
1179 return STATUS_NO_MEMORY;
1180 fold_digits( src, srclen, tmp, &srclen );
1181 ret = RtlNormalizeString( NormalizationC, tmp, srclen, dst, dstlen );
1182 break;
1183 case MAP_FOLDDIGITS | MAP_FOLDCZONE:
1184 case MAP_FOLDDIGITS | MAP_PRECOMPOSED | MAP_FOLDCZONE:
1185 if (!(tmp = RtlAllocateHeap( GetProcessHeap(), 0, srclen * sizeof(WCHAR) )))
1186 return STATUS_NO_MEMORY;
1187 fold_digits( src, srclen, tmp, &srclen );
1188 ret = RtlNormalizeString( NormalizationKC, tmp, srclen, dst, dstlen );
1189 break;
1190 case MAP_FOLDDIGITS | MAP_COMPOSITE:
1191 if (!(tmp = RtlAllocateHeap( GetProcessHeap(), 0, srclen * sizeof(WCHAR) )))
1192 return STATUS_NO_MEMORY;
1193 fold_digits( src, srclen, tmp, &srclen );
1194 ret = RtlNormalizeString( NormalizationD, tmp, srclen, dst, dstlen );
1195 break;
1196 case MAP_FOLDDIGITS | MAP_COMPOSITE | MAP_FOLDCZONE:
1197 if (!(tmp = RtlAllocateHeap( GetProcessHeap(), 0, srclen * sizeof(WCHAR) )))
1198 return STATUS_NO_MEMORY;
1199 fold_digits( src, srclen, tmp, &srclen );
1200 ret = RtlNormalizeString( NormalizationKD, tmp, srclen, dst, dstlen );
1201 break;
1202 case MAP_EXPAND_LIGATURES | MAP_FOLDDIGITS:
1203 case MAP_EXPAND_LIGATURES | MAP_FOLDDIGITS | MAP_FOLDCZONE:
1204 if (!(tmp = RtlAllocateHeap( GetProcessHeap(), 0, srclen * sizeof(WCHAR) )))
1205 return STATUS_NO_MEMORY;
1206 fold_digits( src, srclen, tmp, &srclen );
1207 ret = expand_ligatures( tmp, srclen, dst, dstlen );
1208 break;
1209 default:
1210 return STATUS_INVALID_PARAMETER_1;
1211 }
1212 RtlFreeHeap( GetProcessHeap(), 0, tmp );
1213 return ret;
1214 }
1215
1216
1217 static int mbstowcs_cpsymbol( DWORD flags, const char *src, int srclen, WCHAR *dst, int dstlen )
1218 {
1219 int len, i;
1220
1221 if (flags)
1222 {
1223 SetLastError( ERROR_INVALID_FLAGS );
1224 return 0;
1225 }
1226 if (!dstlen) return srclen;
1227 len = min( srclen, dstlen );
1228 for (i = 0; i < len; i++)
1229 {
1230 unsigned char c = src[i];
1231 dst[i] = (c < 0x20) ? c : c + 0xf000;
1232 }
1233 if (len < srclen)
1234 {
1235 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1236 return 0;
1237 }
1238 return len;
1239 }
1240
1241
1242 static int mbstowcs_utf7( DWORD flags, const char *src, int srclen, WCHAR *dst, int dstlen )
1243 {
1244 static const signed char base64_decoding_table[] =
1245 {
1246 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x00-0x0F */
1247 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x10-0x1F */
1248 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, /* 0x20-0x2F */
1249 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, /* 0x30-0x3F */
1250 -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, /* 0x40-0x4F */
1251 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, /* 0x50-0x5F */
1252 -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, /* 0x60-0x6F */
1253 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1 /* 0x70-0x7F */
1254 };
1255
1256 const char *source_end = src + srclen;
1257 int offset = 0, pos = 0;
1258 DWORD byte_pair = 0;
1259
1260 if (flags)
1261 {
1262 SetLastError( ERROR_INVALID_FLAGS );
1263 return 0;
1264 }
1265 #define OUTPUT(ch) \
1266 do { \
1267 if (dstlen > 0) \
1268 { \
1269 if (pos >= dstlen) goto overflow; \
1270 dst[pos] = (ch); \
1271 } \
1272 pos++; \
1273 } while(0)
1274
1275 while (src < source_end)
1276 {
1277 if (*src == '+')
1278 {
1279 src++;
1280 if (src >= source_end) break;
1281 if (*src == '-')
1282 {
1283 /* just a plus sign escaped as +- */
1284 OUTPUT( '+' );
1285 src++;
1286 continue;
1287 }
1288
1289 do
1290 {
1291 signed char sextet = *src;
1292 if (sextet == '-')
1293 {
1294 /* skip over the dash and end base64 decoding
1295 * the current, unfinished byte pair is discarded */
1296 src++;
1297 offset = 0;
1298 break;
1299 }
1300 if (sextet < 0)
1301 {
1302 /* the next character of src is < 0 and therefore not part of a base64 sequence
1303 * the current, unfinished byte pair is NOT discarded in this case
1304 * this is probably a bug in Windows */
1305 break;
1306 }
1307 sextet = base64_decoding_table[sextet];
1308 if (sextet == -1)
1309 {
1310 /* -1 means that the next character of src is not part of a base64 sequence
1311 * in other words, all sextets in this base64 sequence have been processed
1312 * the current, unfinished byte pair is discarded */
1313 offset = 0;
1314 break;
1315 }
1316
1317 byte_pair = (byte_pair << 6) | sextet;
1318 offset += 6;
1319 if (offset >= 16)
1320 {
1321 /* this byte pair is done */
1322 OUTPUT( byte_pair >> (offset - 16) );
1323 offset -= 16;
1324 }
1325 src++;
1326 }
1327 while (src < source_end);
1328 }
1329 else
1330 {
1331 OUTPUT( (unsigned char)*src );
1332 src++;
1333 }
1334 }
1335 return pos;
1336
1337 overflow:
1338 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1339 return 0;
1340 #undef OUTPUT
1341 }
1342
1343
1344 static int mbstowcs_utf8( DWORD flags, const char *src, int srclen, WCHAR *dst, int dstlen )
1345 {
1346 DWORD reslen;
1347 NTSTATUS status;
1348
1349 if (flags & ~(MB_PRECOMPOSED | MB_COMPOSITE | MB_USEGLYPHCHARS | MB_ERR_INVALID_CHARS))
1350 {
1351 SetLastError( ERROR_INVALID_FLAGS );
1352 return 0;
1353 }
1354 if (!dstlen) dst = NULL;
1355 status = RtlUTF8ToUnicodeN( dst, dstlen * sizeof(WCHAR), &reslen, src, srclen );
1356 if (status == STATUS_SOME_NOT_MAPPED)
1357 {
1358 if (flags & MB_ERR_INVALID_CHARS)
1359 {
1360 SetLastError( ERROR_NO_UNICODE_TRANSLATION );
1361 return 0;
1362 }
1363 }
1364 else if (!set_ntstatus( status )) reslen = 0;
1365
1366 return reslen / sizeof(WCHAR);
1367 }
1368
1369
1370 static inline int is_private_use_area_char( WCHAR code )
1371 {
1372 return (code >= 0xe000 && code <= 0xf8ff);
1373 }
1374
1375
1376 static int check_invalid_chars( const CPTABLEINFO *info, const unsigned char *src, int srclen )
1377 {
1378 if (info->DBCSOffsets)
1379 {
1380 for ( ; srclen; src++, srclen-- )
1381 {
1382 USHORT off = info->DBCSOffsets[*src];
1383 if (off)
1384 {
1385 if (srclen == 1) break; /* partial char, error */
1386 if (info->DBCSOffsets[off + src[1]] == info->UniDefaultChar &&
1387 ((src[0] << 8) | src[1]) != info->TransUniDefaultChar) break;
1388 src++;
1389 srclen--;
1390 continue;
1391 }
1392 if (info->MultiByteTable[*src] == info->UniDefaultChar && *src != info->TransUniDefaultChar)
1393 break;
1394 if (is_private_use_area_char( info->MultiByteTable[*src] )) break;
1395 }
1396 }
1397 else
1398 {
1399 for ( ; srclen; src++, srclen-- )
1400 {
1401 if (info->MultiByteTable[*src] == info->UniDefaultChar && *src != info->TransUniDefaultChar)
1402 break;
1403 if (is_private_use_area_char( info->MultiByteTable[*src] )) break;
1404 }
1405 }
1406 return !!srclen;
1407
1408 }
1409
1410
1411 static int mbstowcs_decompose( const CPTABLEINFO *info, const unsigned char *src, int srclen,
1412 WCHAR *dst, int dstlen )
1413 {
1414 WCHAR ch;
1415 USHORT off;
1416 int len;
1417 const WCHAR *decomp;
1418 unsigned int decomp_len;
1419
1420 if (info->DBCSOffsets)
1421 {
1422 if (!dstlen) /* compute length */
1423 {
1424 for (len = 0; srclen; srclen--, src++, len += decomp_len)
1425 {
1426 if ((off = info->DBCSOffsets[*src]))
1427 {
1428 if (srclen > 1 && src[1])
1429 {
1430 src++;
1431 srclen--;
1432 ch = info->DBCSOffsets[off + *src];
1433 }
1434 else ch = info->UniDefaultChar;
1435 }
1436 else ch = info->MultiByteTable[*src];
1437 get_decomposition( ch, &decomp_len );
1438 }
1439 return len;
1440 }
1441
1442 for (len = dstlen; srclen && len; srclen--, src++, dst += decomp_len, len -= decomp_len)
1443 {
1444 if ((off = info->DBCSOffsets[*src]))
1445 {
1446 if (srclen > 1 && src[1])
1447 {
1448 src++;
1449 srclen--;
1450 ch = info->DBCSOffsets[off + *src];
1451 }
1452 else ch = info->UniDefaultChar;
1453 }
1454 else ch = info->MultiByteTable[*src];
1455
1456 if ((decomp = get_decomposition( ch, &decomp_len )))
1457 {
1458 if (len < decomp_len) break;
1459 memcpy( dst, decomp, decomp_len * sizeof(WCHAR) );
1460 }
1461 else *dst = ch;
1462 }
1463 }
1464 else
1465 {
1466 if (!dstlen) /* compute length */
1467 {
1468 for (len = 0; srclen; srclen--, src++, len += decomp_len)
1469 get_decomposition( info->MultiByteTable[*src], &decomp_len );
1470 return len;
1471 }
1472
1473 for (len = dstlen; srclen && len; srclen--, src++, dst += decomp_len, len -= decomp_len)
1474 {
1475 ch = info->MultiByteTable[*src];
1476 if ((decomp = get_decomposition( ch, &decomp_len )))
1477 {
1478 if (len < decomp_len) break;
1479 memcpy( dst, decomp, decomp_len * sizeof(WCHAR) );
1480 }
1481 else *dst = ch;
1482 }
1483 }
1484
1485 if (srclen)
1486 {
1487 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1488 return 0;
1489 }
1490 return dstlen - len;
1491 }
1492
1493
1494 static int mbstowcs_sbcs( const CPTABLEINFO *info, const unsigned char *src, int srclen,
1495 WCHAR *dst, int dstlen )
1496 {
1497 const USHORT *table = info->MultiByteTable;
1498 int ret = srclen;
1499
1500 if (!dstlen) return srclen;
1501
1502 if (dstlen < srclen) /* buffer too small: fill it up to dstlen and return error */
1503 {
1504 srclen = dstlen;
1505 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1506 ret = 0;
1507 }
1508
1509 while (srclen >= 16)
1510 {
1511 dst[0] = table[src[0]];
1512 dst[1] = table[src[1]];
1513 dst[2] = table[src[2]];
1514 dst[3] = table[src[3]];
1515 dst[4] = table[src[4]];
1516 dst[5] = table[src[5]];
1517 dst[6] = table[src[6]];
1518 dst[7] = table[src[7]];
1519 dst[8] = table[src[8]];
1520 dst[9] = table[src[9]];
1521 dst[10] = table[src[10]];
1522 dst[11] = table[src[11]];
1523 dst[12] = table[src[12]];
1524 dst[13] = table[src[13]];
1525 dst[14] = table[src[14]];
1526 dst[15] = table[src[15]];
1527 src += 16;
1528 dst += 16;
1529 srclen -= 16;
1530 }
1531
1532 /* now handle the remaining characters */
1533 src += srclen;
1534 dst += srclen;
1535 switch (srclen)
1536 {
1537 case 15: dst[-15] = table[src[-15]];
1538 case 14: dst[-14] = table[src[-14]];
1539 case 13: dst[-13] = table[src[-13]];
1540 case 12: dst[-12] = table[src[-12]];
1541 case 11: dst[-11] = table[src[-11]];
1542 case 10: dst[-10] = table[src[-10]];
1543 case 9: dst[-9] = table[src[-9]];
1544 case 8: dst[-8] = table[src[-8]];
1545 case 7: dst[-7] = table[src[-7]];
1546 case 6: dst[-6] = table[src[-6]];
1547 case 5: dst[-5] = table[src[-5]];
1548 case 4: dst[-4] = table[src[-4]];
1549 case 3: dst[-3] = table[src[-3]];
1550 case 2: dst[-2] = table[src[-2]];
1551 case 1: dst[-1] = table[src[-1]];
1552 case 0: break;
1553 }
1554 return ret;
1555 }
1556
1557
1558 static int mbstowcs_dbcs( const CPTABLEINFO *info, const unsigned char *src, int srclen,
1559 WCHAR *dst, int dstlen )
1560 {
1561 USHORT off;
1562 int i;
1563
1564 if (!dstlen)
1565 {
1566 for (i = 0; srclen; i++, src++, srclen--)
1567 if (info->DBCSOffsets[*src] && srclen > 1 && src[1]) { src++; srclen--; }
1568 return i;
1569 }
1570
1571 for (i = dstlen; srclen && i; i--, srclen--, src++, dst++)
1572 {
1573 if ((off = info->DBCSOffsets[*src]))
1574 {
1575 if (srclen > 1 && src[1])
1576 {
1577 src++;
1578 srclen--;
1579 *dst = info->DBCSOffsets[off + *src];
1580 }
1581 else *dst = info->UniDefaultChar;
1582 }
1583 else *dst = info->MultiByteTable[*src];
1584 }
1585 if (srclen)
1586 {
1587 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1588 return 0;
1589 }
1590 return dstlen - i;
1591 }
1592
1593
1594 static int mbstowcs_codepage( UINT codepage, DWORD flags, const char *src, int srclen,
1595 WCHAR *dst, int dstlen )
1596 {
1597 CPTABLEINFO local_info;
1598 const CPTABLEINFO *info = get_codepage_table( codepage );
1599 const unsigned char *str = (const unsigned char *)src;
1600
1601 if (!info)
1602 {
1603 SetLastError( ERROR_INVALID_PARAMETER );
1604 return 0;
1605 }
1606 if (flags & ~(MB_PRECOMPOSED | MB_COMPOSITE | MB_USEGLYPHCHARS | MB_ERR_INVALID_CHARS))
1607 {
1608 SetLastError( ERROR_INVALID_FLAGS );
1609 return 0;
1610 }
1611
1612 if ((flags & MB_USEGLYPHCHARS) && info->MultiByteTable[256] == 256)
1613 {
1614 local_info = *info;
1615 local_info.MultiByteTable += 257;
1616 info = &local_info;
1617 }
1618 if ((flags & MB_ERR_INVALID_CHARS) && check_invalid_chars( info, str, srclen ))
1619 {
1620 SetLastError( ERROR_NO_UNICODE_TRANSLATION );
1621 return 0;
1622 }
1623
1624 if (flags & MB_COMPOSITE) return mbstowcs_decompose( info, str, srclen, dst, dstlen );
1625
1626 if (info->DBCSOffsets)
1627 return mbstowcs_dbcs( info, str, srclen, dst, dstlen );
1628 else
1629 return mbstowcs_sbcs( info, str, srclen, dst, dstlen );
1630 }
1631
1632
1633 static int wcstombs_cpsymbol( DWORD flags, const WCHAR *src, int srclen, char *dst, int dstlen,
1634 const char *defchar, BOOL *used )
1635 {
1636 int len, i;
1637
1638 if (flags)
1639 {
1640 SetLastError( ERROR_INVALID_FLAGS );
1641 return 0;
1642 }
1643 if (defchar || used)
1644 {
1645 SetLastError( ERROR_INVALID_PARAMETER );
1646 return 0;
1647 }
1648 if (!dstlen) return srclen;
1649 len = min( srclen, dstlen );
1650 for (i = 0; i < len; i++)
1651 {
1652 if (src[i] < 0x20) dst[i] = src[i];
1653 else if (src[i] >= 0xf020 && src[i] < 0xf100) dst[i] = src[i] - 0xf000;
1654 else
1655 {
1656 SetLastError( ERROR_NO_UNICODE_TRANSLATION );
1657 return 0;
1658 }
1659 }
1660 if (srclen > len)
1661 {
1662 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1663 return 0;
1664 }
1665 return len;
1666 }
1667
1668
1669 static int wcstombs_utf7( DWORD flags, const WCHAR *src, int srclen, char *dst, int dstlen,
1670 const char *defchar, BOOL *used )
1671 {
1672 static const char directly_encodable[] =
1673 {
1674 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, /* 0x00 - 0x0f */
1675 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x10 - 0x1f */
1676 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, /* 0x20 - 0x2f */
1677 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, /* 0x30 - 0x3f */
1678 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x40 - 0x4f */
1679 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, /* 0x50 - 0x5f */
1680 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0x60 - 0x6f */
1681 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 /* 0x70 - 0x7a */
1682 };
1683 #define ENCODABLE(ch) ((ch) <= 0x7a && directly_encodable[(ch)])
1684
1685 static const char base64_encoding_table[] =
1686 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
1687
1688 const WCHAR *source_end = src + srclen;
1689 int pos = 0;
1690
1691 if (defchar || used)
1692 {
1693 SetLastError( ERROR_INVALID_PARAMETER );
1694 return 0;
1695 }
1696 if (flags)
1697 {
1698 SetLastError( ERROR_INVALID_FLAGS );
1699 return 0;
1700 }
1701
1702 #define OUTPUT(ch) \
1703 do { \
1704 if (dstlen > 0) \
1705 { \
1706 if (pos >= dstlen) goto overflow; \
1707 dst[pos] = (ch); \
1708 } \
1709 pos++; \
1710 } while (0)
1711
1712 while (src < source_end)
1713 {
1714 if (*src == '+')
1715 {
1716 OUTPUT( '+' );
1717 OUTPUT( '-' );
1718 src++;
1719 }
1720 else if (ENCODABLE(*src))
1721 {
1722 OUTPUT( *src );
1723 src++;
1724 }
1725 else
1726 {
1727 unsigned int offset = 0, byte_pair = 0;
1728
1729 OUTPUT( '+' );
1730 while (src < source_end && !ENCODABLE(*src))
1731 {
1732 byte_pair = (byte_pair << 16) | *src;
1733 offset += 16;
1734 while (offset >= 6)
1735 {
1736 offset -= 6;
1737 OUTPUT( base64_encoding_table[(byte_pair >> offset) & 0x3f] );
1738 }
1739 src++;
1740 }
1741 if (offset)
1742 {
1743 /* Windows won't create a padded base64 character if there's no room for the - sign
1744 * as well ; this is probably a bug in Windows */
1745 if (dstlen > 0 && pos + 1 >= dstlen) goto overflow;
1746 byte_pair <<= (6 - offset);
1747 OUTPUT( base64_encoding_table[byte_pair & 0x3f] );
1748 }
1749 /* Windows always explicitly terminates the base64 sequence
1750 even though RFC 2152 (page 3, rule 2) does not require this */
1751 OUTPUT( '-' );
1752 }
1753 }
1754 return pos;
1755
1756 overflow:
1757 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1758 return 0;
1759 #undef OUTPUT
1760 #undef ENCODABLE
1761 }
1762
1763
1764 static int wcstombs_utf8( DWORD flags, const WCHAR *src, int srclen, char *dst, int dstlen,
1765 const char *defchar, BOOL *used )
1766 {
1767 DWORD reslen;
1768 NTSTATUS status;
1769
1770 if (defchar || used)
1771 {
1772 SetLastError( ERROR_INVALID_PARAMETER );
1773 return 0;
1774 }
1775 if (flags & ~(WC_DISCARDNS | WC_SEPCHARS | WC_DEFAULTCHAR | WC_ERR_INVALID_CHARS |
1776 WC_COMPOSITECHECK | WC_NO_BEST_FIT_CHARS))
1777 {
1778 SetLastError( ERROR_INVALID_FLAGS );
1779 return 0;
1780 }
1781 if (!dstlen) dst = NULL;
1782 status = RtlUnicodeToUTF8N( dst, dstlen, &reslen, src, srclen * sizeof(WCHAR) );
1783 if (status == STATUS_SOME_NOT_MAPPED)
1784 {
1785 if (flags & WC_ERR_INVALID_CHARS)
1786 {
1787 SetLastError( ERROR_NO_UNICODE_TRANSLATION );
1788 return 0;
1789 }
1790 }
1791 else if (!set_ntstatus( status )) reslen = 0;
1792 return reslen;
1793 }
1794
1795
1796 static int wcstombs_sbcs( const CPTABLEINFO *info, const WCHAR *src, unsigned int srclen,
1797 char *dst, unsigned int dstlen )
1798 {
1799 const char *table = info->WideCharTable;
1800 int ret = srclen;
1801
1802 if (!dstlen) return srclen;
1803
1804 if (dstlen < srclen)
1805 {
1806 /* buffer too small: fill it up to dstlen and return error */
1807 srclen = dstlen;
1808 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1809 ret = 0;
1810 }
1811
1812 while (srclen >= 16)
1813 {
1814 dst[0] = table[src[0]];
1815 dst[1] = table[src[1]];
1816 dst[2] = table[src[2]];
1817 dst[3] = table[src[3]];
1818 dst[4] = table[src[4]];
1819 dst[5] = table[src[5]];
1820 dst[6] = table[src[6]];
1821 dst[7] = table[src[7]];
1822 dst[8] = table[src[8]];
1823 dst[9] = table[src[9]];
1824 dst[10] = table[src[10]];
1825 dst[11] = table[src[11]];
1826 dst[12] = table[src[12]];
1827 dst[13] = table[src[13]];
1828 dst[14] = table[src[14]];
1829 dst[15] = table[src[15]];
1830 src += 16;
1831 dst += 16;
1832 srclen -= 16;
1833 }
1834
1835 /* now handle remaining characters */
1836 src += srclen;
1837 dst += srclen;
1838 switch(srclen)
1839 {
1840 case 15: dst[-15] = table[src[-15]];
1841 case 14: dst[-14] = table[src[-14]];
1842 case 13: dst[-13] = table[src[-13]];
1843 case 12: dst[-12] = table[src[-12]];
1844 case 11: dst[-11] = table[src[-11]];
1845 case 10: dst[-10] = table[src[-10]];
1846 case 9: dst[-9] = table[src[-9]];
1847 case 8: dst[-8] = table[src[-8]];
1848 case 7: dst[-7] = table[src[-7]];
1849 case 6: dst[-6] = table[src[-6]];
1850 case 5: dst[-5] = table[src[-5]];
1851 case 4: dst[-4] = table[src[-4]];
1852 case 3: dst[-3] = table[src[-3]];
1853 case 2: dst[-2] = table[src[-2]];
1854 case 1: dst[-1] = table[src[-1]];
1855 case 0: break;
1856 }
1857 return ret;
1858 }
1859
1860
1861 static int wcstombs_dbcs( const CPTABLEINFO *info, const WCHAR *src, unsigned int srclen,
1862 char *dst, unsigned int dstlen )
1863 {
1864 const USHORT *table = info->WideCharTable;
1865 int i;
1866
1867 if (!dstlen)
1868 {
1869 for (i = 0; srclen; src++, srclen--, i++) if (table[*src] & 0xff00) i++;
1870 return i;
1871 }
1872
1873 for (i = dstlen; srclen && i; i--, srclen--, src++)
1874 {
1875 if (table[*src] & 0xff00)
1876 {
1877 if (i == 1) break; /* do not output a partial char */
1878 i--;
1879 *dst++ = table[*src] >> 8;
1880 }
1881 *dst++ = (char)table[*src];
1882 }
1883 if (srclen)
1884 {
1885 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1886 return 0;
1887 }
1888 return dstlen - i;
1889 }
1890
1891
1892 static inline int is_valid_sbcs_mapping( const CPTABLEINFO *info, DWORD flags, unsigned int wch )
1893 {
1894 const unsigned char *table = info->WideCharTable;
1895
1896 if (wch >= 0x10000) return 0;
1897 if ((flags & WC_NO_BEST_FIT_CHARS) || table[wch] == info->DefaultChar)
1898 return (info->MultiByteTable[table[wch]] == wch);
1899 return 1;
1900 }
1901
1902
1903 static inline int is_valid_dbcs_mapping( const CPTABLEINFO *info, DWORD flags, unsigned int wch )
1904 {
1905 const unsigned short *table = info->WideCharTable;
1906 unsigned short ch;
1907
1908 if (wch >= 0x10000) return 0;
1909 ch = table[wch];
1910 if ((flags & WC_NO_BEST_FIT_CHARS) || ch == info->DefaultChar)
1911 {
1912 if (ch >> 8) return info->DBCSOffsets[info->DBCSOffsets[ch >> 8] + (ch & 0xff)] == wch;
1913 return info->MultiByteTable[ch] == wch;
1914 }
1915 return 1;
1916 }
1917
1918
1919 static int wcstombs_sbcs_slow( const CPTABLEINFO *info, DWORD flags, const WCHAR *src, unsigned int srclen,
1920 char *dst, unsigned int dstlen, const char *defchar, BOOL *used )
1921 {
1922 const char *table = info->WideCharTable;
1923 const char def = defchar ? *defchar : (char)info->DefaultChar;
1924 int i;
1925 BOOL tmp;
1926 WCHAR wch;
1927 unsigned int composed;
1928
1929 if (!used) used = &tmp; /* avoid checking on every char */
1930 *used = FALSE;
1931
1932 if (!dstlen)
1933 {
1934 for (i = 0; srclen; i++, src++, srclen--)
1935 {
1936 wch = *src;
1937 if ((flags & WC_COMPOSITECHECK) && (srclen > 1) && (composed = compose_chars( src[0], src[1] )))
1938 {
1939 /* now check if we can use the composed char */
1940 if (is_valid_sbcs_mapping( info, flags, composed ))
1941 {
1942 /* we have a good mapping, use it */
1943 src++;
1944 srclen--;
1945 continue;
1946 }
1947 /* no mapping for the composed char, check the other flags */
1948 if (flags & WC_DEFAULTCHAR) /* use the default char instead */
1949 {
1950 *used = TRUE;
1951 src++; /* skip the non-spacing char */
1952 srclen--;
1953 continue;
1954 }
1955 if (flags & WC_DISCARDNS) /* skip the second char of the composition */
1956 {
1957 src++;
1958 srclen--;
1959 }
1960 /* WC_SEPCHARS is the default */
1961 }
1962 if (!*used) *used = !is_valid_sbcs_mapping( info, flags, wch );
1963 }
1964 return i;
1965 }
1966
1967 for (i = dstlen; srclen && i; dst++, i--, src++, srclen--)
1968 {
1969 wch = *src;
1970 if ((flags & WC_COMPOSITECHECK) && (srclen > 1) && (composed = compose_chars( src[0], src[1] )))
1971 {
1972 /* now check if we can use the composed char */
1973 if (is_valid_sbcs_mapping( info, flags, composed ))
1974 {
1975 /* we have a good mapping, use it */
1976 *dst = table[composed];
1977 src++;
1978 srclen--;
1979 continue;
1980 }
1981 /* no mapping for the composed char, check the other flags */
1982 if (flags & WC_DEFAULTCHAR) /* use the default char instead */
1983 {
1984 *dst = def;
1985 *used = TRUE;
1986 src++; /* skip the non-spacing char */
1987 srclen--;
1988 continue;
1989 }
1990 if (flags & WC_DISCARDNS) /* skip the second char of the composition */
1991 {
1992 src++;
1993 srclen--;
1994 }
1995 /* WC_SEPCHARS is the default */
1996 }
1997
1998 *dst = table[wch];
1999 if (!is_valid_sbcs_mapping( info, flags, wch ))
2000 {
2001 *dst = def;
2002 *used = TRUE;
2003 }
2004 }
2005 if (srclen)
2006 {
2007 SetLastError( ERROR_INSUFFICIENT_BUFFER );
2008 return 0;
2009 }
2010 return dstlen - i;
2011 }
2012
2013
2014 static int wcstombs_dbcs_slow( const CPTABLEINFO *info, DWORD flags, const WCHAR *src, unsigned int srclen,
2015 char *dst, unsigned int dstlen, const char *defchar, BOOL *used )
2016 {
2017 const USHORT *table = info->WideCharTable;
2018 WCHAR wch, defchar_value;
2019 unsigned int composed;
2020 unsigned short res;
2021 BOOL tmp;
2022 int i;
2023
2024 if (!defchar[1]) defchar_value = (unsigned char)defchar[0];
2025 else defchar_value = ((unsigned char)defchar[0] << 8) | (unsigned char)defchar[1];
2026
2027 if (!used) used = &tmp; /* avoid checking on every char */
2028 *used = FALSE;
2029
2030 if (!dstlen)
2031 {
2032 if (!defchar && !used && !(flags & WC_COMPOSITECHECK))
2033 {
2034 for (i = 0; srclen; srclen--, src++, i++) if (table[*src] & 0xff00) i++;
2035 return i;
2036 }
2037 for (i = 0; srclen; srclen--, src++, i++)
2038 {
2039 wch = *src;
2040 if ((flags & WC_COMPOSITECHECK) && (srclen > 1) && (composed = compose_chars( src[0], src[1] )))
2041 {
2042 /* now check if we can use the composed char */
2043 if (is_valid_dbcs_mapping( info, flags, composed ))
2044 {
2045 /* we have a good mapping for the composed char, use it */
2046 res = table[composed];
2047 if (res & 0xff00) i++;
2048 src++;
2049 srclen--;
2050 continue;
2051 }
2052 /* no mapping for the composed char, check the other flags */
2053 if (flags & WC_DEFAULTCHAR) /* use the default char instead */
2054 {
2055 if (defchar_value & 0xff00) i++;
2056 *used = TRUE;
2057 src++; /* skip the non-spacing char */
2058 srclen--;
2059 continue;
2060 }
2061 if (flags & WC_DISCARDNS) /* skip the second char of the composition */
2062 {
2063 src++;
2064 srclen--;
2065 }
2066 /* WC_SEPCHARS is the default */
2067 }
2068
2069 res = table[wch];
2070 if (!is_valid_dbcs_mapping( info, flags, wch ))
2071 {
2072 res = defchar_value;
2073 *used = TRUE;
2074 }
2075 if (res & 0xff00) i++;
2076 }
2077 return i;
2078 }
2079
2080
2081 for (i = dstlen; srclen && i; i--, srclen--, src++)
2082 {
2083 wch = *src;
2084 if ((flags & WC_COMPOSITECHECK) && (srclen > 1) && (composed = compose_chars( src[0], src[1] )))
2085 {
2086 /* now check if we can use the composed char */
2087 if (is_valid_dbcs_mapping( info, flags, composed ))
2088 {
2089 /* we have a good mapping for the composed char, use it */
2090 res = table[composed];
2091 src++;
2092 srclen--;
2093 goto output_char;
2094 }
2095 /* no mapping for the composed char, check the other flags */
2096 if (flags & WC_DEFAULTCHAR) /* use the default char instead */
2097 {
2098 res = defchar_value;
2099 *used = TRUE;
2100 src++; /* skip the non-spacing char */
2101 srclen--;
2102 goto output_char;
2103 }
2104 if (flags & WC_DISCARDNS) /* skip the second char of the composition */
2105 {
2106 src++;
2107 srclen--;
2108 }
2109 /* WC_SEPCHARS is the default */
2110 }
2111
2112 res = table[wch];
2113 if (!is_valid_dbcs_mapping( info, flags, wch ))
2114 {
2115 res = defchar_value;
2116 *used = TRUE;
2117 }
2118
2119 output_char:
2120 if (res & 0xff00)
2121 {
2122 if (i == 1) break; /* do not output a partial char */
2123 i--;
2124 *dst++ = res >> 8;
2125 }
2126 *dst++ = (char)res;
2127 }
2128 if (srclen)
2129 {
2130 SetLastError( ERROR_INSUFFICIENT_BUFFER );
2131 return 0;
2132 }
2133 return dstlen - i;
2134 }
2135
2136
2137 static int wcstombs_codepage( UINT codepage, DWORD flags, const WCHAR *src, int srclen,
2138 char *dst, int dstlen, const char *defchar, BOOL *used )
2139 {
2140 const CPTABLEINFO *info = get_codepage_table( codepage );
2141
2142 if (!info)
2143 {
2144 SetLastError( ERROR_INVALID_PARAMETER );
2145 return 0;
2146 }
2147 if (flags & ~(WC_DISCARDNS | WC_SEPCHARS | WC_DEFAULTCHAR | WC_ERR_INVALID_CHARS |
2148 WC_COMPOSITECHECK | WC_NO_BEST_FIT_CHARS))
2149 {
2150 SetLastError( ERROR_INVALID_FLAGS );
2151 return 0;
2152 }
2153 if (flags || defchar || used)
2154 {
2155 if (!defchar) defchar = (const char *)&info->DefaultChar;
2156 if (info->DBCSOffsets)
2157 return wcstombs_dbcs_slow( info, flags, src, srclen, dst, dstlen, defchar, used );
2158 else
2159 return wcstombs_sbcs_slow( info, flags, src, srclen, dst, dstlen, defchar, used );
2160 }
2161 if (info->DBCSOffsets)
2162 return wcstombs_dbcs( info, src, srclen, dst, dstlen );
2163 else
2164 return wcstombs_sbcs( info, src, srclen, dst, dstlen );
2165 }
2166
2167
2168 static int get_sortkey( DWORD flags, const WCHAR *src, int srclen, char *dst, int dstlen )
2169 {
2170 WCHAR dummy[4]; /* no decomposition is larger than 4 chars */
2171 int key_len[4];
2172 char *key_ptr[4];
2173 const WCHAR *src_save = src;
2174 int srclen_save = srclen;
2175
2176 key_len[0] = key_len[1] = key_len[2] = key_len[3] = 0;
2177 for (; srclen; srclen--, src++)
2178 {
2179 unsigned int i, decomposed_len = 1;/*wine_decompose(*src, dummy, 4);*/
2180 dummy[0] = *src;
2181 if (decomposed_len)
2182 {
2183 for (i = 0; i < decomposed_len; i++)
2184 {
2185 WCHAR wch = dummy[i];
2186 unsigned int ce;
2187
2188 if ((flags & NORM_IGNORESYMBOLS) &&
2189 (get_char_type( CT_CTYPE1, wch ) & (C1_PUNCT | C1_SPACE)))
2190 continue;
2191
2192 if (flags & NORM_IGNORECASE) wch = casemap( nls_info.LowerCaseTable, wch );
2193
2194 ce = collation_table[collation_table[collation_table[wch >> 8] + ((wch >> 4) & 0x0f)] + (wch & 0xf)];
2195 if (ce != (unsigned int)-1)
2196 {
2197 if (ce >> 16) key_len[0] += 2;
2198 if ((ce >> 8) & 0xff) key_len[1]++;
2199 if ((ce >> 4) & 0x0f) key_len[2]++;
2200 if (ce & 1)
2201 {
2202 if (wch >> 8) key_len[3]++;
2203 key_len[3]++;
2204 }
2205 }
2206 else
2207 {
2208 key_len[0] += 2;
2209 if (wch >> 8) key_len[0]++;
2210 if (wch & 0xff) key_len[0]++;
2211 }
2212 }
2213 }
2214 }
2215
2216 if (!dstlen) /* compute length */
2217 /* 4 * '\1' + key length */
2218 return key_len[0] + key_len[1] + key_len[2] + key_len[3] + 4;
2219
2220 if (dstlen < key_len[0] + key_len[1] + key_len[2] + key_len[3] + 4 + 1)
2221 return 0; /* overflow */
2222
2223 src = src_save;
2224 srclen = srclen_save;
2225
2226 key_ptr[0] = dst;
2227 key_ptr[1] = key_ptr[0] + key_len[0] + 1;
2228 key_ptr[2] = key_ptr[1] + key_len[1] + 1;
2229 key_ptr[3] = key_ptr[2] + key_len[2] + 1;
2230
2231 for (; srclen; srclen--, src++)
2232 {
2233 unsigned int i, decomposed_len = 1;/*wine_decompose(*src, dummy, 4);*/
2234 dummy[0] = *src;
2235 if (decomposed_len)
2236 {
2237 for (i = 0; i < decomposed_len; i++)
2238 {
2239 WCHAR wch = dummy[i];
2240 unsigned int ce;
2241
2242 if ((flags & NORM_IGNORESYMBOLS) &&
2243 (get_char_type( CT_CTYPE1, wch ) & (C1_PUNCT | C1_SPACE)))
2244 continue;
2245
2246 if (flags & NORM_IGNORECASE) wch = casemap( nls_info.LowerCaseTable, wch );
2247
2248 ce = collation_table[collation_table[collation_table[wch >> 8] + ((wch >> 4) & 0x0f)] + (wch & 0xf)];
2249 if (ce != (unsigned int)-1)
2250 {
2251 WCHAR key;
2252 if ((key = ce >> 16))
2253 {
2254 *key_ptr[0]++ = key >> 8;
2255 *key_ptr[0]++ = key & 0xff;
2256 }
2257 /* make key 1 start from 2 */
2258 if ((key = (ce >> 8) & 0xff)) *key_ptr[1]++ = key + 1;
2259 /* make key 2 start from 2 */
2260 if ((key = (ce >> 4) & 0x0f)) *key_ptr[2]++ = key + 1;
2261 /* key 3 is always a character code */
2262 if (ce & 1)
2263 {
2264 if (wch >> 8) *key_ptr[3]++ = wch >> 8;
2265 if (wch & 0xff) *key_ptr[3]++ = wch & 0xff;
2266 }
2267 }
2268 else
2269 {
2270 *key_ptr[0]++ = 0xff;
2271 *key_ptr[0]++ = 0xfe;
2272 if (wch >> 8) *key_ptr[0]++ = wch >> 8;
2273 if (wch & 0xff) *key_ptr[0]++ = wch & 0xff;
2274 }
2275 }
2276 }
2277 }
2278
2279 *key_ptr[0] = 1;
2280 *key_ptr[1] = 1;
2281 *key_ptr[2] = 1;
2282 *key_ptr[3]++ = 1;
2283 *key_ptr[3] = 0;
2284 return key_ptr[3] - dst;
2285 }
2286
2287
2288 /* compose a full-width katakana. return consumed source characters. */
2289 static int compose_katakana( const WCHAR *src, int srclen, WCHAR *dst )
2290 {
2291 static const BYTE katakana_map[] =
2292 {
2293 /* */ 0x02, 0x0c, 0x0d, 0x01, 0xfb, 0xf2, 0xa1, /* U+FF61- */
2294 0xa3, 0xa5, 0xa7, 0xa9, 0xe3, 0xe5, 0xe7, 0xc3, /* U+FF68- */
2295 0xfc, 0xa2, 0xa4, 0xa6, 0xa8, 0xaa, 0xab, 0xad, /* U+FF70- */
2296 0xaf, 0xb1, 0xb3, 0xb5, 0xb7, 0xb9, 0xbb, 0xbd, /* U+FF78- */
2297 0xbf, 0xc1, 0xc4, 0xc6, 0xc8, 0xca, 0xcb, 0xcc, /* U+FF80- */
2298 0xcd, 0xce, 0xcf, 0xd2, 0xd5, 0xd8, 0xdb, 0xde, /* U+FF88- */
2299 0xdf, 0xe0, 0xe1, 0xe2, 0xe4, 0xe6, 0xe8, 0xe9, /* U+FF90- */
2300 0xea, 0xeb, 0xec, 0xed, 0xef, 0xf3, 0x99, 0x9a, /* U+FF98- */
2301 };
2302 WCHAR dummy;
2303 int shift;
2304
2305 if (!dst) dst = &dummy;
2306
2307 switch (*src)
2308 {
2309 case 0x309b:
2310 case 0x309c:
2311 *dst = *src - 2;
2312 return 1;
2313 case 0x30f0:
2314 case 0x30f1:
2315 case 0x30fd:
2316 *dst = *src;
2317 break;
2318 default:
2319 shift = *src - 0xff61;
2320 if (shift < 0 || shift >= ARRAY_SIZE( katakana_map )) return 0;
2321 *dst = katakana_map[shift] | 0x3000;
2322 break;
2323 }
2324
2325 if (srclen <= 1) return 1;
2326
2327 switch (src[1])
2328 {
2329 case 0xff9e: /* datakuten (voiced sound) */
2330 if ((*src >= 0xff76 && *src <= 0xff84) || (*src >= 0xff8a && *src <= 0xff8e) || *src == 0x30fd)
2331 *dst += 1;
2332 else if (*src == 0xff73)
2333 *dst = 0x30f4; /* KATAKANA LETTER VU */
2334 else if (*src == 0xff9c)
2335 *dst = 0x30f7; /* KATAKANA LETTER VA */
2336 else if (*src == 0x30f0)
2337 *dst = 0x30f8; /* KATAKANA LETTER VI */
2338 else if (*src == 0x30f1)
2339 *dst = 0x30f9; /* KATAKANA LETTER VE */
2340 else if (*src == 0xff66)
2341 *dst = 0x30fa; /* KATAKANA LETTER VO */
2342 else
2343 return 1;
2344 break;
2345 case 0xff9f: /* handakuten (semi-voiced sound) */
2346 if (*src >= 0xff8a && *src <= 0xff8e)
2347 *dst += 2;
2348 else
2349 return 1;
2350 break;
2351 default:
2352 return 1;
2353 }
2354 return 2;
2355 }
2356
2357 /* map one or two half-width characters to one full-width character */
2358 static int map_to_fullwidth( const WCHAR *src, int srclen, WCHAR *dst )
2359 {
2360 INT n;
2361
2362 if (*src <= '~' && *src > ' ' && *src != '\\')
2363 *dst = *src - 0x20 + 0xff00;
2364 else if (*src == ' ')
2365 *dst = 0x3000;
2366 else if (*src <= 0x00af && *src >= 0x00a2)
2367 {
2368 static const BYTE misc_symbols_table[] =
2369 {
2370 0xe0, 0xe1, 0x00, 0xe5, 0xe4, 0x00, 0x00, /* U+00A2- */
2371 0x00, 0x00, 0x00, 0xe2, 0x00, 0x00, 0xe3 /* U+00A9- */
2372 };
2373 if (misc_symbols_table[*src - 0x00a2])
2374 *dst = misc_symbols_table[*src - 0x00a2] | 0xff00;
2375 else
2376 *dst = *src;
2377 }
2378 else if (*src == 0x20a9) /* WON SIGN */
2379 *dst = 0xffe6;
2380 else if ((n = compose_katakana(src, srclen, dst)) > 0)
2381 return n;
2382 else if (*src >= 0xffa0 && *src <= 0xffdc)
2383 {
2384 static const BYTE hangul_mapping_table[] =
2385 {
2386 0x64, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, /* U+FFA0- */
2387 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, /* U+FFA8- */
2388 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, /* U+FFB0- */
2389 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x00, /* U+FFB8- */
2390 0x00, 0x00, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, /* U+FFC0- */
2391 0x00, 0x00, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, /* U+FFC8- */
2392 0x00, 0x00, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, /* U+FFD0- */
2393 0x00, 0x00, 0x61, 0x62, 0x63 /* U+FFD8- */
2394 };
2395
2396 if (hangul_mapping_table[*src - 0xffa0])
2397 *dst = hangul_mapping_table[*src - 0xffa0] | 0x3100;
2398 else
2399 *dst = *src;
2400 }
2401 else
2402 *dst = *src;
2403
2404 return 1;
2405 }
2406
2407 /* decompose a full-width katakana character into one or two half-width characters. */
2408 static int decompose_katakana( WCHAR c, WCHAR *dst, int dstlen )
2409 {
2410 static const BYTE katakana_map[] =
2411 {
2412 /* */ 0x9e, 0x9f, 0x9e, 0x9f, 0x00, 0x00, 0x00, /* U+3099- */
2413 0x00, 0x67, 0x71, 0x68, 0x72, 0x69, 0x73, 0x6a, /* U+30a1- */
2414 0x74, 0x6b, 0x75, 0x76, 0x01, 0x77, 0x01, 0x78, /* U+30a8- */
2415 0x01, 0x79, 0x01, 0x7a, 0x01, 0x7b, 0x01, 0x7c, /* U+30b0- */
2416 0x01, 0x7d, 0x01, 0x7e, 0x01, 0x7f, 0x01, 0x80, /* U+30b8- */
2417 0x01, 0x81, 0x01, 0x6f, 0x82, 0x01, 0x83, 0x01, /* U+30c0- */
2418 0x84, 0x01, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, /* U+30c8- */
2419 0x01, 0x02, 0x8b, 0x01, 0x02, 0x8c, 0x01, 0x02, /* U+30d0- */
2420 0x8d, 0x01, 0x02, 0x8e, 0x01, 0x02, 0x8f, 0x90, /* U+30d8- */
2421 0x91, 0x92, 0x93, 0x6c, 0x94, 0x6d, 0x95, 0x6e, /* U+30e0- */
2422 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x00, 0x9c, /* U+30e8- */
2423 0x00, 0x00, 0x66, 0x9d, 0x4e, 0x00, 0x00, 0x08, /* U+30f0- */
2424 0x58, 0x58, 0x08, 0x65, 0x70, 0x00, 0x51 /* U+30f8- */
2425 };
2426 int len = 0, shift = c - 0x3099;
2427 BYTE k;
2428
2429 if (shift < 0 || shift >= ARRAY_SIZE( katakana_map )) return 0;
2430
2431 k = katakana_map[shift];
2432 if (!k)
2433 {
2434 if (dstlen > 0) *dst = c;
2435 len++;
2436 }
2437 else if (k > 0x60)
2438 {
2439 if (dstlen > 0) *dst = k | 0xff00;
2440 len++;
2441 }
2442 else
2443 {
2444 if (dstlen >= 2)
2445 {
2446 dst[0] = (k > 0x50) ? (c - (k & 0xf)) : (katakana_map[shift - k] | 0xff00);
2447 dst[1] = (k == 2) ? 0xff9f : 0xff9e;
2448 }
2449 len += 2;
2450 }
2451 return len;
2452 }
2453
2454 /* map single full-width character to single or double half-width characters. */
2455 static int map_to_halfwidth( WCHAR c, WCHAR *dst, int dstlen )
2456 {
2457 int n = decompose_katakana( c, dst, dstlen );
2458 if (n > 0) return n;
2459
2460 if (c == 0x3000)
2461 *dst = ' ';
2462 else if (c == 0x3001)
2463 *dst = 0xff64;
2464 else if (c == 0x3002)
2465 *dst = 0xff61;
2466 else if (c == 0x300c || c == 0x300d)
2467 *dst = (c - 0x300c) + 0xff62;
2468 else if (c >= 0x3131 && c <= 0x3163)
2469 {
2470 *dst = c - 0x3131 + 0xffa1;
2471 if (*dst >= 0xffbf) *dst += 3;
2472 if (*dst >= 0xffc8) *dst += 2;
2473 if (*dst >= 0xffd0) *dst += 2;
2474 if (*dst >= 0xffd8) *dst += 2;
2475 }
2476 else if (c == 0x3164)
2477 *dst = 0xffa0;
2478 else if (c == 0x2019)
2479 *dst = '\'';
2480 else if (c == 0x201d)
2481 *dst = '"';
2482 else if (c > 0xff00 && c < 0xff5f && c != 0xff3c)
2483 *dst = c - 0xff00 + 0x20;
2484 else if (c >= 0xffe0 && c <= 0xffe6)
2485 {
2486 static const WCHAR misc_symbol_map[] = { 0x00a2, 0x00a3, 0x00ac, 0x00af, 0x00a6, 0x00a5, 0x20a9 };
2487 *dst = misc_symbol_map[c - 0xffe0];
2488 }
2489 else
2490 *dst = c;
2491
2492 return 1;
2493 }
2494
2495
2496 /* 32-bit collation element table format:
2497 * unicode weight - high 16 bit, diacritic weight - high 8 bit of low 16 bit,
2498 * case weight - high 4 bit of low 8 bit.
2499 */
2500
2501 enum weight { UNICODE_WEIGHT, DIACRITIC_WEIGHT, CASE_WEIGHT };
2502
2503 static unsigned int get_weight( WCHAR ch, enum weight type )
2504 {
2505 unsigned int ret;
2506
2507 ret = collation_table[collation_table[collation_table[ch >> 8] + ((ch >> 4) & 0x0f)] + (ch & 0xf)];
2508 if (ret == ~0u) return ch;
2509
2510 switch (type)
2511 {
2512 case UNICODE_WEIGHT: return ret >> 16;
2513 case DIACRITIC_WEIGHT: return (ret >> 8) & 0xff;
2514 case CASE_WEIGHT: return (ret >> 4) & 0x0f;
2515 default: return 0;
2516 }
2517 }
2518
2519
2520 static void inc_str_pos( const WCHAR **str, int *len, unsigned int *dpos, unsigned int *dlen )
2521 {
2522 (*dpos)++;
2523 if (*dpos == *dlen)
2524 {
2525 *dpos = *dlen = 0;
2526 (*str)++;
2527 (*len)--;
2528 }
2529 }
2530
2531
2532 static int compare_weights(int flags, const WCHAR *str1, int len1,
2533 const WCHAR *str2, int len2, enum weight type )
2534 {
2535 unsigned int ce1, ce2, dpos1 = 0, dpos2 = 0, dlen1 = 0, dlen2 = 0;
2536 const WCHAR *dstr1 = NULL, *dstr2 = NULL;
2537
2538 while (len1 > 0 && len2 > 0)
2539 {
2540 if (!dlen1 && !(dstr1 = get_decomposition( *str1, &dlen1 ))) dstr1 = str1;
2541 if (!dlen2 && !(dstr2 = get_decomposition( *str2, &dlen2 ))) dstr2 = str2;
2542
2543 if (flags & NORM_IGNORESYMBOLS)
2544 {
2545 int skip = 0;
2546 /* FIXME: not tested */
2547 if (get_char_type( CT_CTYPE1, dstr1[dpos1] ) & (C1_PUNCT | C1_SPACE))
2548 {
2549 inc_str_pos( &str1, &len1, &dpos1, &dlen1 );
2550 skip = 1;
2551 }
2552 if (get_char_type( CT_CTYPE1, dstr2[dpos2] ) & (C1_PUNCT | C1_SPACE))
2553 {
2554 inc_str_pos( &str2, &len2, &dpos2, &dlen2 );
2555 skip = 1;
2556 }
2557 if (skip) continue;
2558 }
2559
2560 /* hyphen and apostrophe are treated differently depending on
2561 * whether SORT_STRINGSORT specified or not
2562 */
2563 if (type == UNICODE_WEIGHT && !(flags & SORT_STRINGSORT))
2564 {
2565 if (dstr1[dpos1] == '-' || dstr1[dpos1] == '\'')
2566 {
2567 if (dstr2[dpos2] != '-' && dstr2[dpos2] != '\'')
2568 {
2569 inc_str_pos( &str1, &len1, &dpos1, &dlen1 );
2570 continue;
2571 }
2572 }
2573 else if (dstr2[dpos2] == '-' || dstr2[dpos2] == '\'')
2574 {
2575 inc_str_pos( &str2, &len2, &dpos2, &dlen2 );
2576 continue;
2577 }
2578 }
2579
2580 ce1 = get_weight( dstr1[dpos1], type );
2581 if (!ce1)
2582 {
2583 inc_str_pos( &str1, &len1, &dpos1, &dlen1 );
2584 continue;
2585 }
2586 ce2 = get_weight( dstr2[dpos2], type );
2587 if (!ce2)
2588 {
2589 inc_str_pos( &str2, &len2, &dpos2, &dlen2 );
2590 continue;
2591 }
2592
2593 if (ce1 - ce2) return ce1 - ce2;
2594
2595 inc_str_pos( &str1, &len1, &dpos1, &dlen1 );
2596 inc_str_pos( &str2, &len2, &dpos2, &dlen2 );
2597 }
2598 while (len1)
2599 {
2600 if (!dlen1 && !(dstr1 = get_decomposition( *str1, &dlen1 ))) dstr1 = str1;
2601 ce1 = get_weight( dstr1[dpos1], type );
2602 if (ce1) break;
2603 inc_str_pos( &str1, &len1, &dpos1, &dlen1 );
2604 }
2605 while (len2)
2606 {
2607 if (!dlen2 && !(dstr2 = get_decomposition( *str2, &dlen2 ))) dstr2 = str2;
2608 ce2 = get_weight( dstr2[dpos2], type );
2609 if (ce2) break;
2610 inc_str_pos( &str2, &len2, &dpos2, &dlen2 );
2611 }
2612 return len1 - len2;
2613 }
2614
2615
2616 static const struct geoinfo *get_geoinfo_ptr( GEOID geoid )
2617 {
2618 int min = 0, max = ARRAY_SIZE( geoinfodata )-1;
2619
2620 while (min <= max)
2621 {
2622 int n = (min + max)/2;
2623 const struct geoinfo *ptr = &geoinfodata[n];
2624 if (geoid == ptr->id) /* we don't need empty entries */
2625 return *ptr->iso2W ? ptr : NULL;
2626 if (ptr->id > geoid) max = n-1;
2627 else min = n+1;
2628 }
2629 return NULL;
2630 }
2631
2632
2633 static int compare_tzdate( const TIME_FIELDS *tf, const SYSTEMTIME *compare )
2634 {
2635 static const int month_lengths[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
2636 int first, last, limit, dayinsecs;
2637
2638 if (tf->Month < compare->wMonth) return -1; /* We are in a month before the date limit. */
2639 if (tf->Month > compare->wMonth) return 1; /* We are in a month after the date limit. */
2640
2641 /* if year is 0 then date is in day-of-week format, otherwise
2642 * it's absolute date.
2643 */
2644 if (!compare->wYear)
2645 {
2646 /* wDay is interpreted as number of the week in the month
2647 * 5 means: the last week in the month */
2648 /* calculate the day of the first DayOfWeek in the month */
2649 first = (6 + compare->wDayOfWeek - tf->Weekday + tf->Day) % 7 + 1;
2650 /* check needed for the 5th weekday of the month */
2651 last = month_lengths[tf->Month - 1] +
2652 (tf->Month == 2 && (!(tf->Year % 4) && (tf->Year % 100 || !(tf->Year % 400))));
2653 limit = first + 7 * (compare->wDay - 1);
2654 if (limit > last) limit -= 7;
2655 }
2656 else limit = compare->wDay;
2657
2658 limit = ((limit * 24 + compare->wHour) * 60 + compare->wMinute) * 60;
2659 dayinsecs = ((tf->Day * 24 + tf->Hour) * 60 + tf->Minute) * 60 + tf->Second;
2660 return dayinsecs - limit;
2661 }
2662
2663
2664 static DWORD get_timezone_id( const TIME_ZONE_INFORMATION *info, LARGE_INTEGER time, BOOL is_local )
2665 {
2666 int year;
2667 BOOL before_standard_date, after_daylight_date;
2668 LARGE_INTEGER t2;
2669 TIME_FIELDS tf;
2670
2671 if (!info->DaylightDate.wMonth) return TIME_ZONE_ID_UNKNOWN;
2672
2673 /* if year is 0 then date is in day-of-week format, otherwise it's absolute date */
2674 if (info->StandardDate.wMonth == 0 ||
2675 (info->StandardDate.wYear == 0 &&
2676 (info->StandardDate.wDay < 1 || info->StandardDate.wDay > 5 ||
2677 info->DaylightDate.wDay < 1 || info->DaylightDate.wDay > 5)))
2678 {
2679 SetLastError( ERROR_INVALID_PARAMETER );
2680 return TIME_ZONE_ID_INVALID;
2681 }
2682
2683 if (!is_local) time.QuadPart -= info->Bias * (LONGLONG)600000000;
2684 RtlTimeToTimeFields( &time, &tf );
2685 year = tf.Year;
2686 if (!is_local)
2687 {
2688 t2.QuadPart = time.QuadPart - info->DaylightBias * (LONGLONG)600000000;
2689 RtlTimeToTimeFields( &t2, &tf );
2690 }
2691 if (tf.Year == year)
2692 before_standard_date = compare_tzdate( &tf, &info->StandardDate ) < 0;
2693 else
2694 before_standard_date = tf.Year < year;
2695
2696 if (!is_local)
2697 {
2698 t2.QuadPart = time.QuadPart - info->StandardBias * (LONGLONG)600000000;
2699 RtlTimeToTimeFields( &t2, &tf );
2700 }
2701 if (tf.Year == year)
2702 after_daylight_date = compare_tzdate( &tf, &info->DaylightDate ) >= 0;
2703 else
2704 after_daylight_date = tf.Year > year;
2705
2706 if (info->DaylightDate.wMonth < info->StandardDate.wMonth) /* Northern hemisphere */
2707 {
2708 if (before_standard_date && after_daylight_date) return TIME_ZONE_ID_DAYLIGHT;
2709 }
2710 else /* Down south */
2711 {
2712 if (before_standard_date || after_daylight_date) return TIME_ZONE_ID_DAYLIGHT;
2713 }
2714 return TIME_ZONE_ID_STANDARD;
2715 }
2716
2717
2718 /* Note: the Internal_ functions are not documented. The number of parameters
2719 * should be correct, but their exact meaning may not.
2720 */
2721
2722 /******************************************************************************
2723 * Internal_EnumCalendarInfo (kernelbase.@)
2724 */
2725 BOOL WINAPI DECLSPEC_HOTPATCH Internal_EnumCalendarInfo( CALINFO_ENUMPROCW proc, LCID lcid, CALID id,
2726 CALTYPE type, BOOL unicode, BOOL ex,
2727 BOOL exex, LPARAM lparam )
2728 {
2729 WCHAR buffer[256];
2730 CALID calendars[2] = { id };
2731 INT ret, i;
2732
2733 if (!proc)
2734 {
2735 SetLastError( ERROR_INVALID_PARAMETER );
2736 return FALSE;
2737 }
2738
2739 if (id == ENUM_ALL_CALENDARS)
2740 {
2741 if (!GetLocaleInfoW( lcid, LOCALE_ICALENDARTYPE | LOCALE_RETURN_NUMBER,
2742 (WCHAR *)&calendars[0], sizeof(calendars[0]) / sizeof(WCHAR) )) return FALSE;
2743 if (!GetLocaleInfoW( lcid, LOCALE_IOPTIONALCALENDAR | LOCALE_RETURN_NUMBER,
2744 (WCHAR *)&calendars[1], sizeof(calendars[1]) / sizeof(WCHAR) )) calendars[1] = 0;
2745 }
2746
2747 for (i = 0; i < ARRAY_SIZE(calendars) && calendars[i]; i++)
2748 {
2749 id = calendars[i];
2750 if (type & CAL_RETURN_NUMBER)
2751 ret = GetCalendarInfoW( lcid, id, type, NULL, 0, (LPDWORD)buffer );
2752 else if (unicode)
2753 ret = GetCalendarInfoW( lcid, id, type, buffer, ARRAY_SIZE(buffer), NULL );
2754 else
2755 {
2756 WCHAR bufW[256];
2757 ret = GetCalendarInfoW( lcid, id, type, bufW, ARRAY_SIZE(bufW), NULL );
2758 if (ret) WideCharToMultiByte( CP_ACP, 0, bufW, -1, (char *)buffer, sizeof(buffer), NULL, NULL );
2759 }
2760
2761 if (ret)
2762 {
2763 if (exex) ret = ((CALINFO_ENUMPROCEXEX)proc)( buffer, id, NULL, lparam );
2764 else if (ex) ret = ((CALINFO_ENUMPROCEXW)proc)( buffer, id );
2765 else ret = proc( buffer );
2766 }
2767 if (!ret) break;
2768 }
2769 return TRUE;
2770 }
2771
2772
2773 /**************************************************************************
2774 * Internal_EnumDateFormats (kernelbase.@)
2775 */
2776 BOOL WINAPI DECLSPEC_HOTPATCH Internal_EnumDateFormats( DATEFMT_ENUMPROCW proc, LCID lcid, DWORD flags,
2777 BOOL unicode, BOOL ex, BOOL exex, LPARAM lparam )
2778 {
2779 WCHAR buffer[256];
2780 LCTYPE lctype;
2781 CALID cal_id;
2782 INT ret;
2783
2784 if (!proc)
2785 {
2786 SetLastError( ERROR_INVALID_PARAMETER );
2787 return FALSE;
2788 }
2789 if (!GetLocaleInfoW( lcid, LOCALE_ICALENDARTYPE|LOCALE_RETURN_NUMBER,
2790 (LPWSTR)&cal_id, sizeof(cal_id)/sizeof(WCHAR) ))
2791 return FALSE;
2792
2793 switch (flags & ~LOCALE_USE_CP_ACP)
2794 {
2795 case 0:
2796 case DATE_SHORTDATE:
2797 lctype = LOCALE_SSHORTDATE;
2798 break;
2799 case DATE_LONGDATE:
2800 lctype = LOCALE_SLONGDATE;
2801 break;
2802 case DATE_YEARMONTH:
2803 lctype = LOCALE_SYEARMONTH;
2804 break;
2805 default:
2806 FIXME( "unknown date format 0x%08lx\n", flags );
2807 SetLastError( ERROR_INVALID_PARAMETER );
2808 return FALSE;
2809 }
2810
2811 lctype |= flags & LOCALE_USE_CP_ACP;
2812 if (unicode)
2813 ret = GetLocaleInfoW( lcid, lctype, buffer, ARRAY_SIZE(buffer) );
2814 else
2815 ret = GetLocaleInfoA( lcid, lctype, (char *)buffer, sizeof(buffer) );
2816
2817 if (ret)
2818 {
2819 if (exex) ((DATEFMT_ENUMPROCEXEX)proc)( buffer, cal_id, lparam );
2820 else if (ex) ((DATEFMT_ENUMPROCEXW)proc)( buffer, cal_id );
2821 else proc( buffer );
2822 }
2823 return TRUE;
2824 }
2825
2826
2827 /******************************************************************************
2828 * Internal_EnumLanguageGroupLocales (kernelbase.@)
2829 */
2830 BOOL WINAPI DECLSPEC_HOTPATCH Internal_EnumLanguageGroupLocales( LANGGROUPLOCALE_ENUMPROCW proc, LGRPID id,
2831 DWORD flags, LONG_PTR param, BOOL unicode )
2832 {
2833 WCHAR name[10], value[10];
2834 DWORD name_len, value_len, type, index = 0, alt = 0;
2835 HKEY key, altkey;
2836 LCID lcid;
2837
2838 if (!proc || id < LGRPID_WESTERN_EUROPE || id > LGRPID_ARMENIAN)
2839 {
2840 SetLastError( ERROR_INVALID_PARAMETER );
2841 return FALSE;
2842 }
2843
2844 if (RegOpenKeyExW( nls_key, L"Locale", 0, KEY_READ, &key )) return FALSE;
2845 if (RegOpenKeyExW( key, L"Alternate Sorts", 0, KEY_READ, &altkey )) altkey = 0;
2846
2847 for (;;)
2848 {
2849 name_len = ARRAY_SIZE(name);
2850 value_len = sizeof(value);
2851 if (RegEnumValueW( alt ? altkey : key, index++, name, &name_len, NULL,
2852 &type, (BYTE *)value, &value_len ))
2853 {
2854 if (alt++) break;
2855 index = 0;
2856 continue;
2857 }
2858 if (type != REG_SZ) continue;
2859 if (id != wcstoul( value, NULL, 16 )) continue;
2860 lcid = wcstoul( name, NULL, 16 );
2861 if (!unicode)
2862 {
2863 char nameA[10];
2864 WideCharToMultiByte( CP_ACP, 0, name, -1, nameA, sizeof(nameA), NULL, NULL );
2865 if (!((LANGGROUPLOCALE_ENUMPROCA)proc)( id, lcid, nameA, param )) break;
2866 }
2867 else if (!proc( id, lcid, name, param )) break;
2868 }
2869 RegCloseKey( altkey );
2870 RegCloseKey( key );
2871 return TRUE;
2872 }
2873
2874
2875 /***********************************************************************
2876 * Internal_EnumSystemCodePages (kernelbase.@)
2877 */
2878 BOOL WINAPI DECLSPEC_HOTPATCH Internal_EnumSystemCodePages( CODEPAGE_ENUMPROCW proc, DWORD flags,
2879 BOOL unicode )
2880 {
2881 WCHAR name[10];
2882 DWORD name_len, type, index = 0;
2883 HKEY key;
2884
2885 if (RegOpenKeyExW( nls_key, L"Codepage", 0, KEY_READ, &key )) return FALSE;
2886
2887 for (;;)
2888 {
2889 name_len = ARRAY_SIZE(name);
2890 if (RegEnumValueW( key, index++, name, &name_len, NULL, &type, NULL, NULL )) break;
2891 if (type != REG_SZ) continue;
2892 if (!wcstoul( name, NULL, 10 )) continue;
2893 if (!unicode)
2894 {
2895 char nameA[10];
2896 WideCharToMultiByte( CP_ACP, 0, name, -1, nameA, sizeof(nameA), NULL, NULL );
2897 if (!((CODEPAGE_ENUMPROCA)proc)( nameA )) break;
2898 }
2899 else if (!proc( name )) break;
2900 }
2901 RegCloseKey( key );
2902 return TRUE;
2903 }
2904
2905
2906 /******************************************************************************
2907 * Internal_EnumSystemLanguageGroups (kernelbase.@)
2908 */
2909 BOOL WINAPI DECLSPEC_HOTPATCH Internal_EnumSystemLanguageGroups( LANGUAGEGROUP_ENUMPROCW proc,
2910 DWORD flags, LONG_PTR param, BOOL unicode )
2911 {
2912 WCHAR name[10], value[10], descr[80];
2913 DWORD name_len, value_len, type, index = 0;
2914 HKEY key;
2915 LGRPID id;
2916
2917 if (!proc)
2918 {
2919 SetLastError( ERROR_INVALID_PARAMETER );
2920 return FALSE;
2921 }
2922
2923 switch (flags)
2924 {
2925 case 0:
2926 flags = LGRPID_INSTALLED;
2927 break;
2928 case LGRPID_INSTALLED:
2929 case LGRPID_SUPPORTED:
2930 break;
2931 default:
2932 SetLastError( ERROR_INVALID_FLAGS );
2933 return FALSE;
2934 }
2935
2936 if (RegOpenKeyExW( nls_key, L"Language Groups", 0, KEY_READ, &key )) return FALSE;
2937
2938 for (;;)
2939 {
2940 name_len = ARRAY_SIZE(name);
2941 value_len = sizeof(value);
2942 if (RegEnumValueW( key, index++, name, &name_len, NULL, &type, (BYTE *)value, &value_len )) break;
2943 if (type != REG_SZ) continue;
2944
2945 id = wcstoul( name, NULL, 16 );
2946
2947 if (!(flags & LGRPID_SUPPORTED) && !wcstoul( value, NULL, 10 )) continue;
2948 if (!LoadStringW( kernel32_handle, 0x2000 + id, descr, ARRAY_SIZE(descr) )) descr[0] = 0;
2949 TRACE( "%p: %lu %s %s %lx %Ix\n", proc, id, debugstr_w(name), debugstr_w(descr), flags, param );
2950 if (!unicode)
2951 {
2952 char nameA[10], descrA[80];
2953 WideCharToMultiByte( CP_ACP, 0, name, -1, nameA, sizeof(nameA), NULL, NULL );
2954 WideCharToMultiByte( CP_ACP, 0, descr, -1, descrA, sizeof(descrA), NULL, NULL );
2955 if (!((LANGUAGEGROUP_ENUMPROCA)proc)( id, nameA, descrA, flags, param )) break;
2956 }
2957 else if (!proc( id, name, descr, flags, param )) break;
2958 }
2959 RegCloseKey( key );
2960 return TRUE;
2961 }
2962
2963
2964 /**************************************************************************
2965 * Internal_EnumTimeFormats (kernelbase.@)
2966 */
2967 BOOL WINAPI DECLSPEC_HOTPATCH Internal_EnumTimeFormats( TIMEFMT_ENUMPROCW proc, LCID lcid, DWORD flags,
2968 BOOL unicode, BOOL ex, LPARAM lparam )
2969 {
2970 WCHAR buffer[256];
2971 LCTYPE lctype;
2972 INT ret;
2973
2974 if (!proc)
2975 {
2976 SetLastError( ERROR_INVALID_PARAMETER );
2977 return FALSE;
2978 }
2979 switch (flags & ~LOCALE_USE_CP_ACP)
2980 {
2981 case 0:
2982 lctype = LOCALE_STIMEFORMAT;
2983 break;
2984 case TIME_NOSECONDS:
2985 lctype = LOCALE_SSHORTTIME;
2986 break;
2987 default:
2988 FIXME( "Unknown time format %lx\n", flags );
2989 SetLastError( ERROR_INVALID_PARAMETER );
2990 return FALSE;
2991 }
2992
2993 lctype |= flags & LOCALE_USE_CP_ACP;
2994 if (unicode)
2995 ret = GetLocaleInfoW( lcid, lctype, buffer, ARRAY_SIZE(buffer) );
2996 else
2997 ret = GetLocaleInfoA( lcid, lctype, (char *)buffer, sizeof(buffer) );
2998
2999 if (ret)
3000 {
3001 if (ex) ((TIMEFMT_ENUMPROCEX)proc)( buffer, lparam );
3002 else proc( buffer );
3003 }
3004 return TRUE;
3005 }
3006
3007
3008 /******************************************************************************
3009 * Internal_EnumUILanguages (kernelbase.@)
3010 */
3011 BOOL WINAPI DECLSPEC_HOTPATCH Internal_EnumUILanguages( UILANGUAGE_ENUMPROCW proc, DWORD flags,
3012 LONG_PTR param, BOOL unicode )
3013 {
3014 WCHAR name[10];
3015 DWORD name_len, type, index = 0;
3016 HKEY key;
3017
3018 if (!proc)
3019 {
3020 SetLastError( ERROR_INVALID_PARAMETER );
3021 return FALSE;
3022 }
3023 if (flags & ~MUI_LANGUAGE_ID)
3024 {
3025 SetLastError( ERROR_INVALID_FLAGS );
3026 return FALSE;
3027 }
3028
3029 if (RegOpenKeyExW( nls_key, L"Locale", 0, KEY_READ, &key )) return FALSE;
3030
3031 for (;;)
3032 {
3033 name_len = ARRAY_SIZE(name);
3034 if (RegEnumValueW( key, index++, name, &name_len, NULL, &type, NULL, NULL )) break;
3035 if (type != REG_SZ) continue;
3036 if (!wcstoul( name, NULL, 16 )) continue;
3037 if (!unicode)
3038 {
3039 char nameA[10];
3040 WideCharToMultiByte( CP_ACP, 0, name, -1, nameA, sizeof(nameA), NULL, NULL );
3041 if (!((UILANGUAGE_ENUMPROCA)proc)( nameA, param )) break;
3042 }
3043 else if (!proc( name, param )) break;
3044 }
3045 RegCloseKey( key );
3046 return TRUE;
3047 }
3048
3049
3050 /******************************************************************************
3051 * CompareStringEx (kernelbase.@)
3052 */
3053 INT WINAPI CompareStringEx( const WCHAR *locale, DWORD flags, const WCHAR *str1, int len1,
3054 const WCHAR *str2, int len2, NLSVERSIONINFO *version,
3055 void *reserved, LPARAM handle )
3056 {
3057 DWORD supported_flags = NORM_IGNORECASE | NORM_IGNORENONSPACE | NORM_IGNORESYMBOLS | SORT_STRINGSORT |
3058 NORM_IGNOREKANATYPE | NORM_IGNOREWIDTH | LOCALE_USE_CP_ACP;
3059 DWORD semistub_flags = NORM_LINGUISTIC_CASING | LINGUISTIC_IGNORECASE | LINGUISTIC_IGNOREDIACRITIC |
3060 SORT_DIGITSASNUMBERS | 0x10000000;
3061 /* 0x10000000 is related to diacritics in Arabic, Japanese, and Hebrew */
3062 INT ret;
3063 static int once;
3064
3065 if (version) FIXME( "unexpected version parameter\n" );
3066 if (reserved) FIXME( "unexpected reserved value\n" );
3067 if (handle) FIXME( "unexpected handle\n" );
3068
3069 if (!str1 || !str2)
3070 {
3071 SetLastError( ERROR_INVALID_PARAMETER );
3072 return 0;
3073 }
3074
3075 if (flags & ~(supported_flags | semistub_flags))
3076 {
3077 SetLastError( ERROR_INVALID_FLAGS );
3078 return 0;
3079 }
3080
3081 if (flags & semistub_flags)
3082 {
3083 if (!once++) FIXME( "semi-stub behavior for flag(s) 0x%lx\n", flags & semistub_flags );
3084 }
3085
3086 if (len1 < 0) len1 = lstrlenW(str1);
3087 if (len2 < 0) len2 = lstrlenW(str2);
3088
3089 ret = compare_weights( flags, str1, len1, str2, len2, UNICODE_WEIGHT );
3090 if (!ret)
3091 {
3092 if (!(flags & NORM_IGNORENONSPACE))
3093 ret = compare_weights( flags, str1, len1, str2, len2, DIACRITIC_WEIGHT );
3094 if (!ret && !(flags & NORM_IGNORECASE))
3095 ret = compare_weights( flags, str1, len1, str2, len2, CASE_WEIGHT );
3096 }
3097 if (!ret) return CSTR_EQUAL;
3098 return (ret < 0) ? CSTR_LESS_THAN : CSTR_GREATER_THAN;
3099 }
3100
3101
3102 /******************************************************************************
3103 * CompareStringA (kernelbase.@)
3104 */
3105 INT WINAPI DECLSPEC_HOTPATCH CompareStringA( LCID lcid, DWORD flags, const char *str1, int len1,
3106 const char *str2, int len2 )
3107 {
3108 WCHAR *buf1W = NtCurrentTeb()->StaticUnicodeBuffer;
3109 WCHAR *buf2W = buf1W + 130;
3110 LPWSTR str1W, str2W;
3111 INT len1W = 0, len2W = 0, ret;
3112 UINT locale_cp = CP_ACP;
3113
3114 if (!str1 || !str2)
3115 {
3116 SetLastError( ERROR_INVALID_PARAMETER );
3117 return 0;
3118 }
3119
3120 if (flags & SORT_DIGITSASNUMBERS)
3121 {
3122 SetLastError( ERROR_INVALID_FLAGS );
3123 return 0;
3124 }
3125
3126 if (len1 < 0) len1 = strlen(str1);
3127 if (len2 < 0) len2 = strlen(str2);
3128
3129 locale_cp = get_lcid_codepage( lcid, flags );
3130 if (len1)
3131 {
3132 if (len1 <= 130) len1W = MultiByteToWideChar( locale_cp, 0, str1, len1, buf1W, 130 );
3133 if (len1W) str1W = buf1W;
3134 else
3135 {
3136 len1W = MultiByteToWideChar( locale_cp, 0, str1, len1, NULL, 0 );
3137 str1W = HeapAlloc( GetProcessHeap(), 0, len1W * sizeof(WCHAR) );
3138 if (!str1W)
3139 {
3140 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
3141 return 0;
3142 }
3143 MultiByteToWideChar( locale_cp, 0, str1, len1, str1W, len1W );
3144 }
3145 }
3146 else
3147 {
3148 len1W = 0;
3149 str1W = buf1W;
3150 }
3151
3152 if (len2)
3153 {
3154 if (len2 <= 130) len2W = MultiByteToWideChar( locale_cp, 0, str2, len2, buf2W, 130 );
3155 if (len2W) str2W = buf2W;
3156 else
3157 {
3158 len2W = MultiByteToWideChar( locale_cp, 0, str2, len2, NULL, 0 );
3159 str2W = HeapAlloc( GetProcessHeap(), 0, len2W * sizeof(WCHAR) );
3160 if (!str2W)
3161 {
3162 if (str1W != buf1W) HeapFree( GetProcessHeap(), 0, str1W );
3163 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
3164 return 0;
3165 }
3166 MultiByteToWideChar( locale_cp, 0, str2, len2, str2W, len2W );
3167 }
3168 }
3169 else
3170 {
3171 len2W = 0;
3172 str2W = buf2W;
3173 }
3174
3175 ret = CompareStringW( lcid, flags, str1W, len1W, str2W, len2W );
3176
3177 if (str1W != buf1W) HeapFree( GetProcessHeap(), 0, str1W );
3178 if (str2W != buf2W) HeapFree( GetProcessHeap(), 0, str2W );
3179 return ret;
3180 }
3181
3182
3183 /******************************************************************************
3184 * CompareStringW (kernelbase.@)
3185 */
3186 INT WINAPI DECLSPEC_HOTPATCH CompareStringW( LCID lcid, DWORD flags, const WCHAR *str1, int len1,
3187 const WCHAR *str2, int len2 )
3188 {
3189 return CompareStringEx( NULL, flags, str1, len1, str2, len2, NULL, NULL, 0 );
3190 }
3191
3192
3193 /******************************************************************************
3194 * CompareStringOrdinal (kernelbase.@)
3195 */
3196 INT WINAPI DECLSPEC_HOTPATCH CompareStringOrdinal( const WCHAR *str1, INT len1,
3197 const WCHAR *str2, INT len2, BOOL ignore_case )
3198 {
3199 int ret;
3200
3201 if (!str1 || !str2)
3202 {
3203 SetLastError( ERROR_INVALID_PARAMETER );
3204 return 0;
3205 }
3206 if (len1 < 0) len1 = lstrlenW( str1 );
3207 if (len2 < 0) len2 = lstrlenW( str2 );
3208
3209 ret = RtlCompareUnicodeStrings( str1, len1, str2, len2, ignore_case );
3210 if (ret < 0) return CSTR_LESS_THAN;
3211 if (ret > 0) return CSTR_GREATER_THAN;
3212 return CSTR_EQUAL;
3213 }
3214
3215
3216 /******************************************************************************
3217 * ConvertDefaultLocale (kernelbase.@)
3218 */
3219 LCID WINAPI DECLSPEC_HOTPATCH ConvertDefaultLocale( LCID lcid )
3220 {
3221 switch (lcid)
3222 {
3223 case LOCALE_INVARIANT:
3224 return lcid; /* keep as-is */
3225 case LOCALE_SYSTEM_DEFAULT:
3226 return GetSystemDefaultLCID();
3227 case LOCALE_USER_DEFAULT:
3228 case LOCALE_NEUTRAL:
3229 return GetUserDefaultLCID();
3230 case MAKELANGID( LANG_CHINESE, SUBLANG_NEUTRAL ):
3231 case MAKELANGID( LANG_CHINESE, 0x1e ):
3232 return MAKELANGID( LANG_CHINESE, SUBLANG_CHINESE_SIMPLIFIED );
3233 case MAKELANGID( LANG_CHINESE, 0x1f ):
3234 return MAKELANGID( LANG_CHINESE, SUBLANG_CHINESE_HONGKONG );
3235 case LANG_SERBIAN_NEUTRAL:
3236 return MAKELANGID( LANG_SERBIAN, SUBLANG_SERBIAN_SERBIA_LATIN );
3237 case MAKELANGID( LANG_SPANISH, SUBLANG_NEUTRAL ):
3238 return MAKELANGID( LANG_SPANISH, SUBLANG_SPANISH_MODERN );
3239 case MAKELANGID( LANG_IRISH, SUBLANG_NEUTRAL ):
3240 return MAKELANGID( LANG_IRISH, SUBLANG_IRISH_IRELAND );
3241 case MAKELANGID( LANG_BENGALI, SUBLANG_NEUTRAL ):
3242 return MAKELANGID( LANG_BENGALI, SUBLANG_BENGALI_BANGLADESH );
3243 case MAKELANGID( LANG_SINDHI, SUBLANG_NEUTRAL ):
3244 return MAKELANGID( LANG_SINDHI, SUBLANG_SINDHI_AFGHANISTAN );
3245 case MAKELANGID( LANG_INUKTITUT, SUBLANG_NEUTRAL ):
3246 return MAKELANGID( LANG_INUKTITUT, SUBLANG_INUKTITUT_CANADA_LATIN );
3247 case MAKELANGID( LANG_TAMAZIGHT, SUBLANG_NEUTRAL ):
3248 return MAKELANGID( LANG_TAMAZIGHT, SUBLANG_TAMAZIGHT_ALGERIA_LATIN );
3249 case MAKELANGID( LANG_FULAH, SUBLANG_NEUTRAL ):
3250 return MAKELANGID( LANG_FULAH, SUBLANG_FULAH_SENEGAL );
3251 case MAKELANGID( LANG_TIGRINYA, SUBLANG_NEUTRAL ):
3252 return MAKELANGID( LANG_TIGRINYA, SUBLANG_TIGRINYA_ERITREA );
3253 default:
3254 /* Replace SUBLANG_NEUTRAL with SUBLANG_DEFAULT */
3255 if (SUBLANGID(lcid) == SUBLANG_NEUTRAL && SORTIDFROMLCID(lcid) == SORT_DEFAULT)
3256 lcid = MAKELANGID( PRIMARYLANGID(lcid), SUBLANG_DEFAULT );
3257 break;
3258 }
3259 return lcid;
3260 }
3261
3262
3263 /******************************************************************************
3264 * EnumCalendarInfoW (kernelbase.@)
3265 */
3266 BOOL WINAPI DECLSPEC_HOTPATCH EnumCalendarInfoW( CALINFO_ENUMPROCW proc, LCID lcid,
3267 CALID id, CALTYPE type )
3268 {
3269 return Internal_EnumCalendarInfo( proc, lcid, id, type, TRUE, FALSE, FALSE, 0 );
3270 }
3271
3272
3273 /******************************************************************************
3274 * EnumCalendarInfoExW (kernelbase.@)
3275 */
3276 BOOL WINAPI DECLSPEC_HOTPATCH EnumCalendarInfoExW( CALINFO_ENUMPROCEXW proc, LCID lcid,
3277 CALID id, CALTYPE type )
3278 {
3279 return Internal_EnumCalendarInfo( (CALINFO_ENUMPROCW)proc, lcid, id, type, TRUE, TRUE, FALSE, 0 );
3280 }
3281
3282 /******************************************************************************
3283 * EnumCalendarInfoExEx (kernelbase.@)
3284 */
3285 BOOL WINAPI DECLSPEC_HOTPATCH EnumCalendarInfoExEx( CALINFO_ENUMPROCEXEX proc, LPCWSTR locale, CALID id,
3286 LPCWSTR reserved, CALTYPE type, LPARAM lparam )
3287 {
3288 LCID lcid = LocaleNameToLCID( locale, 0 );
3289 return Internal_EnumCalendarInfo( (CALINFO_ENUMPROCW)proc, lcid, id, type, TRUE, TRUE, TRUE, lparam );
3290 }
3291
3292
3293 /**************************************************************************
3294 * EnumDateFormatsW (kernelbase.@)
3295 */
3296 BOOL WINAPI DECLSPEC_HOTPATCH EnumDateFormatsW( DATEFMT_ENUMPROCW proc, LCID lcid, DWORD flags )
3297 {
3298 return Internal_EnumDateFormats( proc, lcid, flags, TRUE, FALSE, FALSE, 0 );
3299 }
3300
3301
3302 /**************************************************************************
3303 * EnumDateFormatsExW (kernelbase.@)
3304 */
3305 BOOL WINAPI DECLSPEC_HOTPATCH EnumDateFormatsExW( DATEFMT_ENUMPROCEXW proc, LCID lcid, DWORD flags )
3306 {
3307 return Internal_EnumDateFormats( (DATEFMT_ENUMPROCW)proc, lcid, flags, TRUE, TRUE, FALSE, 0 );
3308 }
3309
3310
3311 /**************************************************************************
3312 * EnumDateFormatsExEx (kernelbase.@)
3313 */
3314 BOOL WINAPI DECLSPEC_HOTPATCH EnumDateFormatsExEx( DATEFMT_ENUMPROCEXEX proc, const WCHAR *locale,
3315 DWORD flags, LPARAM lparam )
3316 {
3317 LCID lcid = LocaleNameToLCID( locale, 0 );
3318 return Internal_EnumDateFormats( (DATEFMT_ENUMPROCW)proc, lcid, flags, TRUE, TRUE, TRUE, lparam );
3319 }
3320
3321
3322
3323 /******************************************************************************
3324 * EnumDynamicTimeZoneInformation (kernelbase.@)
3325 */
3326 DWORD WINAPI DECLSPEC_HOTPATCH EnumDynamicTimeZoneInformation( DWORD index,
3327 DYNAMIC_TIME_ZONE_INFORMATION *info )
3328 {
3329 DYNAMIC_TIME_ZONE_INFORMATION tz;
3330 LSTATUS ret;
3331 DWORD size;
3332
3333 if (!info) return ERROR_INVALID_PARAMETER;
3334
3335 size = ARRAY_SIZE(tz.TimeZoneKeyName);
3336 ret = RegEnumKeyExW( tz_key, index, tz.TimeZoneKeyName, &size, NULL, NULL, NULL, NULL );
3337 if (ret) return ret;
3338
3339 tz.DynamicDaylightTimeDisabled = TRUE;
3340 if (!GetTimeZoneInformationForYear( 0, &tz, (TIME_ZONE_INFORMATION *)info )) return GetLastError();
3341
3342 lstrcpyW( info->TimeZoneKeyName, tz.TimeZoneKeyName );
3343 info->DynamicDaylightTimeDisabled = FALSE;
3344 return 0;
3345 }
3346
3347
3348 /******************************************************************************
3349 * EnumLanguageGroupLocalesW (kernelbase.@)
3350 */
3351 BOOL WINAPI DECLSPEC_HOTPATCH EnumLanguageGroupLocalesW( LANGGROUPLOCALE_ENUMPROCW proc, LGRPID id,
3352 DWORD flags, LONG_PTR param )
3353 {
3354 return Internal_EnumLanguageGroupLocales( proc, id, flags, param, TRUE );
3355 }
3356
3357
3358 /******************************************************************************
3359 * EnumUILanguagesW (kernelbase.@)
3360 */
3361 BOOL WINAPI DECLSPEC_HOTPATCH EnumUILanguagesW( UILANGUAGE_ENUMPROCW proc, DWORD flags, LONG_PTR param )
3362 {
3363 return Internal_EnumUILanguages( proc, flags, param, TRUE );
3364 }
3365
3366
3367 /***********************************************************************
3368 * EnumSystemCodePagesW (kernelbase.@)
3369 */
3370 BOOL WINAPI DECLSPEC_HOTPATCH EnumSystemCodePagesW( CODEPAGE_ENUMPROCW proc, DWORD flags )
3371 {
3372 return Internal_EnumSystemCodePages( proc, flags, TRUE );
3373 }
3374
3375
3376 /******************************************************************************
3377 * EnumSystemGeoID (kernelbase.@)
3378 */
3379 BOOL WINAPI DECLSPEC_HOTPATCH EnumSystemGeoID( GEOCLASS class, GEOID parent, GEO_ENUMPROC proc )
3380 {
3381 INT i;
3382
3383 TRACE( "(%ld, %ld, %p)\n", class, parent, proc );
3384
3385 if (!proc)
3386 {
3387 SetLastError( ERROR_INVALID_PARAMETER );
3388 return FALSE;
3389 }
3390 if (class != GEOCLASS_NATION && class != GEOCLASS_REGION && class != GEOCLASS_ALL)
3391 {
3392 SetLastError( ERROR_INVALID_FLAGS );
3393 return FALSE;
3394 }
3395
3396 for (i = 0; i < ARRAY_SIZE(geoinfodata); i++)
3397 {
3398 const struct geoinfo *ptr = &geoinfodata[i];
3399
3400 if (class == GEOCLASS_NATION && (ptr->kind != LOCATION_NATION)) continue;
3401 /* LOCATION_BOTH counts as region */
3402 if (class == GEOCLASS_REGION && (ptr->kind == LOCATION_NATION)) continue;
3403 if (parent && ptr->parent != parent) continue;
3404 if (!proc( ptr->id )) break;
3405 }
3406 return TRUE;
3407 }
3408
3409
3410 /******************************************************************************
3411 * EnumSystemLanguageGroupsW (kernelbase.@)
3412 */
3413 BOOL WINAPI DECLSPEC_HOTPATCH EnumSystemLanguageGroupsW( LANGUAGEGROUP_ENUMPROCW proc,
3414 DWORD flags, LONG_PTR param )
3415 {
3416 return Internal_EnumSystemLanguageGroups( proc, flags, param, TRUE );
3417 }
3418
3419
3420 /******************************************************************************
3421 * EnumSystemLocalesA (kernelbase.@)
3422 */
3423 BOOL WINAPI DECLSPEC_HOTPATCH EnumSystemLocalesA( LOCALE_ENUMPROCA proc, DWORD flags )
3424 {
3425 char name[10];
3426 DWORD name_len, type, index = 0;
3427 HKEY key;
3428
3429 if (RegOpenKeyExW( nls_key, L"Locale", 0, KEY_READ, &key )) return FALSE;
3430
3431 for (;;)
3432 {
3433 name_len = ARRAY_SIZE(name);
3434 if (RegEnumValueA( key, index++, name, &name_len, NULL, &type, NULL, NULL )) break;
3435 if (type != REG_SZ) continue;
3436 if (!strtoul( name, NULL, 16 )) continue;
3437 if (!proc( name )) break;
3438 }
3439 RegCloseKey( key );
3440 return TRUE;
3441 }
3442
3443
3444 /******************************************************************************
3445 * EnumSystemLocalesW (kernelbase.@)
3446 */
3447 BOOL WINAPI DECLSPEC_HOTPATCH EnumSystemLocalesW( LOCALE_ENUMPROCW proc, DWORD flags )
3448 {
3449 WCHAR name[10];
3450 DWORD name_len, type, index = 0;
3451 HKEY key;
3452
3453 if (RegOpenKeyExW( nls_key, L"Locale", 0, KEY_READ, &key )) return FALSE;
3454
3455 for (;;)
3456 {
3457 name_len = ARRAY_SIZE(name);
3458 if (RegEnumValueW( key, index++, name, &name_len, NULL, &type, NULL, NULL )) break;
3459 if (type != REG_SZ) continue;
3460 if (!wcstoul( name, NULL, 16 )) continue;
3461 if (!proc( name )) break;
3462 }
3463 RegCloseKey( key );
3464 return TRUE;
3465 }
3466
3467
3468 /******************************************************************************
3469 * EnumSystemLocalesEx (kernelbase.@)
3470 */
3471 BOOL WINAPI DECLSPEC_HOTPATCH EnumSystemLocalesEx( LOCALE_ENUMPROCEX proc, DWORD wanted_flags,
3472 LPARAM param, void *reserved )
3473 {
3474 WCHAR buffer[256], name[10];
3475 DWORD name_len, type, neutral, flags, index = 0, alt = 0;
3476 HKEY key, altkey;
3477 LCID lcid;
3478
3479 if (reserved)
3480 {
3481 SetLastError( ERROR_INVALID_PARAMETER );
3482 return FALSE;
3483 }
3484
3485 if (RegOpenKeyExW( nls_key, L"Locale", 0, KEY_READ, &key )) return FALSE;
3486 if (RegOpenKeyExW( key, L"Alternate Sorts", 0, KEY_READ, &altkey )) altkey = 0;
3487
3488 for (;;)
3489 {
3490 name_len = ARRAY_SIZE(name);
3491 if (RegEnumValueW( alt ? altkey : key, index++, name, &name_len, NULL, &type, NULL, NULL ))
3492 {
3493 if (alt++) break;
3494 index = 0;
3495 continue;
3496 }
3497 if (type != REG_SZ) continue;
3498 if (!(lcid = wcstoul( name, NULL, 16 ))) continue;
3499
3500 GetLocaleInfoW( lcid, LOCALE_SNAME | LOCALE_NOUSEROVERRIDE, buffer, ARRAY_SIZE( buffer ));
3501 if (!GetLocaleInfoW( lcid, LOCALE_INEUTRAL | LOCALE_NOUSEROVERRIDE | LOCALE_RETURN_NUMBER,
3502 (LPWSTR)&neutral, sizeof(neutral) / sizeof(WCHAR) ))
3503 neutral = 0;
3504
3505 if (alt)
3506 flags = LOCALE_ALTERNATE_SORTS;
3507 else
3508 flags = LOCALE_WINDOWS | (neutral ? LOCALE_NEUTRALDATA : LOCALE_SPECIFICDATA);
3509
3510 if (wanted_flags && !(flags & wanted_flags)) continue;
3511 if (!proc( buffer, flags, param )) break;
3512 }
3513 RegCloseKey( altkey );
3514 RegCloseKey( key );
3515 return TRUE;
3516 }
3517
3518
3519 /**************************************************************************
3520 * EnumTimeFormatsW (kernelbase.@)
3521 */
3522 BOOL WINAPI DECLSPEC_HOTPATCH EnumTimeFormatsW( TIMEFMT_ENUMPROCW proc, LCID lcid, DWORD flags )
3523 {
3524 return Internal_EnumTimeFormats( proc, lcid, flags, TRUE, FALSE, 0 );
3525 }
3526
3527
3528 /**************************************************************************
3529 * EnumTimeFormatsEx (kernelbase.@)
3530 */
3531 BOOL WINAPI DECLSPEC_HOTPATCH EnumTimeFormatsEx( TIMEFMT_ENUMPROCEX proc, const WCHAR *locale,
3532 DWORD flags, LPARAM lparam )
3533 {
3534 LCID lcid = LocaleNameToLCID( locale, 0 );
3535 return Internal_EnumTimeFormats( (TIMEFMT_ENUMPROCW)proc, lcid, flags, TRUE, TRUE, lparam );
3536 }
3537
3538
3539 /**************************************************************************
3540 * FindNLSString (kernelbase.@)
3541 */
3542 INT WINAPI DECLSPEC_HOTPATCH FindNLSString( LCID lcid, DWORD flags, const WCHAR *src,
3543 int srclen, const WCHAR *value, int valuelen, int *found )
3544 {
3545 WCHAR locale[LOCALE_NAME_MAX_LENGTH];
3546
3547 LCIDToLocaleName( lcid, locale, ARRAY_SIZE(locale), 0 );
3548 return FindNLSStringEx( locale, flags, src, srclen, value, valuelen, found, NULL, NULL, 0 );
3549 }
3550
3551
3552 /**************************************************************************
3553 * FindNLSStringEx (kernelbase.@)
3554 */
3555 INT WINAPI DECLSPEC_HOTPATCH FindNLSStringEx( const WCHAR *locale, DWORD flags, const WCHAR *src,
3556 int srclen, const WCHAR *value, int valuelen, int *found,
3557 NLSVERSIONINFO *version, void *reserved, LPARAM handle )
3558 {
3559 /* FIXME: this function should normalize strings before calling CompareStringEx() */
3560 DWORD mask = flags;
3561 int offset, inc, count;
3562
3563 TRACE( "%s %lx %s %d %s %d %p %p %p %Id\n", wine_dbgstr_w(locale), flags,
3564 wine_dbgstr_w(src), srclen, wine_dbgstr_w(value), valuelen, found,
3565 version, reserved, handle );
3566
3567 if (version || reserved || handle || !IsValidLocaleName(locale) ||
3568 !src || !srclen || srclen < -1 || !value || !valuelen || valuelen < -1)
3569 {
3570 SetLastError( ERROR_INVALID_PARAMETER );
3571 return -1;
3572 }
3573 if (srclen == -1) srclen = lstrlenW(src);
3574 if (valuelen == -1) valuelen = lstrlenW(value);
3575
3576 srclen -= valuelen;
3577 if (srclen < 0) return -1;
3578
3579 mask = flags & ~(FIND_FROMSTART | FIND_FROMEND | FIND_STARTSWITH | FIND_ENDSWITH);
3580 count = flags & (FIND_FROMSTART | FIND_FROMEND) ? srclen + 1 : 1;
3581 offset = flags & (FIND_FROMSTART | FIND_STARTSWITH) ? 0 : srclen;
3582 inc = flags & (FIND_FROMSTART | FIND_STARTSWITH) ? 1 : -1;
3583 while (count--)
3584 {
3585 if (CompareStringEx( locale, mask, src + offset, valuelen,
3586 value, valuelen, NULL, NULL, 0 ) == CSTR_EQUAL)
3587 {
3588 if (found) *found = valuelen;
3589 return offset;
3590 }
3591 offset += inc;
3592 }
3593 return -1;
3594 }
3595
3596
3597 /******************************************************************************
3598 * FindStringOrdinal (kernelbase.@)
3599 */
3600 INT WINAPI DECLSPEC_HOTPATCH FindStringOrdinal( DWORD flag, const WCHAR *src, INT src_size,
3601 const WCHAR *val, INT val_size, BOOL ignore_case )
3602 {
3603 INT offset, inc, count;
3604
3605 TRACE( "%#lx %s %d %s %d %d\n", flag, wine_dbgstr_w(src), src_size,
3606 wine_dbgstr_w(val), val_size, ignore_case );
3607
3608 if (!src || !val)
3609 {
3610 SetLastError( ERROR_INVALID_PARAMETER );
3611 return -1;
3612 }
3613
3614 if (flag != FIND_FROMSTART && flag != FIND_FROMEND && flag != FIND_STARTSWITH && flag != FIND_ENDSWITH)
3615 {
3616 SetLastError( ERROR_INVALID_FLAGS );
3617 return -1;
3618 }
3619
3620 if (src_size == -1) src_size = lstrlenW( src );
3621 if (val_size == -1) val_size = lstrlenW( val );
3622
3623 SetLastError( ERROR_SUCCESS );
3624 src_size -= val_size;
3625 if (src_size < 0) return -1;
3626
3627 count = flag & (FIND_FROMSTART | FIND_FROMEND) ? src_size + 1 : 1;
3628 offset = flag & (FIND_FROMSTART | FIND_STARTSWITH) ? 0 : src_size;
3629 inc = flag & (FIND_FROMSTART | FIND_STARTSWITH) ? 1 : -1;
3630 while (count--)
3631 {
3632 if (CompareStringOrdinal( src + offset, val_size, val, val_size, ignore_case ) == CSTR_EQUAL)
3633 return offset;
3634 offset += inc;
3635 }
3636 return -1;
3637 }
3638
3639
3640 /******************************************************************************
3641 * FoldStringW (kernelbase.@)
3642 */
3643 INT WINAPI DECLSPEC_HOTPATCH FoldStringW( DWORD flags, LPCWSTR src, INT srclen, LPWSTR dst, INT dstlen )
3644 {
3645 NTSTATUS status;
3646 WCHAR *buf = dst;
3647 int len = dstlen;
3648
3649 if (!src || !srclen || dstlen < 0 || (dstlen && !dst) || src == dst)
3650 {
3651 SetLastError( ERROR_INVALID_PARAMETER );
3652 return 0;
3653 }
3654 if (srclen == -1) srclen = lstrlenW(src) + 1;
3655
3656 if (!dstlen && (flags & (MAP_PRECOMPOSED | MAP_FOLDCZONE | MAP_COMPOSITE)))
3657 {
3658 len = srclen * 4;
3659 if (!(buf = RtlAllocateHeap( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
3660 {
3661 SetLastError( ERROR_OUTOFMEMORY );
3662 return 0;
3663 }
3664 }
3665
3666 for (;;)
3667 {
3668 status = fold_string( flags, src, srclen, buf, &len );
3669 if (buf != dst) RtlFreeHeap( GetProcessHeap(), 0, buf );
3670 if (status != STATUS_BUFFER_TOO_SMALL) break;
3671 if (!(buf = RtlAllocateHeap( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
3672 {
3673 SetLastError( ERROR_OUTOFMEMORY );
3674 return 0;
3675 }
3676 }
3677 if (status == STATUS_INVALID_PARAMETER_1)
3678 {
3679 SetLastError( ERROR_INVALID_FLAGS );
3680 return 0;
3681 }
3682 if (!set_ntstatus( status )) return 0;
3683
3684 if (dstlen && dstlen < len) SetLastError( ERROR_INSUFFICIENT_BUFFER );
3685 return len;
3686 }
3687
3688
3689 static const WCHAR *get_message( DWORD flags, const void *src, UINT id, UINT lang,
3690 BOOL ansi, WCHAR **buffer )
3691 {
3692 DWORD len;
3693
3694 if (!(flags & FORMAT_MESSAGE_FROM_STRING))
3695 {
3696 const MESSAGE_RESOURCE_ENTRY *entry;
3697 NTSTATUS status = STATUS_INVALID_PARAMETER;
3698
3699 if (flags & FORMAT_MESSAGE_FROM_HMODULE)
3700 {
3701 HMODULE module = (HMODULE)src;
3702 if (!module) module = GetModuleHandleW( 0 );
3703 status = RtlFindMessage( module, RT_MESSAGETABLE, lang, id, &entry );
3704 }
3705 if (status && (flags & FORMAT_MESSAGE_FROM_SYSTEM))
3706 {
3707 /* Fold win32 hresult to its embedded error code. */
3708 if (HRESULT_SEVERITY(id) == SEVERITY_ERROR && HRESULT_FACILITY(id) == FACILITY_WIN32)
3709 id = HRESULT_CODE( id );
3710 status = RtlFindMessage( kernel32_handle, RT_MESSAGETABLE, lang, id, &entry );
3711 }
3712 if (!set_ntstatus( status )) return NULL;
3713
3714 src = entry->Text;
3715 ansi = !(entry->Flags & MESSAGE_RESOURCE_UNICODE);
3716 }
3717
3718 if (!ansi) return src;
3719 len = MultiByteToWideChar( CP_ACP, 0, src, -1, NULL, 0 );
3720 if (!(*buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return NULL;
3721 MultiByteToWideChar( CP_ACP, 0, src, -1, *buffer, len );
3722 return *buffer;
3723 }
3724
3725
3726 /***********************************************************************
3727 * FormatMessageA (kernelbase.@)
3728 */
3729 DWORD WINAPI DECLSPEC_HOTPATCH FormatMessageA( DWORD flags, const void *source, DWORD msgid, DWORD langid,
3730 char *buffer, DWORD size, va_list *args )
3731 {
3732 DWORD ret = 0;
3733 ULONG len, retsize = 0;
3734 ULONG width = (flags & FORMAT_MESSAGE_MAX_WIDTH_MASK);
3735 const WCHAR *src;
3736 WCHAR *result, *message = NULL;
3737 NTSTATUS status;
3738
3739 TRACE( "(0x%lx,%p,%#lx,0x%lx,%p,%lu,%p)\n", flags, source, msgid, langid, buffer, size, args );
3740
3741 if (flags & FORMAT_MESSAGE_ALLOCATE_BUFFER)
3742 {
3743 if (!buffer)
3744 {
3745 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
3746 return 0;
3747 }
3748 *(char **)buffer = NULL;
3749 }
3750 if (size >= 32768)
3751 {
3752 SetLastError( ERROR_INVALID_PARAMETER );
3753 return 0;
3754 }
3755
3756 if (width == 0xff) width = ~0u;
3757
3758 if (!(src = get_message( flags, source, msgid, langid, TRUE, &message ))) return 0;
3759
3760 if (!(result = HeapAlloc( GetProcessHeap(), 0, 65536 )))
3761 status = STATUS_NO_MEMORY;
3762 else
3763 status = RtlFormatMessage( src, width, !!(flags & FORMAT_MESSAGE_IGNORE_INSERTS),
3764 TRUE, !!(flags & FORMAT_MESSAGE_ARGUMENT_ARRAY), args,
3765 result, 65536, &retsize );
3766
3767 HeapFree( GetProcessHeap(), 0, message );
3768
3769 if (status == STATUS_BUFFER_OVERFLOW)
3770 {
3771 SetLastError( ERROR_INSUFFICIENT_BUFFER );
3772 goto done;
3773 }
3774 if (!set_ntstatus( status )) goto done;
3775
3776 len = WideCharToMultiByte( CP_ACP, 0, result, retsize / sizeof(WCHAR), NULL, 0, NULL, NULL );
3777 if (len <= 1)
3778 {
3779 SetLastError( ERROR_NO_WORK_DONE );
3780 goto done;
3781 }
3782
3783 if (flags & FORMAT_MESSAGE_ALLOCATE_BUFFER)
3784 {
3785 char *buf = LocalAlloc( LMEM_ZEROINIT, max( size, len ));
3786 if (!buf)
3787 {
3788 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
3789 goto done;
3790 }
3791 *(char **)buffer = buf;
3792 WideCharToMultiByte( CP_ACP, 0, result, retsize / sizeof(WCHAR), buf, max( size, len ), NULL, NULL );
3793 }
3794 else if (len > size)
3795 {
3796 SetLastError( ERROR_INSUFFICIENT_BUFFER );
3797 goto done;
3798 }
3799 else WideCharToMultiByte( CP_ACP, 0, result, retsize / sizeof(WCHAR), buffer, size, NULL, NULL );
3800
3801 ret = len - 1;
3802
3803 done:
3804 HeapFree( GetProcessHeap(), 0, result );
3805 return ret;
3806 }
3807
3808
3809 /***********************************************************************
3810 * FormatMessageW (kernelbase.@)
3811 */
3812 DWORD WINAPI DECLSPEC_HOTPATCH FormatMessageW( DWORD flags, const void *source, DWORD msgid, DWORD langid,
3813 WCHAR *buffer, DWORD size, va_list *args )
3814 {
3815 ULONG retsize = 0;
3816 ULONG width = (flags & FORMAT_MESSAGE_MAX_WIDTH_MASK);
3817 const WCHAR *src;
3818 WCHAR *message = NULL;
3819 NTSTATUS status;
3820
3821 TRACE( "(0x%lx,%p,%#lx,0x%lx,%p,%lu,%p)\n", flags, source, msgid, langid, buffer, size, args );
3822
3823 if (!buffer)
3824 {
3825 SetLastError( ERROR_INVALID_PARAMETER );
3826 return 0;
3827 }
3828
3829 if (width == 0xff) width = ~0u;
3830
3831 if (flags & FORMAT_MESSAGE_ALLOCATE_BUFFER) *(LPWSTR *)buffer = NULL;
3832
3833 if (!(src = get_message( flags, source, msgid, langid, FALSE, &message ))) return 0;
3834
3835 if (flags & FORMAT_MESSAGE_ALLOCATE_BUFFER)
3836 {
3837 WCHAR *result;
3838 ULONG alloc = max( size * sizeof(WCHAR), 65536 );
3839
3840 for (;;)
3841 {
3842 if (!(result = HeapAlloc( GetProcessHeap(), 0, alloc )))
3843 {
3844 status = STATUS_NO_MEMORY;
3845 break;
3846 }
3847 status = RtlFormatMessage( src, width, !!(flags & FORMAT_MESSAGE_IGNORE_INSERTS),
3848 FALSE, !!(flags & FORMAT_MESSAGE_ARGUMENT_ARRAY), args,
3849 result, alloc, &retsize );
3850 if (!status)
3851 {
3852 if (retsize <= sizeof(WCHAR)) HeapFree( GetProcessHeap(), 0, result );
3853 else *(WCHAR **)buffer = HeapReAlloc( GetProcessHeap(), HEAP_REALLOC_IN_PLACE_ONLY,
3854 result, max( retsize, size * sizeof(WCHAR) ));
3855 break;
3856 }
3857 HeapFree( GetProcessHeap(), 0, result );
3858 if (status != STATUS_BUFFER_OVERFLOW) break;
3859 alloc *= 2;
3860 }
3861 }
3862 else status = RtlFormatMessage( src, width, !!(flags & FORMAT_MESSAGE_IGNORE_INSERTS),
3863 FALSE, !!(flags & FORMAT_MESSAGE_ARGUMENT_ARRAY), args,
3864 buffer, size * sizeof(WCHAR), &retsize );
3865
3866 HeapFree( GetProcessHeap(), 0, message );
3867
3868 if (status == STATUS_BUFFER_OVERFLOW)
3869 {
3870 if (size) buffer[size - 1] = 0;
3871 SetLastError( ERROR_INSUFFICIENT_BUFFER );
3872 return 0;
3873 }
3874 if (!set_ntstatus( status )) return 0;
3875 if (retsize <= sizeof(WCHAR)) SetLastError( ERROR_NO_WORK_DONE );
3876 return retsize / sizeof(WCHAR) - 1;
3877 }
3878
3879
3880 /******************************************************************************
3881 * GetACP (kernelbase.@)
3882 */
3883 UINT WINAPI GetACP(void)
3884 {
3885 return nls_info.AnsiTableInfo.CodePage;
3886 }
3887
3888
3889 /***********************************************************************
3890 * GetCPInfo (kernelbase.@)
3891 */
3892 BOOL WINAPI DECLSPEC_HOTPATCH GetCPInfo( UINT codepage, CPINFO *cpinfo )
3893 {
3894 const CPTABLEINFO *table;
3895
3896 if (!cpinfo)
3897 {
3898 SetLastError( ERROR_INVALID_PARAMETER );
3899 return FALSE;
3900 }
3901 switch (codepage)
3902 {
3903 case CP_UTF7:
3904 case CP_UTF8:
3905 cpinfo->DefaultChar[0] = 0x3f;
3906 cpinfo->DefaultChar[1] = 0;
3907 memset( cpinfo->LeadByte, 0, sizeof(cpinfo->LeadByte) );
3908 cpinfo->MaxCharSize = (codepage == CP_UTF7) ? 5 : 4;
3909 break;
3910 default:
3911 if (!(table = get_codepage_table( codepage ))) return FALSE;
3912 cpinfo->MaxCharSize = table->MaximumCharacterSize;
3913 memcpy( cpinfo->DefaultChar, &table->DefaultChar, sizeof(cpinfo->DefaultChar) );
3914 memcpy( cpinfo->LeadByte, table->LeadByte, sizeof(cpinfo->LeadByte) );
3915 break;
3916 }
3917 return TRUE;
3918 }
3919
3920
3921 /***********************************************************************
3922 * GetCPInfoExW (kernelbase.@)
3923 */
3924 BOOL WINAPI GetCPInfoExW( UINT codepage, DWORD flags, CPINFOEXW *cpinfo )
3925 {
3926 const CPTABLEINFO *table;
3927 int min, max, pos;
3928
3929 if (!cpinfo)
3930 {
3931 SetLastError( ERROR_INVALID_PARAMETER );
3932 return FALSE;
3933 }
3934 switch (codepage)
3935 {
3936 case CP_UTF7:
3937 cpinfo->DefaultChar[0] = 0x3f;
3938 cpinfo->DefaultChar[1] = 0;
3939 cpinfo->LeadByte[0] = cpinfo->LeadByte[1] = 0;
3940 cpinfo->MaxCharSize = 5;
3941 cpinfo->CodePage = CP_UTF7;
3942 cpinfo->UnicodeDefaultChar = 0x3f;
3943 break;
3944 case CP_UTF8:
3945 cpinfo->DefaultChar[0] = 0x3f;
3946 cpinfo->DefaultChar[1] = 0;
3947 cpinfo->LeadByte[0] = cpinfo->LeadByte[1] = 0;
3948 cpinfo->MaxCharSize = 4;
3949 cpinfo->CodePage = CP_UTF8;
3950 cpinfo->UnicodeDefaultChar = 0x3f;
3951 break;
3952 default:
3953 if (!(table = get_codepage_table( codepage ))) return FALSE;
3954 cpinfo->MaxCharSize = table->MaximumCharacterSize;
3955 memcpy( cpinfo->DefaultChar, &table->DefaultChar, sizeof(cpinfo->DefaultChar) );
3956 memcpy( cpinfo->LeadByte, table->LeadByte, sizeof(cpinfo->LeadByte) );
3957 cpinfo->CodePage = table->CodePage;
3958 cpinfo->UnicodeDefaultChar = table->UniDefaultChar;
3959 break;
3960 }
3961
3962 min = 0;
3963 max = ARRAY_SIZE(codepage_names) - 1;
3964 cpinfo->CodePageName[0] = 0;
3965 while (min <= max)
3966 {
3967 pos = (min + max) / 2;
3968 if (codepage_names[pos].cp < cpinfo->CodePage) min = pos + 1;
3969 else if (codepage_names[pos].cp > cpinfo->CodePage) max = pos - 1;
3970 else
3971 {
3972 wcscpy( cpinfo->CodePageName, codepage_names[pos].name );
3973 break;
3974 }
3975 }
3976 return TRUE;
3977 }
3978
3979
3980 /***********************************************************************
3981 * GetCalendarInfoW (kernelbase.@)
3982 */
3983 INT WINAPI DECLSPEC_HOTPATCH GetCalendarInfoW( LCID lcid, CALID calendar, CALTYPE type,
3984 WCHAR *data, INT count, DWORD *value )
3985 {
3986 static const LCTYPE lctype_map[] =
3987 {
3988 0, /* not used */
3989 0, /* CAL_ICALINTVALUE */
3990 0, /* CAL_SCALNAME */
3991 0, /* CAL_IYEAROFFSETRANGE */
3992 0, /* CAL_SERASTRING */
3993 LOCALE_SSHORTDATE,
3994 LOCALE_SLONGDATE,
3995 LOCALE_SDAYNAME1,
3996 LOCALE_SDAYNAME2,
3997 LOCALE_SDAYNAME3,
3998 LOCALE_SDAYNAME4,
3999 LOCALE_SDAYNAME5,
4000 LOCALE_SDAYNAME6,
4001 LOCALE_SDAYNAME7,
4002 LOCALE_SABBREVDAYNAME1,
4003 LOCALE_SABBREVDAYNAME2,
4004 LOCALE_SABBREVDAYNAME3,
4005 LOCALE_SABBREVDAYNAME4,
4006 LOCALE_SABBREVDAYNAME5,
4007 LOCALE_SABBREVDAYNAME6,
4008 LOCALE_SABBREVDAYNAME7,
4009 LOCALE_SMONTHNAME1,
4010 LOCALE_SMONTHNAME2,
4011 LOCALE_SMONTHNAME3,
4012 LOCALE_SMONTHNAME4,
4013 LOCALE_SMONTHNAME5,
4014 LOCALE_SMONTHNAME6,
4015 LOCALE_SMONTHNAME7,
4016 LOCALE_SMONTHNAME8,
4017 LOCALE_SMONTHNAME9,
4018 LOCALE_SMONTHNAME10,
4019 LOCALE_SMONTHNAME11,
4020 LOCALE_SMONTHNAME12,
4021 LOCALE_SMONTHNAME13,
4022 LOCALE_SABBREVMONTHNAME1,
4023 LOCALE_SABBREVMONTHNAME2,
4024 LOCALE_SABBREVMONTHNAME3,
4025 LOCALE_SABBREVMONTHNAME4,
4026 LOCALE_SABBREVMONTHNAME5,
4027 LOCALE_SABBREVMONTHNAME6,
4028 LOCALE_SABBREVMONTHNAME7,
4029 LOCALE_SABBREVMONTHNAME8,
4030 LOCALE_SABBREVMONTHNAME9,
4031 LOCALE_SABBREVMONTHNAME10,
4032 LOCALE_SABBREVMONTHNAME11,
4033 LOCALE_SABBREVMONTHNAME12,
4034 LOCALE_SABBREVMONTHNAME13,
4035 LOCALE_SYEARMONTH,
4036 0, /* CAL_ITWODIGITYEARMAX */
4037 LOCALE_SSHORTESTDAYNAME1,
4038 LOCALE_SSHORTESTDAYNAME2,
4039 LOCALE_SSHORTESTDAYNAME3,
4040 LOCALE_SSHORTESTDAYNAME4,
4041 LOCALE_SSHORTESTDAYNAME5,
4042 LOCALE_SSHORTESTDAYNAME6,
4043 LOCALE_SSHORTESTDAYNAME7,
4044 LOCALE_SMONTHDAY,
4045 0, /* CAL_SABBREVERASTRING */
4046 };
4047 DWORD flags = 0;
4048 CALTYPE calinfo = type & 0xffff;
4049
4050 if (type & CAL_NOUSEROVERRIDE) FIXME("flag CAL_NOUSEROVERRIDE used, not fully implemented\n");
4051 if (type & CAL_USE_CP_ACP) FIXME("flag CAL_USE_CP_ACP used, not fully implemented\n");
4052
4053 if ((type & CAL_RETURN_NUMBER) && !value)
4054 {
4055 SetLastError( ERROR_INVALID_PARAMETER );
4056 return 0;
4057 }
4058
4059 if (type & CAL_RETURN_GENITIVE_NAMES) flags |= LOCALE_RETURN_GENITIVE_NAMES;
4060
4061 switch (calinfo)
4062 {
4063 case CAL_ICALINTVALUE:
4064 if (type & CAL_RETURN_NUMBER)
4065 return GetLocaleInfoW( lcid, LOCALE_RETURN_NUMBER | LOCALE_ICALENDARTYPE,
4066 (WCHAR *)value, sizeof(*value) / sizeof(WCHAR) );
4067 return GetLocaleInfoW( lcid, LOCALE_ICALENDARTYPE, data, count );
4068
4069 case CAL_SCALNAME:
4070 FIXME( "Unimplemented caltype %ld\n", calinfo );
4071 if (data) *data = 0;
4072 return 1;
4073
4074 case CAL_IYEAROFFSETRANGE:
4075 case CAL_SERASTRING:
4076 case CAL_SABBREVERASTRING:
4077 FIXME( "Unimplemented caltype %ld\n", calinfo );
4078 return 0;
4079
4080 case CAL_SSHORTDATE:
4081 case CAL_SLONGDATE:
4082 case CAL_SDAYNAME1:
4083 case CAL_SDAYNAME2:
4084 case CAL_SDAYNAME3:
4085 case CAL_SDAYNAME4:
4086 case CAL_SDAYNAME5:
4087 case CAL_SDAYNAME6:
4088 case CAL_SDAYNAME7:
4089 case CAL_SABBREVDAYNAME1:
4090 case CAL_SABBREVDAYNAME2:
4091 case CAL_SABBREVDAYNAME3:
4092 case CAL_SABBREVDAYNAME4:
4093 case CAL_SABBREVDAYNAME5:
4094 case CAL_SABBREVDAYNAME6:
4095 case CAL_SABBREVDAYNAME7:
4096 case CAL_SMONTHNAME1:
4097 case CAL_SMONTHNAME2:
4098 case CAL_SMONTHNAME3:
4099 case CAL_SMONTHNAME4:
4100 case CAL_SMONTHNAME5:
4101 case CAL_SMONTHNAME6:
4102 case CAL_SMONTHNAME7:
4103 case CAL_SMONTHNAME8:
4104 case CAL_SMONTHNAME9:
4105 case CAL_SMONTHNAME10:
4106 case CAL_SMONTHNAME11:
4107 case CAL_SMONTHNAME12:
4108 case CAL_SMONTHNAME13:
4109 case CAL_SABBREVMONTHNAME1:
4110 case CAL_SABBREVMONTHNAME2:
4111 case CAL_SABBREVMONTHNAME3:
4112 case CAL_SABBREVMONTHNAME4:
4113 case CAL_SABBREVMONTHNAME5:
4114 case CAL_SABBREVMONTHNAME6:
4115 case CAL_SABBREVMONTHNAME7:
4116 case CAL_SABBREVMONTHNAME8:
4117 case CAL_SABBREVMONTHNAME9:
4118 case CAL_SABBREVMONTHNAME10:
4119 case CAL_SABBREVMONTHNAME11:
4120 case CAL_SABBREVMONTHNAME12:
4121 case CAL_SABBREVMONTHNAME13:
4122 case CAL_SMONTHDAY:
4123 case CAL_SYEARMONTH:
4124 case CAL_SSHORTESTDAYNAME1:
4125 case CAL_SSHORTESTDAYNAME2:
4126 case CAL_SSHORTESTDAYNAME3:
4127 case CAL_SSHORTESTDAYNAME4:
4128 case CAL_SSHORTESTDAYNAME5:
4129 case CAL_SSHORTESTDAYNAME6:
4130 case CAL_SSHORTESTDAYNAME7:
4131 return GetLocaleInfoW( lcid, lctype_map[calinfo] | flags, data, count );
4132
4133 case CAL_ITWODIGITYEARMAX:
4134 if (type & CAL_RETURN_NUMBER)
4135 {
4136 *value = CALINFO_MAX_YEAR;
4137 return sizeof(DWORD) / sizeof(WCHAR);
4138 }
4139 else
4140 {
4141 WCHAR buffer[10];
4142 int ret = swprintf( buffer, ARRAY_SIZE(buffer), L"%u", CALINFO_MAX_YEAR ) + 1;
4143 if (!data) return ret;
4144 if (ret <= count)
4145 {
4146 lstrcpyW( data, buffer );
4147 return ret;
4148 }
4149 SetLastError( ERROR_INSUFFICIENT_BUFFER );
4150 return 0;
4151 }
4152 break;
4153 default:
4154 FIXME( "Unknown caltype %ld\n", calinfo );
4155 SetLastError( ERROR_INVALID_FLAGS );
4156 return 0;
4157 }
4158 return 0;
4159 }
4160
4161
4162 /***********************************************************************
4163 * GetCalendarInfoEx (kernelbase.@)
4164 */
4165 INT WINAPI DECLSPEC_HOTPATCH GetCalendarInfoEx( const WCHAR *locale, CALID calendar, const WCHAR *reserved,
4166 CALTYPE type, WCHAR *data, INT count, DWORD *value )
4167 {
4168 LCID lcid = LocaleNameToLCID( locale, 0 );
4169 return GetCalendarInfoW( lcid, calendar, type, data, count, value );
4170 }
4171
4172 static CRITICAL_SECTION tzname_section;
4173 static CRITICAL_SECTION_DEBUG tzname_section_debug =
4174 {
4175 0, 0, &tzname_section,
4176 { &tzname_section_debug.ProcessLocksList, &tzname_section_debug.ProcessLocksList },
4177 0, 0, { (DWORD_PTR)(__FILE__ ": tzname_section") }
4178 };
4179 static CRITICAL_SECTION tzname_section = { &tzname_section_debug, -1, 0, 0, 0, 0 };
4180 static struct {
4181 LCID lcid;
4182 WCHAR key_name[128];
4183 WCHAR standard_name[32];
4184 WCHAR daylight_name[32];
4185 } cached_tzname;
4186
4187 /***********************************************************************
4188 * GetDynamicTimeZoneInformation (kernelbase.@)
4189 */
4190 DWORD WINAPI DECLSPEC_HOTPATCH GetDynamicTimeZoneInformation( DYNAMIC_TIME_ZONE_INFORMATION *info )
4191 {
4192 HKEY key;
4193 LARGE_INTEGER now;
4194
4195 if (!set_ntstatus( RtlQueryDynamicTimeZoneInformation( (RTL_DYNAMIC_TIME_ZONE_INFORMATION *)info )))
4196 return TIME_ZONE_ID_INVALID;
4197
4198 RtlEnterCriticalSection( &tzname_section );
4199 if (cached_tzname.lcid == GetThreadLocale() &&
4200 !wcscmp( info->TimeZoneKeyName, cached_tzname.key_name ))
4201 {
4202 wcscpy( info->StandardName, cached_tzname.standard_name );
4203 wcscpy( info->DaylightName, cached_tzname.daylight_name );
4204 RtlLeaveCriticalSection( &tzname_section );
4205 }
4206 else
4207 {
4208 RtlLeaveCriticalSection( &tzname_section );
4209 if (!RegOpenKeyExW( tz_key, info->TimeZoneKeyName, 0, KEY_ALL_ACCESS, &key ))
4210 {
4211 RegLoadMUIStringW( key, L"MUI_Std", info->StandardName,
4212 sizeof(info->StandardName), NULL, 0, system_dir );
4213 RegLoadMUIStringW( key, L"MUI_Dlt", info->DaylightName,
4214 sizeof(info->DaylightName), NULL, 0, system_dir );
4215 RegCloseKey( key );
4216 }
4217 else return TIME_ZONE_ID_INVALID;
4218
4219 RtlEnterCriticalSection( &tzname_section );
4220 cached_tzname.lcid = GetThreadLocale();
4221 wcscpy( cached_tzname.key_name, info->TimeZoneKeyName );
4222 wcscpy( cached_tzname.standard_name, info->StandardName );
4223 wcscpy( cached_tzname.daylight_name, info->DaylightName );
4224 RtlLeaveCriticalSection( &tzname_section );
4225 }
4226
4227 NtQuerySystemTime( &now );
4228 return get_timezone_id( (TIME_ZONE_INFORMATION *)info, now, FALSE );
4229 }
4230
4231
4232 /******************************************************************************
4233 * GetDynamicTimeZoneInformationEffectiveYears (kernelbase.@)
4234 */
4235 DWORD WINAPI DECLSPEC_HOTPATCH GetDynamicTimeZoneInformationEffectiveYears( const DYNAMIC_TIME_ZONE_INFORMATION *info,
4236 DWORD *first, DWORD *last )
4237 {
4238 HKEY key, dst_key = 0;
4239 DWORD type, count, ret = ERROR_FILE_NOT_FOUND;
4240
4241 if (RegOpenKeyExW( tz_key, info->TimeZoneKeyName, 0, KEY_ALL_ACCESS, &key )) return ret;
4242
4243 if (RegOpenKeyExW( key, L"Dynamic DST", 0, KEY_ALL_ACCESS, &dst_key )) goto done;
4244 count = sizeof(DWORD);
4245 if (RegQueryValueExW( dst_key, L"FirstEntry", NULL, &type, (BYTE *)first, &count )) goto done;
4246 if (type != REG_DWORD) goto done;
4247 count = sizeof(DWORD);
4248 if (RegQueryValueExW( dst_key, L"LastEntry", NULL, &type, (BYTE *)last, &count )) goto done;
4249 if (type != REG_DWORD) goto done;
4250 ret = 0;
4251
4252 done:
4253 RegCloseKey( dst_key );
4254 RegCloseKey( key );
4255 return ret;
4256 }
4257
4258
4259 /******************************************************************************
4260 * GetFileMUIInfo (kernelbase.@)
4261 */
4262 BOOL WINAPI /* DECLSPEC_HOTPATCH */ GetFileMUIInfo( DWORD flags, const WCHAR *path,
4263 FILEMUIINFO *info, DWORD *size )
4264 {
4265 FIXME( "stub: %lu, %s, %p, %p\n", flags, debugstr_w(path), info, size );
4266 SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
4267 return FALSE;
4268 }
4269
4270
4271 /******************************************************************************
4272 * GetFileMUIPath (kernelbase.@)
4273 */
4274 BOOL WINAPI /* DECLSPEC_HOTPATCH */ GetFileMUIPath( DWORD flags, const WCHAR *filepath,
4275 WCHAR *language, ULONG *languagelen,
4276 WCHAR *muipath, ULONG *muipathlen,
4277 ULONGLONG *enumerator )
4278 {
4279 FIXME( "stub: 0x%lx, %s, %s, %p, %p, %p, %p\n", flags, debugstr_w(filepath),
4280 debugstr_w(language), languagelen, muipath, muipathlen, enumerator );
4281 SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
4282 return FALSE;
4283 }
4284
4285
4286 /******************************************************************************
4287 * GetGeoInfoW (kernelbase.@)
4288 */
4289 INT WINAPI DECLSPEC_HOTPATCH GetGeoInfoW( GEOID id, GEOTYPE type, WCHAR *data, int count, LANGID lang )
4290 {
4291 const struct geoinfo *ptr = get_geoinfo_ptr( id );
4292 WCHAR bufferW[12];
4293 const WCHAR *str = bufferW;
4294 int len;
4295
4296 TRACE( "%ld %ld %p %d %d\n", id, type, data, count, lang );
4297
4298 if (!ptr)
4299 {
4300 SetLastError( ERROR_INVALID_PARAMETER );
4301 return 0;
4302 }
4303 switch (type)
4304 {
4305 case GEO_NATION:
4306 if (ptr->kind != LOCATION_NATION) return 0;
4307 /* fall through */
4308 case GEO_ID:
4309 swprintf( bufferW, ARRAY_SIZE(bufferW), L"%u", ptr->id );
4310 break;
4311 case GEO_ISO_UN_NUMBER:
4312 swprintf( bufferW, ARRAY_SIZE(bufferW), L"%03u", ptr->uncode );
4313 break;
4314 case GEO_PARENT:
4315 swprintf( bufferW, ARRAY_SIZE(bufferW), L"%u", ptr->parent );
4316 break;
4317 case GEO_ISO2:
4318 str = ptr->iso2W;
4319 break;
4320 case GEO_ISO3:
4321 str = ptr->iso3W;
4322 break;
4323 case GEO_RFC1766:
4324 case GEO_LCID:
4325 case GEO_FRIENDLYNAME:
4326 case GEO_OFFICIALNAME:
4327 case GEO_TIMEZONES:
4328 case GEO_OFFICIALLANGUAGES:
4329 case GEO_LATITUDE:
4330 case GEO_LONGITUDE:
4331 case GEO_DIALINGCODE:
4332 case GEO_CURRENCYCODE:
4333 case GEO_CURRENCYSYMBOL:
4334 case GEO_NAME:
4335 FIXME( "type %ld is not supported\n", type );
4336 SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
4337 return 0;
4338 default:
4339 WARN( "unrecognized type %ld\n", type );
4340 SetLastError( ERROR_INVALID_FLAGS );
4341 return 0;
4342 }
4343
4344 len = lstrlenW(str) + 1;
4345 if (!data || !count) return len;
4346
4347 memcpy( data, str, min(len, count) * sizeof(WCHAR) );
4348 if (count < len) SetLastError( ERROR_INSUFFICIENT_BUFFER );
4349 return count < len ? 0 : len;
4350 }
4351
4352
4353 /******************************************************************************
4354 * GetLocaleInfoA (kernelbase.@)
4355 */
4356 INT WINAPI DECLSPEC_HOTPATCH GetLocaleInfoA( LCID lcid, LCTYPE lctype, char *buffer, INT len )
4357 {
4358 WCHAR *bufferW;
4359 INT lenW, ret;
4360
4361 TRACE( "lcid=0x%lx lctype=0x%lx %p %d\n", lcid, lctype, buffer, len );
4362
4363 if (len < 0 || (len && !buffer))
4364 {
4365 SetLastError( ERROR_INVALID_PARAMETER );
4366 return 0;
4367 }
4368 if (LOWORD(lctype) == LOCALE_SSHORTTIME || (lctype & LOCALE_RETURN_GENITIVE_NAMES))
4369 {
4370 SetLastError( ERROR_INVALID_FLAGS );
4371 return 0;
4372 }
4373
4374 if (LOWORD(lctype) == LOCALE_FONTSIGNATURE || (lctype & LOCALE_RETURN_NUMBER))
4375 return GetLocaleInfoW( lcid, lctype, (WCHAR *)buffer, len / sizeof(WCHAR) ) * sizeof(WCHAR);
4376
4377 if (!(lenW = GetLocaleInfoW( lcid, lctype, NULL, 0 ))) return 0;
4378
4379 if (!(bufferW = RtlAllocateHeap( GetProcessHeap(), 0, lenW * sizeof(WCHAR) )))
4380 {
4381 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
4382 return 0;
4383 }
4384 ret = GetLocaleInfoW( lcid, lctype, bufferW, lenW );
4385 if (ret) ret = WideCharToMultiByte( get_lcid_codepage( lcid, lctype ), 0,
4386 bufferW, ret, buffer, len, NULL, NULL );
4387 RtlFreeHeap( GetProcessHeap(), 0, bufferW );
4388 return ret;
4389 }
4390
4391
4392 /******************************************************************************
4393 * GetLocaleInfoW (kernelbase.@)
4394 */
4395 INT WINAPI DECLSPEC_HOTPATCH GetLocaleInfoW( LCID lcid, LCTYPE lctype, WCHAR *buffer, INT len )
4396 {
4397 HRSRC hrsrc;
4398 HGLOBAL hmem;
4399 INT ret;
4400 UINT lcflags = lctype;
4401 const WCHAR *p;
4402 unsigned int i;
4403
4404 if (len < 0 || (len && !buffer))
4405 {
4406 SetLastError( ERROR_INVALID_PARAMETER );
4407 return 0;
4408 }
4409 if (lctype & LOCALE_RETURN_GENITIVE_NAMES && !is_genitive_name_supported( lctype ))
4410 {
4411 SetLastError( ERROR_INVALID_FLAGS );
4412 return 0;
4413 }
4414
4415 if (!len) buffer = NULL;
4416
4417 lcid = ConvertDefaultLocale( lcid );
4418 lctype = LOWORD(lctype);
4419
4420 TRACE( "(lcid=0x%lx,lctype=0x%lx,%p,%d)\n", lcid, lctype, buffer, len );
4421
4422 /* first check for overrides in the registry */
4423
4424 if (!(lcflags & LOCALE_NOUSEROVERRIDE) && lcid == ConvertDefaultLocale( LOCALE_USER_DEFAULT ))
4425 {
4426 const struct registry_value *value = get_locale_registry_value( lctype );
4427
4428 if (value)
4429 {
4430 if (lcflags & LOCALE_RETURN_NUMBER)
4431 {
4432 WCHAR tmp[16];
4433 ret = get_registry_locale_info( value, tmp, ARRAY_SIZE( tmp ));
4434 if (ret > 0)
4435 {
4436 WCHAR *end;
4437 UINT number = wcstol( tmp, &end, get_value_base_by_lctype( lctype ) );
4438 if (*end) /* invalid number */
4439 {
4440 SetLastError( ERROR_INVALID_FLAGS );
4441 return 0;
4442 }
4443 ret = sizeof(UINT) / sizeof(WCHAR);
4444 if (!len) return ret;
4445 if (ret > len)
4446 {
4447 SetLastError( ERROR_INSUFFICIENT_BUFFER );
4448 return 0;
4449 }
4450 memcpy( buffer, &number, sizeof(number) );
4451 }
4452 }
4453 else ret = get_registry_locale_info( value, buffer, len );
4454
4455 if (ret != -1) return ret;
4456 }
4457 }
4458
4459 /* now load it from kernel resources */
4460
4461 if (!(hrsrc = FindResourceExW( kernel32_handle, (LPWSTR)RT_STRING,
4462 ULongToPtr((lctype >> 4) + 1), lcid )))
4463 {
4464 SetLastError( ERROR_INVALID_FLAGS ); /* no such lctype */
4465 return 0;
4466 }
4467 if (!(hmem = LoadResource( kernel32_handle, hrsrc ))) return 0;
4468
4469 p = LockResource( hmem );
4470 for (i = 0; i < (lctype & 0x0f); i++) p += *p + 1;
4471
4472 if (lcflags & LOCALE_RETURN_NUMBER) ret = sizeof(UINT) / sizeof(WCHAR);
4473 else if (is_genitive_name_supported( lctype ) && *p)
4474 {
4475 /* genitive form is stored after a null separator from a nominative */
4476 for (i = 1; i <= *p; i++) if (!p[i]) break;
4477
4478 if (i <= *p && (lcflags & LOCALE_RETURN_GENITIVE_NAMES))
4479 {
4480 ret = *p - i + 1;
4481 p += i;
4482 }
4483 else ret = i;
4484 }
4485 else
4486 ret = (lctype == LOCALE_FONTSIGNATURE) ? *p : *p + 1;
4487
4488 if (!len) return ret;
4489
4490 if (ret > len)
4491 {
4492 SetLastError( ERROR_INSUFFICIENT_BUFFER );
4493 return 0;
4494 }
4495
4496 if (lcflags & LOCALE_RETURN_NUMBER)
4497 {
4498 UINT number;
4499 WCHAR *end, *tmp = HeapAlloc( GetProcessHeap(), 0, (*p + 1) * sizeof(WCHAR) );
4500 if (!tmp) return 0;
4501 memcpy( tmp, p + 1, *p * sizeof(WCHAR) );
4502 tmp[*p] = 0;
4503 number = wcstol( tmp, &end, get_value_base_by_lctype( lctype ) );
4504 if (!*end)
4505 memcpy( buffer, &number, sizeof(number) );
4506 else /* invalid number */
4507 {
4508 SetLastError( ERROR_INVALID_FLAGS );
4509 ret = 0;
4510 }
4511 HeapFree( GetProcessHeap(), 0, tmp );
4512
4513 TRACE( "(lcid=0x%lx,lctype=0x%lx,%p,%d) returning number %d\n",
4514 lcid, lctype, buffer, len, number );
4515 }
4516 else
4517 {
4518 memcpy( buffer, p + 1, ret * sizeof(WCHAR) );
4519 if (lctype != LOCALE_FONTSIGNATURE) buffer[ret-1] = 0;
4520
4521 TRACE( "(lcid=0x%lx,lctype=0x%lx,%p,%d) returning %d %s\n",
4522 lcid, lctype, buffer, len, ret, debugstr_w(buffer) );
4523 }
4524 return ret;
4525 }
4526
4527
4528 /******************************************************************************
4529 * GetLocaleInfoEx (kernelbase.@)
4530 */
4531 INT WINAPI DECLSPEC_HOTPATCH GetLocaleInfoEx( const WCHAR *locale, LCTYPE info, WCHAR *buffer, INT len )
4532 {
4533 LCID lcid = LocaleNameToLCID( locale, 0 );
4534
4535 TRACE( "%s lcid=0x%lx 0x%lx\n", debugstr_w(locale), lcid, info );
4536
4537 if (!lcid) return 0;
4538
4539 /* special handling for neutral locale names */
4540 if (locale && lstrlenW( locale ) == 2)
4541 {
4542 switch (LOWORD( info ))
4543 {
4544 case LOCALE_SNAME:
4545 if (len && len < 3)
4546 {
4547 SetLastError( ERROR_INSUFFICIENT_BUFFER );
4548 return 0;
4549 }
4550 if (len) lstrcpyW( buffer, locale );
4551 return 3;
4552 case LOCALE_SPARENT:
4553 if (len) buffer[0] = 0;
4554 return 1;
4555 }
4556 }
4557 return GetLocaleInfoW( lcid, info, buffer, len );
4558 }
4559
4560
4561 /******************************************************************************
4562 * GetNLSVersion (kernelbase.@)
4563 */
4564 BOOL WINAPI DECLSPEC_HOTPATCH GetNLSVersion( NLS_FUNCTION func, LCID lcid, NLSVERSIONINFO *info )
4565 {
4566 WCHAR locale[LOCALE_NAME_MAX_LENGTH];
4567
4568 if (info->dwNLSVersionInfoSize < offsetof( NLSVERSIONINFO, dwEffectiveId ))
4569 {
4570 SetLastError( ERROR_INSUFFICIENT_BUFFER );
4571 return FALSE;
4572 }
4573 if (!LCIDToLocaleName( lcid, locale, LOCALE_NAME_MAX_LENGTH, LOCALE_ALLOW_NEUTRAL_NAMES ))
4574 {
4575 SetLastError( ERROR_INVALID_PARAMETER );
4576 return FALSE;
4577 }
4578 return GetNLSVersionEx( func, locale, (NLSVERSIONINFOEX *)info );
4579 }
4580
4581
4582 /******************************************************************************
4583 * GetNLSVersionEx (kernelbase.@)
4584 */
4585 BOOL WINAPI DECLSPEC_HOTPATCH GetNLSVersionEx( NLS_FUNCTION func, const WCHAR *locale,
4586 NLSVERSIONINFOEX *info )
4587 {
4588 LCID lcid = 0;
4589
4590 if (func != COMPARE_STRING)
4591 {
4592 SetLastError( ERROR_INVALID_FLAGS );
4593 return FALSE;
4594 }
4595 if (info->dwNLSVersionInfoSize < sizeof(*info) &&
4596 (info->dwNLSVersionInfoSize != offsetof( NLSVERSIONINFO, dwEffectiveId )))
4597 {
4598 SetLastError( ERROR_INSUFFICIENT_BUFFER );
4599 return FALSE;
4600 }
4601
4602 if (!(lcid = LocaleNameToLCID( locale, 0 ))) return FALSE;
4603
4604 info->dwNLSVersion = info->dwDefinedVersion = sort.version;
4605 if (info->dwNLSVersionInfoSize >= sizeof(*info))
4606 {
4607 const struct sortguid *sortid = get_language_sort( locale );
4608 info->dwEffectiveId = lcid;
4609 info->guidCustomVersion = sortid ? sortid->id : default_sort_guid;
4610 }
4611 return TRUE;
4612 }
4613
4614
4615 /******************************************************************************
4616 * GetOEMCP (kernelbase.@)
4617 */
4618 UINT WINAPI GetOEMCP(void)
4619 {
4620 return nls_info.OemTableInfo.CodePage;
4621 }
4622
4623
4624 /***********************************************************************
4625 * GetProcessPreferredUILanguages (kernelbase.@)
4626 */
4627 BOOL WINAPI DECLSPEC_HOTPATCH GetProcessPreferredUILanguages( DWORD flags, ULONG *count,
4628 WCHAR *buffer, ULONG *size )
4629 {
4630 return set_ntstatus( RtlGetProcessPreferredUILanguages( flags, count, buffer, size ));
4631 }
4632
4633
4634 /***********************************************************************
4635 * GetStringTypeA (kernelbase.@)
4636 */
4637 BOOL WINAPI DECLSPEC_HOTPATCH GetStringTypeA( LCID locale, DWORD type, const char *src, int count,
4638 WORD *chartype )
4639 {
4640 UINT cp;
4641 INT countW;
4642 LPWSTR srcW;
4643 BOOL ret = FALSE;
4644
4645 if (count == -1) count = strlen(src) + 1;
4646
4647 cp = get_lcid_codepage( locale, 0 );
4648 countW = MultiByteToWideChar(cp, 0, src, count, NULL, 0);
4649 if((srcW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
4650 {
4651 MultiByteToWideChar(cp, 0, src, count, srcW, countW);
4652 /*
4653 * NOTE: the target buffer has 1 word for each CHARACTER in the source
4654 * string, with multibyte characters there maybe be more bytes in count
4655 * than character space in the buffer!
4656 */
4657 ret = GetStringTypeW(type, srcW, countW, chartype);
4658 HeapFree(GetProcessHeap(), 0, srcW);
4659 }
4660 return ret;
4661 }
4662
4663
4664 /***********************************************************************
4665 * GetStringTypeW (kernelbase.@)
4666 */
4667 BOOL WINAPI DECLSPEC_HOTPATCH GetStringTypeW( DWORD type, const WCHAR *src, INT count, WORD *chartype )
4668 {
4669 if (!src)
4670 {
4671 SetLastError( ERROR_INVALID_PARAMETER );
4672 return FALSE;
4673 }
4674 if (type != CT_CTYPE1 && type != CT_CTYPE2 && type != CT_CTYPE3)
4675 {
4676 SetLastError( ERROR_INVALID_PARAMETER );
4677 return FALSE;
4678 }
4679
4680 if (count == -1) count = lstrlenW(src) + 1;
4681
4682 while (count--) *chartype++ = get_char_type( type, *src++ );
4683
4684 return TRUE;
4685 }
4686
4687
4688 /***********************************************************************
4689 * GetStringTypeExW (kernelbase.@)
4690 */
4691 BOOL WINAPI DECLSPEC_HOTPATCH GetStringTypeExW( LCID locale, DWORD type, const WCHAR *src, int count,
4692 WORD *chartype )
4693 {
4694 /* locale is ignored for Unicode */
4695 return GetStringTypeW( type, src, count, chartype );
4696 }
4697
4698
4699 /***********************************************************************
4700 * GetSystemDefaultLCID (kernelbase.@)
4701 */
4702 LCID WINAPI DECLSPEC_HOTPATCH GetSystemDefaultLCID(void)
4703 {
4704 LCID lcid;
4705 NtQueryDefaultLocale( FALSE, &lcid );
4706 return lcid;
4707 }
4708
4709
4710 /***********************************************************************
4711 * GetSystemDefaultLangID (kernelbase.@)
4712 */
4713 LANGID WINAPI DECLSPEC_HOTPATCH GetSystemDefaultLangID(void)
4714 {
4715 return LANGIDFROMLCID( GetSystemDefaultLCID() );
4716 }
4717
4718
4719 /***********************************************************************
4720 * GetSystemDefaultLocaleName (kernelbase.@)
4721 */
4722 INT WINAPI DECLSPEC_HOTPATCH GetSystemDefaultLocaleName( LPWSTR name, INT len )
4723 {
4724 return LCIDToLocaleName( GetSystemDefaultLCID(), name, len, 0 );
4725 }
4726
4727
4728 /***********************************************************************
4729 * GetSystemDefaultUILanguage (kernelbase.@)
4730 */
4731 LANGID WINAPI DECLSPEC_HOTPATCH GetSystemDefaultUILanguage(void)
4732 {
4733 LANGID lang;
4734 NtQueryInstallUILanguage( &lang );
4735 return lang;
4736 }
4737
4738
4739 /***********************************************************************
4740 * GetSystemPreferredUILanguages (kernelbase.@)
4741 */
4742 BOOL WINAPI DECLSPEC_HOTPATCH GetSystemPreferredUILanguages( DWORD flags, ULONG *count,
4743 WCHAR *buffer, ULONG *size )
4744 {
4745 return set_ntstatus( RtlGetSystemPreferredUILanguages( flags, 0, count, buffer, size ));
4746 }
4747
4748
4749 /***********************************************************************
4750 * GetThreadPreferredUILanguages (kernelbase.@)
4751 */
4752 BOOL WINAPI DECLSPEC_HOTPATCH GetThreadPreferredUILanguages( DWORD flags, ULONG *count,
4753 WCHAR *buffer, ULONG *size )
4754 {
4755 return set_ntstatus( RtlGetThreadPreferredUILanguages( flags, count, buffer, size ));
4756 }
4757
4758
4759 /***********************************************************************
4760 * GetTimeZoneInformation (kernelbase.@)
4761 */
4762 DWORD WINAPI DECLSPEC_HOTPATCH GetTimeZoneInformation( TIME_ZONE_INFORMATION *info )
4763 {
4764 DYNAMIC_TIME_ZONE_INFORMATION tzinfo;
4765 DWORD ret = GetDynamicTimeZoneInformation( &tzinfo );
4766
4767 memcpy( info, &tzinfo, sizeof(*info) );
4768 return ret;
4769 }
4770
4771
4772 /***********************************************************************
4773 * GetTimeZoneInformationForYear (kernelbase.@)
4774 */
4775 BOOL WINAPI DECLSPEC_HOTPATCH GetTimeZoneInformationForYear( USHORT year,
4776 DYNAMIC_TIME_ZONE_INFORMATION *dynamic,
4777 TIME_ZONE_INFORMATION *info )
4778 {
4779 DYNAMIC_TIME_ZONE_INFORMATION local_info;
4780 HKEY key = 0, dst_key;
4781 DWORD count;
4782 LRESULT ret;
4783 struct
4784 {
4785 LONG bias;
4786 LONG std_bias;
4787 LONG dlt_bias;
4788 SYSTEMTIME std_date;
4789 SYSTEMTIME dlt_date;
4790 } data;
4791
4792 TRACE( "(%u,%p)\n", year, info );
4793
4794 if (!dynamic)
4795 {
4796 if (GetDynamicTimeZoneInformation( &local_info ) == TIME_ZONE_ID_INVALID) return FALSE;
4797 dynamic = &local_info;
4798 }
4799
4800 if ((ret = RegOpenKeyExW( tz_key, dynamic->TimeZoneKeyName, 0, KEY_ALL_ACCESS, &key ))) goto done;
4801 if (RegLoadMUIStringW( key, L"MUI_Std", info->StandardName,
4802 sizeof(info->StandardName), NULL, 0, system_dir ))
4803 {
4804 count = sizeof(info->StandardName);
4805 if ((ret = RegQueryValueExW( key, L"Std", NULL, NULL, (BYTE *)info->StandardName, &count )))
4806 goto done;
4807 }
4808 if (RegLoadMUIStringW( key, L"MUI_Dlt", info->DaylightName,
4809 sizeof(info->DaylightName), NULL, 0, system_dir ))
4810 {
4811 count = sizeof(info->DaylightName);
4812 if ((ret = RegQueryValueExW( key, L"Dlt", NULL, NULL, (BYTE *)info->DaylightName, &count )))
4813 goto done;
4814 }
4815
4816 ret = ERROR_FILE_NOT_FOUND;
4817 if (!dynamic->DynamicDaylightTimeDisabled &&
4818 !RegOpenKeyExW( key, L"Dynamic DST", 0, KEY_ALL_ACCESS, &dst_key ))
4819 {
4820 WCHAR yearW[16];
4821 swprintf( yearW, ARRAY_SIZE(yearW), L"%u", year );
4822 count = sizeof(data);
4823 ret = RegQueryValueExW( dst_key, yearW, NULL, NULL, (BYTE *)&data, &count );
4824 RegCloseKey( dst_key );
4825 }
4826 if (ret)
4827 {
4828 count = sizeof(data);
4829 ret = RegQueryValueExW( key, L"TZI", NULL, NULL, (BYTE *)&data, &count );
4830 }
4831
4832 if (!ret)
4833 {
4834 info->Bias = data.bias;
4835 info->StandardBias = data.std_bias;
4836 info->DaylightBias = data.dlt_bias;
4837 info->StandardDate = data.std_date;
4838 info->DaylightDate = data.dlt_date;
4839 }
4840
4841 done:
4842 RegCloseKey( key );
4843 if (ret) SetLastError( ret );
4844 return !ret;
4845 }
4846
4847
4848 /***********************************************************************
4849 * GetUserDefaultLCID (kernelbase.@)
4850 */
4851 LCID WINAPI DECLSPEC_HOTPATCH GetUserDefaultLCID(void)
4852 {
4853 LCID lcid;
4854 NtQueryDefaultLocale( TRUE, &lcid );
4855 return lcid;
4856 }
4857
4858
4859 /***********************************************************************
4860 * GetUserDefaultLangID (kernelbase.@)
4861 */
4862 LANGID WINAPI DECLSPEC_HOTPATCH GetUserDefaultLangID(void)
4863 {
4864 return LANGIDFROMLCID( GetUserDefaultLCID() );
4865 }
4866
4867
4868 /***********************************************************************
4869 * GetUserDefaultLocaleName (kernelbase.@)
4870 */
4871 INT WINAPI DECLSPEC_HOTPATCH GetUserDefaultLocaleName( LPWSTR name, INT len )
4872 {
4873 return LCIDToLocaleName( GetUserDefaultLCID(), name, len, 0 );
4874 }
4875
4876
4877 /***********************************************************************
4878 * GetUserDefaultUILanguage (kernelbase.@)
4879 */
4880 LANGID WINAPI DECLSPEC_HOTPATCH GetUserDefaultUILanguage(void)
4881 {
4882 LANGID lang;
4883 NtQueryDefaultUILanguage( &lang );
4884 return lang;
4885 }
4886
4887
4888 /******************************************************************************
4889 * GetUserGeoID (kernelbase.@)
4890 */
4891 GEOID WINAPI DECLSPEC_HOTPATCH GetUserGeoID( GEOCLASS geoclass )
4892 {
4893 GEOID ret = 39070;
4894 const WCHAR *name;
4895 WCHAR bufferW[40];
4896 HKEY hkey;
4897
4898 switch (geoclass)
4899 {
4900 case GEOCLASS_NATION:
4901 name = L"Nation";
4902 break;
4903 case GEOCLASS_REGION:
4904 name = L"Region";
4905 break;
4906 default:
4907 WARN("Unknown geoclass %ld\n", geoclass);
4908 return GEOID_NOT_AVAILABLE;
4909 }
4910 if (!RegOpenKeyExW( intl_key, L"Geo", 0, KEY_ALL_ACCESS, &hkey ))
4911 {
4912 DWORD count = sizeof(bufferW);
4913 if (!RegQueryValueExW( hkey, name, NULL, NULL, (BYTE *)bufferW, &count ))
4914 ret = wcstol( bufferW, NULL, 10 );
4915 RegCloseKey( hkey );
4916 }
4917 return ret;
4918 }
4919
4920
4921 /******************************************************************************
4922 * GetUserPreferredUILanguages (kernelbase.@)
4923 */
4924 BOOL WINAPI DECLSPEC_HOTPATCH GetUserPreferredUILanguages( DWORD flags, ULONG *count,
4925 WCHAR *buffer, ULONG *size )
4926 {
4927 return set_ntstatus( RtlGetUserPreferredUILanguages( flags, 0, count, buffer, size ));
4928 }
4929
4930
4931 /******************************************************************************
4932 * IdnToAscii (kernelbase.@)
4933 */
4934 INT WINAPI DECLSPEC_HOTPATCH IdnToAscii( DWORD flags, const WCHAR *src, INT srclen,
4935 WCHAR *dst, INT dstlen )
4936 {
4937 NTSTATUS status = RtlIdnToAscii( flags, src, srclen, dst, &dstlen );
4938 if (!set_ntstatus( status )) return 0;
4939 return dstlen;
4940 }
4941
4942
4943 /******************************************************************************
4944 * IdnToNameprepUnicode (kernelbase.@)
4945 */
4946 INT WINAPI DECLSPEC_HOTPATCH IdnToNameprepUnicode( DWORD flags, const WCHAR *src, INT srclen,
4947 WCHAR *dst, INT dstlen )
4948 {
4949 NTSTATUS status = RtlIdnToNameprepUnicode( flags, src, srclen, dst, &dstlen );
4950 if (!set_ntstatus( status )) return 0;
4951 return dstlen;
4952 }
4953
4954
4955 /******************************************************************************
4956 * IdnToUnicode (kernelbase.@)
4957 */
4958 INT WINAPI DECLSPEC_HOTPATCH IdnToUnicode( DWORD flags, const WCHAR *src, INT srclen,
4959 WCHAR *dst, INT dstlen )
4960 {
4961 NTSTATUS status = RtlIdnToUnicode( flags, src, srclen, dst, &dstlen );
4962 if (!set_ntstatus( status )) return 0;
4963 return dstlen;
4964 }
4965
4966
4967 /******************************************************************************
4968 * IsCharAlphaA (kernelbase.@)
4969 */
4970 BOOL WINAPI DECLSPEC_HOTPATCH IsCharAlphaA( CHAR c )
4971 {
4972 WCHAR wc = nls_info.AnsiTableInfo.MultiByteTable[(unsigned char)c];
4973 return !!(get_char_type( CT_CTYPE1, wc ) & C1_ALPHA);
4974 }
4975
4976
4977 /******************************************************************************
4978 * IsCharAlphaW (kernelbase.@)
4979 */
4980 BOOL WINAPI DECLSPEC_HOTPATCH IsCharAlphaW( WCHAR wc )
4981 {
4982 return !!(get_char_type( CT_CTYPE1, wc ) & C1_ALPHA);
4983 }
4984
4985
4986 /******************************************************************************
4987 * IsCharAlphaNumericA (kernelbase.@)
4988 */
4989 BOOL WINAPI DECLSPEC_HOTPATCH IsCharAlphaNumericA( CHAR c )
4990 {
4991 WCHAR wc = nls_info.AnsiTableInfo.MultiByteTable[(unsigned char)c];
4992 return !!(get_char_type( CT_CTYPE1, wc ) & (C1_ALPHA | C1_DIGIT));
4993 }
4994
4995
4996 /******************************************************************************
4997 * IsCharAlphaNumericW (kernelbase.@)
4998 */
4999 BOOL WINAPI DECLSPEC_HOTPATCH IsCharAlphaNumericW( WCHAR wc )
5000 {
5001 return !!(get_char_type( CT_CTYPE1, wc ) & (C1_ALPHA | C1_DIGIT));
5002 }
5003
5004
5005 /******************************************************************************
5006 * IsCharBlankW (kernelbase.@)
5007 */
5008 BOOL WINAPI DECLSPEC_HOTPATCH IsCharBlankW( WCHAR wc )
5009 {
5010 return !!(get_char_type( CT_CTYPE1, wc ) & C1_BLANK);
5011 }
5012
5013
5014 /******************************************************************************
5015 * IsCharCntrlW (kernelbase.@)
5016 */
5017 BOOL WINAPI DECLSPEC_HOTPATCH IsCharCntrlW( WCHAR wc )
5018 {
5019 return !!(get_char_type( CT_CTYPE1, wc ) & C1_CNTRL);
5020 }
5021
5022
5023 /******************************************************************************
5024 * IsCharDigitW (kernelbase.@)
5025 */
5026 BOOL WINAPI DECLSPEC_HOTPATCH IsCharDigitW( WCHAR wc )
5027 {
5028 return !!(get_char_type( CT_CTYPE1, wc ) & C1_DIGIT);
5029 }
5030
5031
5032 /******************************************************************************
5033 * IsCharLowerA (kernelbase.@)
5034 */
5035 BOOL WINAPI DECLSPEC_HOTPATCH IsCharLowerA( CHAR c )
5036 {
5037 WCHAR wc = nls_info.AnsiTableInfo.MultiByteTable[(unsigned char)c];
5038 return !!(get_char_type( CT_CTYPE1, wc ) & C1_LOWER);
5039 }
5040
5041
5042 /******************************************************************************
5043 * IsCharLowerW (kernelbase.@)
5044 */
5045 BOOL WINAPI DECLSPEC_HOTPATCH IsCharLowerW( WCHAR wc )
5046 {
5047 return !!(get_char_type( CT_CTYPE1, wc ) & C1_LOWER);
5048 }
5049
5050
5051 /******************************************************************************
5052 * IsCharPunctW (kernelbase.@)
5053 */
5054 BOOL WINAPI DECLSPEC_HOTPATCH IsCharPunctW( WCHAR wc )
5055 {
5056 return !!(get_char_type( CT_CTYPE1, wc ) & C1_PUNCT);
5057 }
5058
5059
5060 /******************************************************************************
5061 * IsCharSpaceA (kernelbase.@)
5062 */
5063 BOOL WINAPI DECLSPEC_HOTPATCH IsCharSpaceA( CHAR c )
5064 {
5065 WCHAR wc = nls_info.AnsiTableInfo.MultiByteTable[(unsigned char)c];
5066 return !!(get_char_type( CT_CTYPE1, wc ) & C1_SPACE);
5067 }
5068
5069
5070 /******************************************************************************
5071 * IsCharSpaceW (kernelbase.@)
5072 */
5073 BOOL WINAPI DECLSPEC_HOTPATCH IsCharSpaceW( WCHAR wc )
5074 {
5075 return !!(get_char_type( CT_CTYPE1, wc ) & C1_SPACE);
5076 }
5077
5078
5079 /******************************************************************************
5080 * IsCharUpperA (kernelbase.@)
5081 */
5082 BOOL WINAPI DECLSPEC_HOTPATCH IsCharUpperA( CHAR c )
5083 {
5084 WCHAR wc = nls_info.AnsiTableInfo.MultiByteTable[(unsigned char)c];
5085 return !!(get_char_type( CT_CTYPE1, wc ) & C1_UPPER);
5086 }
5087
5088
5089 /******************************************************************************
5090 * IsCharUpperW (kernelbase.@)
5091 */
5092 BOOL WINAPI DECLSPEC_HOTPATCH IsCharUpperW( WCHAR wc )
5093 {
5094 return !!(get_char_type( CT_CTYPE1, wc ) & C1_UPPER);
5095 }
5096
5097
5098 /******************************************************************************
5099 * IsCharXDigitW (kernelbase.@)
5100 */
5101 BOOL WINAPI DECLSPEC_HOTPATCH IsCharXDigitW( WCHAR wc )
5102 {
5103 return !!(get_char_type( CT_CTYPE1, wc ) & C1_XDIGIT);
5104 }
5105
5106
5107 /******************************************************************************
5108 * IsDBCSLeadByte (kernelbase.@)
5109 */
5110 BOOL WINAPI DECLSPEC_HOTPATCH IsDBCSLeadByte( BYTE testchar )
5111 {
5112 return nls_info.AnsiTableInfo.DBCSCodePage && nls_info.AnsiTableInfo.DBCSOffsets[testchar];
5113 }
5114
5115
5116 /******************************************************************************
5117 * IsDBCSLeadByteEx (kernelbase.@)
5118 */
5119 BOOL WINAPI DECLSPEC_HOTPATCH IsDBCSLeadByteEx( UINT codepage, BYTE testchar )
5120 {
5121 const CPTABLEINFO *table = get_codepage_table( codepage );
5122 return table && table->DBCSCodePage && table->DBCSOffsets[testchar];
5123 }
5124
5125
5126 /******************************************************************************
5127 * IsNormalizedString (kernelbase.@)
5128 */
5129 BOOL WINAPI DECLSPEC_HOTPATCH IsNormalizedString( NORM_FORM form, const WCHAR *str, INT len )
5130 {
5131 BOOLEAN res;
5132 if (!set_ntstatus( RtlIsNormalizedString( form, str, len, &res ))) res = FALSE;
5133 return res;
5134 }
5135
5136
5137 /******************************************************************************
5138 * IsValidCodePage (kernelbase.@)
5139 */
5140 BOOL WINAPI DECLSPEC_HOTPATCH IsValidCodePage( UINT codepage )
5141 {
5142 switch (codepage)
5143 {
5144 case CP_ACP:
5145 case CP_OEMCP:
5146 case CP_MACCP:
5147 case CP_THREAD_ACP:
5148 return FALSE;
5149 case CP_UTF7:
5150 case CP_UTF8:
5151 return TRUE;
5152 default:
5153 return get_codepage_table( codepage ) != NULL;
5154 }
5155 }
5156
5157
5158 /******************************************************************************
5159 * IsValidLanguageGroup (kernelbase.@)
5160 */
5161 BOOL WINAPI DECLSPEC_HOTPATCH IsValidLanguageGroup( LGRPID id, DWORD flags )
5162 {
5163 WCHAR name[10], value[10];
5164 DWORD type, value_len = sizeof(value);
5165 BOOL ret = FALSE;
5166 HKEY key;
5167
5168 if (RegOpenKeyExW( nls_key, L"Language Groups", 0, KEY_READ, &key )) return FALSE;
5169
5170 swprintf( name, ARRAY_SIZE(name), L"%x", id );
5171 if (!RegQueryValueExW( key, name, NULL, &type, (BYTE *)value, &value_len ) && type == REG_SZ)
5172 ret = (flags & LGRPID_SUPPORTED) || wcstoul( value, NULL, 10 );
5173
5174 RegCloseKey( key );
5175 return ret;
5176 }
5177
5178
5179 /******************************************************************************
5180 * IsValidLocale (kernelbase.@)
5181 */
5182 BOOL WINAPI DECLSPEC_HOTPATCH IsValidLocale( LCID lcid, DWORD flags )
5183 {
5184 /* check if language is registered in the kernel32 resources */
5185 return FindResourceExW( kernel32_handle, (LPWSTR)RT_STRING,
5186 ULongToPtr( (LOCALE_ILANGUAGE >> 4) + 1 ), LANGIDFROMLCID(lcid)) != 0;
5187 }
5188
5189
5190 /******************************************************************************
5191 * IsValidLocaleName (kernelbase.@)
5192 */
5193 BOOL WINAPI DECLSPEC_HOTPATCH IsValidLocaleName( const WCHAR *locale )
5194 {
5195 LCID lcid;
5196
5197 return !RtlLocaleNameToLcid( locale, &lcid, 2 );
5198 }
5199
5200
5201 /******************************************************************************
5202 * IsValidNLSVersion (kernelbase.@)
5203 */
5204 DWORD WINAPI DECLSPEC_HOTPATCH IsValidNLSVersion( NLS_FUNCTION func, const WCHAR *locale,
5205 NLSVERSIONINFOEX *info )
5206 {
5207 static const GUID GUID_NULL;
5208 NLSVERSIONINFOEX infoex;
5209 DWORD ret;
5210
5211 if (func != COMPARE_STRING)
5212 {
5213 SetLastError( ERROR_INVALID_PARAMETER );
5214 return FALSE;
5215 }
5216 if (info->dwNLSVersionInfoSize < sizeof(*info) &&
5217 (info->dwNLSVersionInfoSize != offsetof( NLSVERSIONINFO, dwEffectiveId )))
5218 {
5219 SetLastError( ERROR_INVALID_PARAMETER );
5220 return FALSE;
5221 }
5222 infoex.dwNLSVersionInfoSize = sizeof(infoex);
5223 if (!GetNLSVersionEx( func, locale, &infoex )) return FALSE;
5224
5225 ret = (infoex.dwNLSVersion & ~0xff) == (info->dwNLSVersion & ~0xff);
5226 if (ret && !IsEqualGUID( &info->guidCustomVersion, &GUID_NULL ))
5227 ret = find_sortguid( &info->guidCustomVersion ) != NULL;
5228
5229 if (!ret) SetLastError( ERROR_SUCCESS );
5230 return ret;
5231 }
5232
5233
5234 /***********************************************************************
5235 * LCIDToLocaleName (kernelbase.@)
5236 */
5237 INT WINAPI DECLSPEC_HOTPATCH LCIDToLocaleName( LCID lcid, WCHAR *name, INT count, DWORD flags )
5238 {
5239 static int once;
5240 if (flags && !once++) FIXME( "unsupported flags %lx\n", flags );
5241
5242 return GetLocaleInfoW( lcid, LOCALE_SNAME | LOCALE_NOUSEROVERRIDE, name, count );
5243 }
5244
5245
5246 /***********************************************************************
5247 * LCMapStringEx (kernelbase.@)
5248 */
5249 INT WINAPI DECLSPEC_HOTPATCH LCMapStringEx( const WCHAR *locale, DWORD flags, const WCHAR *src, int srclen,
5250 WCHAR *dst, int dstlen, NLSVERSIONINFO *version,
5251 void *reserved, LPARAM handle )
5252 {
5253 const struct sortguid *sortid = NULL;
5254 LPWSTR dst_ptr;
5255 INT len;
5256
5257 if (version) FIXME( "unsupported version structure %p\n", version );
5258 if (reserved) FIXME( "unsupported reserved pointer %p\n", reserved );
5259 if (handle)
5260 {
5261 static int once;
5262 if (!once++) FIXME( "unsupported lparam %Ix\n", handle );
5263 }
5264
5265 if (!src || !srclen || dstlen < 0)
5266 {
5267 SetLastError( ERROR_INVALID_PARAMETER );
5268 return 0;
5269 }
5270
5271 /* mutually exclusive flags */
5272 if ((flags & (LCMAP_LOWERCASE | LCMAP_UPPERCASE)) == (LCMAP_LOWERCASE | LCMAP_UPPERCASE) ||
5273 (flags & (LCMAP_HIRAGANA | LCMAP_KATAKANA)) == (LCMAP_HIRAGANA | LCMAP_KATAKANA) ||
5274 (flags & (LCMAP_HALFWIDTH | LCMAP_FULLWIDTH)) == (LCMAP_HALFWIDTH | LCMAP_FULLWIDTH) ||
5275 (flags & (LCMAP_TRADITIONAL_CHINESE | LCMAP_SIMPLIFIED_CHINESE)) == (LCMAP_TRADITIONAL_CHINESE | LCMAP_SIMPLIFIED_CHINESE) ||
5276 !flags)
5277 {
5278 SetLastError( ERROR_INVALID_FLAGS );
5279 return 0;
5280 }
5281
5282 if (!dstlen) dst = NULL;
5283
5284 if (flags & LCMAP_LINGUISTIC_CASING && !(sortid = get_language_sort( locale )))
5285 {
5286 FIXME( "unknown locale %s\n", debugstr_w(locale) );
5287 SetLastError( ERROR_INVALID_PARAMETER );
5288 return 0;
5289 }
5290
5291 if (flags & LCMAP_SORTKEY)
5292 {
5293 INT ret;
5294
5295 if (src == dst)
5296 {
5297 SetLastError( ERROR_INVALID_FLAGS );
5298 return 0;
5299 }
5300 if (srclen < 0) srclen = lstrlenW(src);
5301
5302 TRACE( "(%s,0x%08lx,%s,%d,%p,%d)\n",
5303 debugstr_w(locale), flags, debugstr_wn(src, srclen), srclen, dst, dstlen );
5304
5305 if ((ret = get_sortkey( flags, src, srclen, (char *)dst, dstlen ))) ret++;
5306 else SetLastError( ERROR_INSUFFICIENT_BUFFER );
5307 return ret;
5308 }
5309
5310 /* SORT_STRINGSORT must be used exclusively with LCMAP_SORTKEY */
5311 if (flags & SORT_STRINGSORT)
5312 {
5313 SetLastError( ERROR_INVALID_FLAGS );
5314 return 0;
5315 }
5316 if (((flags & (NORM_IGNORENONSPACE | NORM_IGNORESYMBOLS)) &&
5317 (flags & ~(NORM_IGNORENONSPACE | NORM_IGNORESYMBOLS))) ||
5318 ((flags & (LCMAP_HIRAGANA | LCMAP_KATAKANA | LCMAP_HALFWIDTH | LCMAP_FULLWIDTH)) &&
5319 (flags & (LCMAP_SIMPLIFIED_CHINESE | LCMAP_TRADITIONAL_CHINESE))))
5320 {
5321 SetLastError( ERROR_INVALID_FLAGS );
5322 return 0;
5323 }
5324
5325 if (srclen < 0) srclen = lstrlenW(src) + 1;
5326
5327 TRACE( "(%s,0x%08lx,%s,%d,%p,%d)\n",
5328 debugstr_w(locale), flags, debugstr_wn(src, srclen), srclen, dst, dstlen );
5329
5330 if (!dst) /* return required string length */
5331 {
5332 if (flags & NORM_IGNORESYMBOLS)
5333 {
5334 for (len = 0; srclen; src++, srclen--)
5335 if (!(get_char_type( CT_CTYPE1, *src ) & (C1_PUNCT | C1_SPACE))) len++;
5336 }
5337 else if (flags & LCMAP_FULLWIDTH)
5338 {
5339 for (len = 0; srclen; src++, srclen--, len++)
5340 {
5341 if (compose_katakana( src, srclen, NULL ) == 2)
5342 {
5343 src++;
5344 srclen--;
5345 }
5346 }
5347 }
5348 else if (flags & LCMAP_HALFWIDTH)
5349 {
5350 for (len = 0; srclen; src++, srclen--, len++)
5351 {
5352 WCHAR wch = *src;
5353 /* map Hiragana to Katakana before decomposition if needed */
5354 if ((flags & LCMAP_KATAKANA) &&
5355 ((wch >= 0x3041 && wch <= 0x3096) || wch == 0x309D || wch == 0x309E))
5356 wch += 0x60;
5357
5358 if (decompose_katakana( wch, NULL, 0 ) == 2) len++;
5359 }
5360 }
5361 else len = srclen;
5362 return len;
5363 }
5364
5365 if (src == dst && (flags & ~(LCMAP_LOWERCASE | LCMAP_UPPERCASE)))
5366 {
5367 SetLastError( ERROR_INVALID_FLAGS );
5368 return 0;
5369 }
5370
5371 if (flags & (NORM_IGNORENONSPACE | NORM_IGNORESYMBOLS))
5372 {
5373 for (len = dstlen, dst_ptr = dst; srclen && len; src++, srclen--)
5374 {
5375 if ((flags & NORM_IGNORESYMBOLS) && (get_char_type( CT_CTYPE1, *src ) & (C1_PUNCT | C1_SPACE)))
5376 continue;
5377 *dst_ptr++ = *src;
5378 len--;
5379 }
5380 goto done;
5381 }
5382
5383 if (flags & (LCMAP_FULLWIDTH | LCMAP_HALFWIDTH | LCMAP_HIRAGANA | LCMAP_KATAKANA))
5384 {
5385 for (len = dstlen, dst_ptr = dst; len && srclen; src++, srclen--, len--, dst_ptr++)
5386 {
5387 WCHAR wch;
5388 if (flags & LCMAP_FULLWIDTH)
5389 {
5390 /* map half-width character to full-width one,
5391 e.g. U+FF71 -> U+30A2, U+FF8C U+FF9F -> U+30D7. */
5392 if (map_to_fullwidth( src, srclen, &wch ) == 2)
5393 {
5394 src++;
5395 srclen--;
5396 }
5397 }
5398 else wch = *src;
5399
5400 if (flags & LCMAP_KATAKANA)
5401 {
5402 /* map hiragana to katakana, e.g. U+3041 -> U+30A1.
5403 we can't use C3_HIRAGANA as some characters can't map to katakana */
5404 if ((wch >= 0x3041 && wch <= 0x3096) || wch == 0x309D || wch == 0x309E) wch += 0x60;
5405 }
5406 else if (flags & LCMAP_HIRAGANA)
5407 {
5408 /* map katakana to hiragana, e.g. U+30A1 -> U+3041.
5409 we can't use C3_KATAKANA as some characters can't map to hiragana */
5410 if ((wch >= 0x30A1 && wch <= 0x30F6) || wch == 0x30FD || wch == 0x30FE) wch -= 0x60;
5411 }
5412
5413 if (flags & LCMAP_HALFWIDTH)
5414 {
5415 /* map full-width character to half-width one,
5416 e.g. U+30A2 -> U+FF71, U+30D7 -> U+FF8C U+FF9F. */
5417 if (map_to_halfwidth(wch, dst_ptr, len) == 2)
5418 {
5419 len--;
5420 dst_ptr++;
5421 if (!len) break;
5422 }
5423 }
5424 else *dst_ptr = wch;
5425 }
5426 if (!(flags & (LCMAP_UPPERCASE | LCMAP_LOWERCASE)) || srclen) goto done;
5427
5428 srclen = dst_ptr - dst;
5429 src = dst;
5430 }
5431
5432 if (flags & (LCMAP_UPPERCASE | LCMAP_LOWERCASE))
5433 {
5434 const USHORT *table = sort.casemap + (flags & LCMAP_LINGUISTIC_CASING ? sortid->casemap : 0);
5435 table = table + 2 + (flags & LCMAP_LOWERCASE ? table[1] : 0);
5436 for (len = dstlen, dst_ptr = dst; srclen && len; src++, srclen--, len--)
5437 *dst_ptr++ = casemap( table, *src );
5438 }
5439 else
5440 {
5441 len = min( srclen, dstlen );
5442 memcpy( dst, src, len * sizeof(WCHAR) );
5443 dst_ptr = dst + len;
5444 srclen -= len;
5445 }
5446
5447 done:
5448 if (srclen)
5449 {
5450 SetLastError( ERROR_INSUFFICIENT_BUFFER );
5451 return 0;
5452 }
5453
5454 return dst_ptr - dst;
5455 }
5456
5457
5458 /***********************************************************************
5459 * LCMapStringA (kernelbase.@)
5460 */
5461 INT WINAPI DECLSPEC_HOTPATCH LCMapStringA( LCID lcid, DWORD flags, const char *src, int srclen,
5462 char *dst, int dstlen )
5463 {
5464 WCHAR *bufW = NtCurrentTeb()->StaticUnicodeBuffer;
5465 LPWSTR srcW, dstW;
5466 INT ret = 0, srclenW, dstlenW;
5467 UINT locale_cp = CP_ACP;
5468
5469 if (!src || !srclen || dstlen < 0)
5470 {
5471 SetLastError( ERROR_INVALID_PARAMETER );
5472 return 0;
5473 }
5474
5475 locale_cp = get_lcid_codepage( lcid, flags );
5476
5477 srclenW = MultiByteToWideChar( locale_cp, 0, src, srclen, bufW, 260 );
5478 if (srclenW) srcW = bufW;
5479 else
5480 {
5481 srclenW = MultiByteToWideChar( locale_cp, 0, src, srclen, NULL, 0 );
5482 srcW = HeapAlloc( GetProcessHeap(), 0, srclenW * sizeof(WCHAR) );
5483 if (!srcW)
5484 {
5485 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
5486 return 0;
5487 }
5488 MultiByteToWideChar( locale_cp, 0, src, srclen, srcW, srclenW );
5489 }
5490
5491 if (flags & LCMAP_SORTKEY)
5492 {
5493 if (src == dst)
5494 {
5495 SetLastError( ERROR_INVALID_FLAGS );
5496 goto done;
5497 }
5498 ret = LCMapStringEx( NULL, flags, srcW, srclenW, (WCHAR *)dst, dstlen, NULL, NULL, 0 );
5499 goto done;
5500 }
5501
5502 if (flags & SORT_STRINGSORT)
5503 {
5504 SetLastError( ERROR_INVALID_FLAGS );
5505 goto done;
5506 }
5507
5508 dstlenW = LCMapStringEx( NULL, flags, srcW, srclenW, NULL, 0, NULL, NULL, 0 );
5509 if (!dstlenW) goto done;
5510
5511 dstW = HeapAlloc( GetProcessHeap(), 0, dstlenW * sizeof(WCHAR) );
5512 if (!dstW)
5513 {
5514 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
5515 goto done;
5516 }
5517 LCMapStringEx( NULL, flags, srcW, srclenW, dstW, dstlenW, NULL, NULL, 0 );
5518 ret = WideCharToMultiByte( locale_cp, 0, dstW, dstlenW, dst, dstlen, NULL, NULL );
5519 HeapFree( GetProcessHeap(), 0, dstW );
5520
5521 done:
5522 if (srcW != bufW) HeapFree( GetProcessHeap(), 0, srcW );
5523 return ret;
5524 }
5525
5526
5527 /***********************************************************************
5528 * LCMapStringW (kernelbase.@)
5529 */
5530 INT WINAPI DECLSPEC_HOTPATCH LCMapStringW( LCID lcid, DWORD flags, const WCHAR *src, int srclen,
5531 WCHAR *dst, int dstlen )
5532 {
5533 return LCMapStringEx( NULL, flags, src, srclen, dst, dstlen, NULL, NULL, 0 );
5534 }
5535
5536
5537 /***********************************************************************
5538 * LocaleNameToLCID (kernelbase.@)
5539 */
5540 LCID WINAPI DECLSPEC_HOTPATCH LocaleNameToLCID( const WCHAR *name, DWORD flags )
5541 {
5542 LCID lcid;
5543
5544 if (!name) return GetUserDefaultLCID();
5545 if (!set_ntstatus( RtlLocaleNameToLcid( name, &lcid, 2 ))) return 0;
5546 if (!(flags & LOCALE_ALLOW_NEUTRAL_NAMES)) lcid = ConvertDefaultLocale( lcid );
5547 return lcid;
5548 }
5549
5550
5551 /******************************************************************************
5552 * MultiByteToWideChar (kernelbase.@)
5553 */
5554 INT WINAPI DECLSPEC_HOTPATCH MultiByteToWideChar( UINT codepage, DWORD flags, const char *src, INT srclen,
5555 WCHAR *dst, INT dstlen )
5556 {
5557 int ret;
5558
5559 if (!src || !srclen || (!dst && dstlen) || dstlen < 0)
5560 {
5561 SetLastError( ERROR_INVALID_PARAMETER );
5562 return 0;
5563 }
5564 if (srclen < 0) srclen = strlen(src) + 1;
5565
5566 switch (codepage)
5567 {
5568 case CP_SYMBOL:
5569 ret = mbstowcs_cpsymbol( flags, src, srclen, dst, dstlen );
5570 break;
5571 case CP_UTF7:
5572 ret = mbstowcs_utf7( flags, src, srclen, dst, dstlen );
5573 break;
5574 case CP_UTF8:
5575 ret = mbstowcs_utf8( flags, src, srclen, dst, dstlen );
5576 break;
5577 case CP_UNIXCP:
5578 if (unix_cp == CP_UTF8)
5579 {
5580 ret = mbstowcs_utf8( flags, src, srclen, dst, dstlen );
5581 break;
5582 }
5583 codepage = unix_cp;
5584 /* fall through */
5585 default:
5586 ret = mbstowcs_codepage( codepage, flags, src, srclen, dst, dstlen );
5587 break;
5588 }
5589 TRACE( "cp %d %s -> %s, ret = %d\n", codepage, debugstr_an(src, srclen), debugstr_wn(dst, ret), ret );
5590 return ret;
5591 }
5592
5593
5594 /******************************************************************************
5595 * NormalizeString (kernelbase.@)
5596 */
5597 INT WINAPI DECLSPEC_HOTPATCH NormalizeString(NORM_FORM form, const WCHAR *src, INT src_len,
5598 WCHAR *dst, INT dst_len)
5599 {
5600 NTSTATUS status = RtlNormalizeString( form, src, src_len, dst, &dst_len );
5601
5602 switch (status)
5603 {
5604 case STATUS_OBJECT_NAME_NOT_FOUND:
5605 status = STATUS_INVALID_PARAMETER;
5606 break;
5607 case STATUS_BUFFER_TOO_SMALL:
5608 case STATUS_NO_UNICODE_TRANSLATION:
5609 dst_len = -dst_len;
5610 break;
5611 }
5612 SetLastError( RtlNtStatusToDosError( status ));
5613 return dst_len;
5614 }
5615
5616
5617 /******************************************************************************
5618 * ResolveLocaleName (kernelbase.@)
5619 */
5620 INT WINAPI DECLSPEC_HOTPATCH ResolveLocaleName( LPCWSTR name, LPWSTR buffer, INT len )
5621 {
5622 FIXME( "stub: %s, %p, %d\n", wine_dbgstr_w(name), buffer, len );
5623
5624 SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
5625 return 0;
5626 }
5627
5628
5629 /******************************************************************************
5630 * SetLocaleInfoW (kernelbase.@)
5631 */
5632 BOOL WINAPI DECLSPEC_HOTPATCH SetLocaleInfoW( LCID lcid, LCTYPE lctype, const WCHAR *data )
5633 {
5634 const struct registry_value *value;
5635 DWORD index;
5636 LSTATUS status;
5637
5638 lctype = LOWORD(lctype);
5639 value = get_locale_registry_value( lctype );
5640
5641 if (!data || !value)
5642 {
5643 SetLastError( ERROR_INVALID_PARAMETER );
5644 return FALSE;
5645 }
5646
5647 if (lctype == LOCALE_IDATE || lctype == LOCALE_ILDATE)
5648 {
5649 SetLastError( ERROR_INVALID_FLAGS );
5650 return FALSE;
5651 }
5652
5653 TRACE( "setting %lx (%s) to %s\n", lctype, debugstr_w(value->name), debugstr_w(data) );
5654
5655 /* FIXME: should check that data to set is sane */
5656
5657 status = RegSetValueExW( intl_key, value->name, 0, REG_SZ, (BYTE *)data, (lstrlenW(data)+1)*sizeof(WCHAR) );
5658 index = value - registry_values;
5659
5660 RtlEnterCriticalSection( &locale_section );
5661 HeapFree( GetProcessHeap(), 0, registry_cache[index] );
5662 registry_cache[index] = NULL;
5663 RtlLeaveCriticalSection( &locale_section );
5664
5665 if (lctype == LOCALE_SSHORTDATE || lctype == LOCALE_SLONGDATE)
5666 {
5667 /* Set I-value from S value */
5668 WCHAR *pD, *pM, *pY, buf[2];
5669
5670 pD = wcschr( data, 'd' );
5671 pM = wcschr( data, 'M' );
5672 pY = wcschr( data, 'y' );
5673
5674 if (pD <= pM) buf[0] = '1'; /* D-M-Y */
5675 else if (pY <= pM) buf[0] = '2'; /* Y-M-D */
5676 else buf[0] = '0'; /* M-D-Y */
5677 buf[1] = 0;
5678
5679 lctype = (lctype == LOCALE_SSHORTDATE) ? LOCALE_IDATE : LOCALE_ILDATE;
5680 value = get_locale_registry_value( lctype );
5681 index = value - registry_values;
5682
5683 RegSetValueExW( intl_key, value->name, 0, REG_SZ, (BYTE *)buf, sizeof(buf) );
5684
5685 RtlEnterCriticalSection( &locale_section );
5686 HeapFree( GetProcessHeap(), 0, registry_cache[index] );
5687 registry_cache[index] = NULL;
5688 RtlLeaveCriticalSection( &locale_section );
5689 }
5690 return set_ntstatus( status );
5691 }
5692
5693
5694 /***********************************************************************
5695 * SetCalendarInfoW (kernelbase.@)
5696 */
5697 INT WINAPI /* DECLSPEC_HOTPATCH */ SetCalendarInfoW( LCID lcid, CALID calendar, CALTYPE type, const WCHAR *data )
5698 {
5699 FIXME( "(%08lx,%08lx,%08lx,%s): stub\n", lcid, calendar, type, debugstr_w(data) );
5700 return 0;
5701 }
5702
5703
5704 /***********************************************************************
5705 * SetProcessPreferredUILanguages (kernelbase.@)
5706 */
5707 BOOL WINAPI DECLSPEC_HOTPATCH SetProcessPreferredUILanguages( DWORD flags, PCZZWSTR buffer, ULONG *count )
5708 {
5709 return set_ntstatus( RtlSetProcessPreferredUILanguages( flags, buffer, count ));
5710 }
5711
5712
5713 /***********************************************************************
5714 * SetThreadPreferredUILanguages (kernelbase.@)
5715 */
5716 BOOL WINAPI DECLSPEC_HOTPATCH SetThreadPreferredUILanguages( DWORD flags, PCZZWSTR buffer, ULONG *count )
5717 {
5718 return set_ntstatus( RtlSetThreadPreferredUILanguages( flags, buffer, count ));
5719 }
5720
5721
5722 /***********************************************************************
5723 * SetTimeZoneInformation (kernelbase.@)
5724 */
5725 BOOL WINAPI DECLSPEC_HOTPATCH SetTimeZoneInformation( const TIME_ZONE_INFORMATION *info )
5726 {
5727 return set_ntstatus( RtlSetTimeZoneInformation( (const RTL_TIME_ZONE_INFORMATION *)info ));
5728 }
5729
5730
5731 /******************************************************************************
5732 * SetUserGeoID (kernelbase.@)
5733 */
5734 BOOL WINAPI DECLSPEC_HOTPATCH SetUserGeoID( GEOID id )
5735 {
5736 const struct geoinfo *geoinfo = get_geoinfo_ptr( id );
5737 WCHAR bufferW[10];
5738 HKEY hkey;
5739
5740 if (!geoinfo)
5741 {
5742 SetLastError( ERROR_INVALID_PARAMETER );
5743 return FALSE;
5744 }
5745 if (!RegCreateKeyExW( intl_key, L"Geo", 0, NULL, 0, KEY_ALL_ACCESS, NULL, &hkey, NULL ))
5746 {
5747 const WCHAR *name = geoinfo->kind == LOCATION_NATION ? L"Nation" : L"Region";
5748 swprintf( bufferW, ARRAY_SIZE(bufferW), L"%u", geoinfo->id );
5749 RegSetValueExW( hkey, name, 0, REG_SZ, (BYTE *)bufferW, (lstrlenW(bufferW) + 1) * sizeof(WCHAR) );
5750
5751 if (geoinfo->kind == LOCATION_NATION || geoinfo->kind == LOCATION_BOTH)
5752 lstrcpyW( bufferW, geoinfo->iso2W );
5753 else
5754 swprintf( bufferW, ARRAY_SIZE(bufferW), L"%03u", geoinfo->uncode );
5755 RegSetValueExW( hkey, L"Name", 0, REG_SZ, (BYTE *)bufferW, (lstrlenW(bufferW) + 1) * sizeof(WCHAR) );
5756 RegCloseKey( hkey );
5757 }
5758 return TRUE;
5759 }
5760
5761
5762 /***********************************************************************
5763 * SystemTimeToTzSpecificLocalTime (kernelbase.@)
5764 */
5765 BOOL WINAPI DECLSPEC_HOTPATCH SystemTimeToTzSpecificLocalTime( const TIME_ZONE_INFORMATION *info,
5766 const SYSTEMTIME *system,
5767 SYSTEMTIME *local )
5768 {
5769 TIME_ZONE_INFORMATION tzinfo;
5770 LARGE_INTEGER ft;
5771
5772 if (!info)
5773 {
5774 RtlQueryTimeZoneInformation( (RTL_TIME_ZONE_INFORMATION *)&tzinfo );
5775 info = &tzinfo;
5776 }
5777
5778 if (!SystemTimeToFileTime( system, (FILETIME *)&ft )) return FALSE;
5779 switch (get_timezone_id( info, ft, FALSE ))
5780 {
5781 case TIME_ZONE_ID_UNKNOWN:
5782 ft.QuadPart -= info->Bias * (LONGLONG)600000000;
5783 break;
5784 case TIME_ZONE_ID_STANDARD:
5785 ft.QuadPart -= (info->Bias + info->StandardBias) * (LONGLONG)600000000;
5786 break;
5787 case TIME_ZONE_ID_DAYLIGHT:
5788 ft.QuadPart -= (info->Bias + info->DaylightBias) * (LONGLONG)600000000;
5789 break;
5790 default:
5791 return FALSE;
5792 }
5793 return FileTimeToSystemTime( (FILETIME *)&ft, local );
5794 }
5795
5796
5797 /***********************************************************************
5798 * TzSpecificLocalTimeToSystemTime (kernelbase.@)
5799 */
5800 BOOL WINAPI DECLSPEC_HOTPATCH TzSpecificLocalTimeToSystemTime( const TIME_ZONE_INFORMATION *info,
5801 const SYSTEMTIME *local,
5802 SYSTEMTIME *system )
5803 {
5804 TIME_ZONE_INFORMATION tzinfo;
5805 LARGE_INTEGER ft;
5806
5807 if (!info)
5808 {
5809 RtlQueryTimeZoneInformation( (RTL_TIME_ZONE_INFORMATION *)&tzinfo );
5810 info = &tzinfo;
5811 }
5812
5813 if (!SystemTimeToFileTime( local, (FILETIME *)&ft )) return FALSE;
5814 switch (get_timezone_id( info, ft, TRUE ))
5815 {
5816 case TIME_ZONE_ID_UNKNOWN:
5817 ft.QuadPart += info->Bias * (LONGLONG)600000000;
5818 break;
5819 case TIME_ZONE_ID_STANDARD:
5820 ft.QuadPart += (info->Bias + info->StandardBias) * (LONGLONG)600000000;
5821 break;
5822 case TIME_ZONE_ID_DAYLIGHT:
5823 ft.QuadPart += (info->Bias + info->DaylightBias) * (LONGLONG)600000000;
5824 break;
5825 default:
5826 return FALSE;
5827 }
5828 return FileTimeToSystemTime( (FILETIME *)&ft, system );
5829 }
5830
5831
5832 /***********************************************************************
5833 * VerLanguageNameA (kernelbase.@)
5834 */
5835 DWORD WINAPI DECLSPEC_HOTPATCH VerLanguageNameA( DWORD lang, LPSTR buffer, DWORD size )
5836 {
5837 return GetLocaleInfoA( MAKELCID( lang, SORT_DEFAULT ), LOCALE_SENGLANGUAGE, buffer, size );
5838 }
5839
5840
5841 /***********************************************************************
5842 * VerLanguageNameW (kernelbase.@)
5843 */
5844 DWORD WINAPI DECLSPEC_HOTPATCH VerLanguageNameW( DWORD lang, LPWSTR buffer, DWORD size )
5845 {
5846 return GetLocaleInfoW( MAKELCID( lang, SORT_DEFAULT ), LOCALE_SENGLANGUAGE, buffer, size );
5847 }
5848
5849
5850 /***********************************************************************
5851 * WideCharToMultiByte (kernelbase.@)
5852 */
5853 INT WINAPI DECLSPEC_HOTPATCH WideCharToMultiByte( UINT codepage, DWORD flags, LPCWSTR src, INT srclen,
5854 LPSTR dst, INT dstlen, LPCSTR defchar, BOOL *used )
5855 {
5856 int ret;
5857
5858 if (!src || !srclen || (!dst && dstlen) || dstlen < 0)
5859 {
5860 SetLastError( ERROR_INVALID_PARAMETER );
5861 return 0;
5862 }
5863
5864 if (srclen < 0) srclen = lstrlenW(src) + 1;
5865
5866 switch (codepage)
5867 {
5868 case CP_SYMBOL:
5869 ret = wcstombs_cpsymbol( flags, src, srclen, dst, dstlen, defchar, used );
5870 break;
5871 case CP_UTF7:
5872 ret = wcstombs_utf7( flags, src, srclen, dst, dstlen, defchar, used );
5873 break;
5874 case CP_UTF8:
5875 ret = wcstombs_utf8( flags, src, srclen, dst, dstlen, defchar, used );
5876 break;
5877 case CP_UNIXCP:
5878 if (unix_cp == CP_UTF8)
5879 {
5880 if (used) *used = FALSE;
5881 ret = wcstombs_utf8( flags, src, srclen, dst, dstlen, NULL, NULL );
5882 break;
5883 }
5884 codepage = unix_cp;
5885 /* fall through */
5886 default:
5887 ret = wcstombs_codepage( codepage, flags, src, srclen, dst, dstlen, defchar, used );
5888 break;
5889 }
5890 TRACE( "cp %d %s -> %s, ret = %d\n", codepage, debugstr_wn(src, srclen), debugstr_an(dst, ret), ret );
5891 return ret;
5892 }
5893
5894
5895 /***********************************************************************
5896 * GetUserDefaultGeoName (kernelbase.@)
5897 */
5898 INT WINAPI GetUserDefaultGeoName(LPWSTR geo_name, int count)
5899 {
5900 const struct geoinfo *geoinfo;
5901 WCHAR buffer[32];
5902 LSTATUS status;
5903 DWORD size;
5904 HKEY key;
5905
5906 TRACE( "geo_name %p, count %d.\n", geo_name, count );
5907
5908 if (count && !geo_name)
5909 {
5910 SetLastError( ERROR_INVALID_PARAMETER );
5911 return 0;
5912 }
5913 if (!(status = RegOpenKeyExW( intl_key, L"Geo", 0, KEY_ALL_ACCESS, &key )))
5914 {
5915 size = sizeof(buffer);
5916 status = RegQueryValueExW( key, L"Name", NULL, NULL, (BYTE *)buffer, &size );
5917 RegCloseKey( key );
5918 }
5919 if (status)
5920 {
5921 if ((geoinfo = get_geoinfo_ptr( GetUserGeoID( GEOCLASS_NATION ))) && geoinfo->id != 39070)
5922 lstrcpyW( buffer, geoinfo->iso2W );
5923 else
5924 lstrcpyW( buffer, L"001" );
5925 }
5926 size = lstrlenW( buffer ) + 1;
5927 if (count < size)
5928 {
5929 if (!count)
5930 return size;
5931 SetLastError( ERROR_INSUFFICIENT_BUFFER );
5932 return 0;
5933 }
5934 lstrcpyW( geo_name, buffer );
5935 return size;
5936 }
5937
5938
5939 /***********************************************************************
5940 * SetUserDefaultGeoName (kernelbase.@)
5941 */
5942 BOOL WINAPI SetUserGeoName(PWSTR geo_name)
5943 {
5944 unsigned int i;
5945 WCHAR *endptr;
5946 int uncode;
5947
5948 TRACE( "geo_name %s.\n", debugstr_w( geo_name ));
5949
5950 if (!geo_name)
5951 {
5952 SetLastError( ERROR_INVALID_PARAMETER );
5953 return FALSE;
5954 }
5955
5956 if (lstrlenW( geo_name ) == 3)
5957 {
5958 uncode = wcstol( geo_name, &endptr, 10 );
5959 if (!uncode || endptr != geo_name + 3)
5960 {
5961 SetLastError( ERROR_INVALID_PARAMETER );
5962 return FALSE;
5963 }
5964 for (i = 0; i < ARRAY_SIZE(geoinfodata); ++i)
5965 if (geoinfodata[i].uncode == uncode)
5966 break;
5967 }
5968 else
5969 {
5970 if (!lstrcmpiW( geo_name, L"XX" ))
5971 return SetUserGeoID( 39070 );
5972 for (i = 0; i < ARRAY_SIZE(geoinfodata); ++i)
5973 if (!lstrcmpiW( geo_name, geoinfodata[i].iso2W ))
5974 break;
5975 }
5976 if (i == ARRAY_SIZE(geoinfodata))
5977 {
5978 SetLastError( ERROR_INVALID_PARAMETER );
5979 return FALSE;
5980 }
5981 return SetUserGeoID( geoinfodata[i].id );
5982 }
Windows API implementation