1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /*
4 **********************************************************************
5 * Copyright (C) 1996-2016, International Business Machines
6 * Corporation and others. All Rights Reserved.
7 **********************************************************************
8 *
9 * Provides functionality for mapping between
10 * LCID and Posix IDs or ICU locale to codepage
11 *
12 * Note: All classes and code in this file are
13 * intended for internal use only.
14 *
15 * Methods of interest:
16 * unsigned long convertToLCID(const char*);
17 * const char* convertToPosix(unsigned long);
18 *
19 * Kathleen Wilson, 4/30/96
20 *
21 * Date Name Description
22 * 3/11/97 aliu Fixed off-by-one bug in assignment operator. Added
23 * setId() method and safety check against
24 * MAX_ID_LENGTH.
25 * 04/23/99 stephen Added C wrapper for convertToPosix.
26 * 09/18/00 george Removed the memory leaks.
27 * 08/23/01 george Convert to C
28 */
29
30 #include "locmap.h"
31 #include "cstring.h"
32 #include "cmemory.h"
33 #include "unicode/uloc.h"
34
35 #if U_PLATFORM == U_PF_WINDOWS && defined(_MSC_VER) && (_MSC_VER >= 1500)
36 /*
37 * TODO: It seems like we should widen this to
38 * either U_PLATFORM_USES_ONLY_WIN32_API (includes MinGW)
39 * or U_PLATFORM_HAS_WIN32_API (includes MinGW and Cygwin)
40 * but those use gcc and won't have defined(_MSC_VER).
41 * We might need to #include some Windows header and test for some version macro from there.
42 * Or call some Windows function and see what it returns.
43 */
44 #define USE_WINDOWS_LCID_MAPPING_API
45 #include <windows.h>
46 #include <winnls.h>
47 #endif
48
49 /*
50 * Note:
51 * The mapping from Win32 locale ID numbers to POSIX locale strings should
52 * be the faster one.
53 *
54 * Windows LCIDs are defined at https://msdn.microsoft.com/en-us/library/cc233965.aspx
55 * [MS-LCID] Windows Language Code Identifier (LCID) Reference
56 */
57
58 /*
59 ////////////////////////////////////////////////
60 //
61 // Internal Classes for LCID <--> POSIX Mapping
62 //
63 /////////////////////////////////////////////////
64 */
65
66 typedef struct ILcidPosixElement
67 {
68 const uint32_t hostID;
69 const char * const posixID;
70 } ILcidPosixElement;
71
72 typedef struct ILcidPosixMap
73 {
74 const uint32_t numRegions;
75 const struct ILcidPosixElement* const regionMaps;
76 } ILcidPosixMap;
77
78
79 /*
80 /////////////////////////////////////////////////
81 //
82 // Easy macros to make the LCID <--> POSIX Mapping
83 //
84 /////////////////////////////////////////////////
85 */
86
87 /**
88 * The standard one language/one country mapping for LCID.
89 * The first element must be the language, and the following
90 * elements are the language with the country.
91 * @param hostID LCID in host format such as 0x044d
92 * @param languageID posix ID of just the language such as 'de'
93 * @param posixID posix ID of the language_TERRITORY such as 'de_CH'
94 */
95 #define ILCID_POSIX_ELEMENT_ARRAY(hostID, languageID, posixID) \
96 static const ILcidPosixElement locmap_ ## languageID [] = { \
97 {LANGUAGE_LCID(hostID), #languageID}, /* parent locale */ \
98 {hostID, #posixID}, \
99 };
100
101 /**
102 * Define a subtable by ID
103 * @param id the POSIX ID, either a language or language_TERRITORY
104 */
105 #define ILCID_POSIX_SUBTABLE(id) \
106 static const ILcidPosixElement locmap_ ## id [] =
107
108
109 /**
110 * Create the map for the posixID. This macro supposes that the language string
111 * name is the same as the global variable name, and that the first element
112 * in the ILcidPosixElement is just the language.
113 * @param _posixID the full POSIX ID for this entry.
114 */
115 #define ILCID_POSIX_MAP(_posixID) \
116 {UPRV_LENGTHOF(locmap_ ## _posixID), locmap_ ## _posixID}
117
118 /*
119 ////////////////////////////////////////////
120 //
121 // Create the table of LCID to POSIX Mapping
122 // None of it should be dynamically created.
123 //
124 // Keep static locale variables inside the function so that
125 // it can be created properly during static init.
126 //
127 // Note: This table should be updated periodically. Check the [MS-LCID] Windows Language Code Identifier
128 // (LCID) Reference defined at https://msdn.microsoft.com/en-us/library/cc233965.aspx
129 //
130 // Microsoft is moving away from LCID in favor of locale name as of Vista. This table needs to be
131 // maintained for support of older Windows version.
132 // Update: Windows 7 (091130)
133 //
134 // Note: Microsoft assign a different LCID if a locale has a sorting variant. POSIX IDs below may contain
135 // @collation=XXX, but no other keywords are allowed (at least for now). When uprv_convertToLCID() is
136 // called from uloc_getLCID(), keywords other than collation are already removed. If we really need
137 // to support other keywords in this mapping data, we must update the implementation.
138 ////////////////////////////////////////////
139 */
140
141 // TODO: For Windows ideally this table would be a list of exceptions rather than a complete list as
142 // LocaleNameToLCID and LCIDToLocaleName provide 90% of these.
143
144 ILCID_POSIX_ELEMENT_ARRAY(0x0436, af, af_ZA)
145
ILCID_POSIX_SUBTABLE(ar)146 ILCID_POSIX_SUBTABLE(ar) {
147 {0x01, "ar"},
148 {0x3801, "ar_AE"},
149 {0x3c01, "ar_BH"},
150 {0x1401, "ar_DZ"},
151 {0x0c01, "ar_EG"},
152 {0x0801, "ar_IQ"},
153 {0x2c01, "ar_JO"},
154 {0x3401, "ar_KW"},
155 {0x3001, "ar_LB"},
156 {0x1001, "ar_LY"},
157 {0x1801, "ar_MA"},
158 {0x1801, "ar_MO"},
159 {0x2001, "ar_OM"},
160 {0x4001, "ar_QA"},
161 {0x0401, "ar_SA"},
162 {0x2801, "ar_SY"},
163 {0x1c01, "ar_TN"},
164 {0x2401, "ar_YE"}
165 };
166
167 ILCID_POSIX_ELEMENT_ARRAY(0x044d, as, as_IN)
168 ILCID_POSIX_ELEMENT_ARRAY(0x045e, am, am_ET)
169 ILCID_POSIX_ELEMENT_ARRAY(0x047a, arn,arn_CL)
170
ILCID_POSIX_SUBTABLE(az)171 ILCID_POSIX_SUBTABLE(az) {
172 {0x2c, "az"},
173 {0x082c, "az_Cyrl_AZ"}, /* Cyrillic based */
174 {0x742c, "az_Cyrl"}, /* Cyrillic based */
175 {0x042c, "az_Latn_AZ"}, /* Latin based */
176 {0x782c, "az_Latn"}, /* Latin based */
177 {0x042c, "az_AZ"} /* Latin based */
178 };
179
180 ILCID_POSIX_ELEMENT_ARRAY(0x046d, ba, ba_RU)
181 ILCID_POSIX_ELEMENT_ARRAY(0x0423, be, be_BY)
182
183 /*ILCID_POSIX_SUBTABLE(ber) {
184 {0x5f, "ber"},
185 {0x045f, "ber_Arab_DZ"},
186 {0x045f, "ber_Arab"},
187 {0x085f, "ber_Latn_DZ"},
188 {0x085f, "ber_Latn"}
189 };*/
190
191 ILCID_POSIX_ELEMENT_ARRAY(0x0402, bg, bg_BG)
192
ILCID_POSIX_SUBTABLE(bin)193 ILCID_POSIX_SUBTABLE(bin) {
194 {0x66, "bin"},
195 {0x0466, "bin_NG"}
196 };
197
ILCID_POSIX_SUBTABLE(bn)198 ILCID_POSIX_SUBTABLE(bn) {
199 {0x45, "bn"},
200 {0x0845, "bn_BD"},
201 {0x0445, "bn_IN"}
202 };
203
ILCID_POSIX_SUBTABLE(bo)204 ILCID_POSIX_SUBTABLE(bo) {
205 {0x51, "bo"},
206 {0x0851, "bo_BT"},
207 {0x0451, "bo_CN"},
208 {0x0c51, "dz_BT"}
209 };
210
211 ILCID_POSIX_ELEMENT_ARRAY(0x047e, br, br_FR)
212
ILCID_POSIX_SUBTABLE(ca)213 ILCID_POSIX_SUBTABLE(ca) {
214 {0x03, "ca"},
215 {0x0403, "ca_ES"},
216 {0x0803, "ca_ES_VALENCIA"}
217 };
218
219 ILCID_POSIX_ELEMENT_ARRAY(0x0483, co, co_FR)
220
ILCID_POSIX_SUBTABLE(chr)221 ILCID_POSIX_SUBTABLE(chr) {
222 {0x05c, "chr"},
223 {0x7c5c, "chr_Cher"},
224 {0x045c, "chr_Cher_US"},
225 {0x045c, "chr_US"}
226 };
227
228 // ICU has chosen different names for these.
ILCID_POSIX_SUBTABLE(ckb)229 ILCID_POSIX_SUBTABLE(ckb) {
230 {0x92, "ckb"},
231 {0x7c92, "ckb_Arab"},
232 {0x0492, "ckb_Arab_IQ"}
233 };
234
235 /* Declared as cs_CZ to get around compiler errors on z/OS, which defines cs as a function */
236 ILCID_POSIX_ELEMENT_ARRAY(0x0405, cs, cs_CZ)
237
238 ILCID_POSIX_ELEMENT_ARRAY(0x0452, cy, cy_GB)
239 ILCID_POSIX_ELEMENT_ARRAY(0x0406, da, da_DK)
240
241 // Windows doesn't know POSIX or BCP47 Unicode phonebook sort names
ILCID_POSIX_SUBTABLE(de)242 ILCID_POSIX_SUBTABLE(de) {
243 {0x07, "de"},
244 {0x0c07, "de_AT"},
245 {0x0807, "de_CH"},
246 {0x0407, "de_DE"},
247 {0x1407, "de_LI"},
248 {0x1007, "de_LU"},
249 {0x10407,"de_DE@collation=phonebook"}, /*This is really de_DE_PHONEBOOK on Windows*/
250 {0x10407,"de@collation=phonebook"} /*This is really de_DE_PHONEBOOK on Windows*/
251 };
252
253 ILCID_POSIX_ELEMENT_ARRAY(0x0465, dv, dv_MV)
254 ILCID_POSIX_ELEMENT_ARRAY(0x0408, el, el_GR)
255
256 // Windows uses an empty string for 'invariant'
ILCID_POSIX_SUBTABLE(en)257 ILCID_POSIX_SUBTABLE(en) {
258 {0x09, "en"},
259 {0x0c09, "en_AU"},
260 {0x2809, "en_BZ"},
261 {0x1009, "en_CA"},
262 {0x0809, "en_GB"},
263 {0x3c09, "en_HK"},
264 {0x3809, "en_ID"},
265 {0x1809, "en_IE"},
266 {0x4009, "en_IN"},
267 {0x2009, "en_JM"},
268 {0x4409, "en_MY"},
269 {0x1409, "en_NZ"},
270 {0x3409, "en_PH"},
271 {0x4809, "en_SG"},
272 {0x2C09, "en_TT"},
273 {0x0409, "en_US"},
274 {0x007f, "en_US_POSIX"}, /* duplicate for round-tripping */
275 {0x2409, "en_029"},
276 {0x1c09, "en_ZA"},
277 {0x3009, "en_ZW"},
278 {0x2409, "en_VI"}, /* Virgin Islands AKA Caribbean Islands (en_CB). On Windows8+ This is 0x1000 or dynamically assigned */
279 {0x0409, "en_AS"}, /* Alias for en_US. Leave last. On Windows8+ This is 0x1000 or dynamically assigned */
280 {0x0409, "en_GU"}, /* Alias for en_US. Leave last. On Windows8+ This is 0x1000 or dynamically assigned */
281 {0x0409, "en_MH"}, /* Alias for en_US. Leave last. On Windows8+ This is 0x1000 or dynamically assigned */
282 {0x0409, "en_MP"}, /* Alias for en_US. Leave last. On Windows8+ This is 0x1000 or dynamically assigned */
283 {0x0409, "en_UM"} /* Alias for en_US. Leave last. On Windows8+ This is 0x1000 or dynamically assigned */
284 };
285
ILCID_POSIX_SUBTABLE(en_US_POSIX)286 ILCID_POSIX_SUBTABLE(en_US_POSIX) {
287 {0x007f, "en_US_POSIX"} /* duplicate for roundtripping */
288 };
289
290 // Windows doesn't know POSIX or BCP47 Unicode traditional sort names
ILCID_POSIX_SUBTABLE(es)291 ILCID_POSIX_SUBTABLE(es) {
292 {0x0a, "es"},
293 {0x2c0a, "es_AR"},
294 {0x400a, "es_BO"},
295 {0x340a, "es_CL"},
296 {0x240a, "es_CO"},
297 {0x140a, "es_CR"},
298 {0x5c0a, "es_CU"},
299 {0x1c0a, "es_DO"},
300 {0x300a, "es_EC"},
301 {0x0c0a, "es_ES"}, /*Modern sort.*/
302 {0x100a, "es_GT"},
303 {0x480a, "es_HN"},
304 {0x080a, "es_MX"},
305 {0x4c0a, "es_NI"},
306 {0x180a, "es_PA"},
307 {0x280a, "es_PE"},
308 {0x500a, "es_PR"},
309 {0x3c0a, "es_PY"},
310 {0x440a, "es_SV"},
311 {0x540a, "es_US"},
312 {0x380a, "es_UY"},
313 {0x200a, "es_VE"},
314 {0x580a, "es_419"},
315 {0x040a, "es_ES@collation=traditional"},
316 {0x040a, "es@collation=traditional"} // Windows will treat this as es-ES@collation=traditional
317 };
318
319 ILCID_POSIX_ELEMENT_ARRAY(0x0425, et, et_EE)
320 ILCID_POSIX_ELEMENT_ARRAY(0x042d, eu, eu_ES)
321
322 /* ISO-639 doesn't distinguish between Persian and Dari.*/
ILCID_POSIX_SUBTABLE(fa)323 ILCID_POSIX_SUBTABLE(fa) {
324 {0x29, "fa"},
325 {0x0429, "fa_IR"}, /* Persian/Farsi (Iran) */
326 {0x048c, "fa_AF"} /* Persian/Dari (Afghanistan) */
327 };
328
329
330 /* duplicate for roundtripping */
ILCID_POSIX_SUBTABLE(fa_AF)331 ILCID_POSIX_SUBTABLE(fa_AF) {
332 {0x8c, "fa_AF"}, /* Persian/Dari (Afghanistan) */
333 {0x048c, "fa_AF"} /* Persian/Dari (Afghanistan) */
334 };
335
ILCID_POSIX_SUBTABLE(ff)336 ILCID_POSIX_SUBTABLE(ff) {
337 {0x67, "ff"},
338 {0x7c67, "ff_Latn"},
339 {0x0867, "ff_Latn_SN"},
340 {0x0467, "ff_NG"}
341 };
342
343 ILCID_POSIX_ELEMENT_ARRAY(0x040b, fi, fi_FI)
344 ILCID_POSIX_ELEMENT_ARRAY(0x0464, fil,fil_PH)
345 ILCID_POSIX_ELEMENT_ARRAY(0x0438, fo, fo_FO)
346
ILCID_POSIX_SUBTABLE(fr)347 ILCID_POSIX_SUBTABLE(fr) {
348 {0x0c, "fr"},
349 {0x080c, "fr_BE"},
350 {0x0c0c, "fr_CA"},
351 {0x240c, "fr_CD"},
352 {0x240c, "fr_CG"},
353 {0x100c, "fr_CH"},
354 {0x300c, "fr_CI"},
355 {0x2c0c, "fr_CM"},
356 {0x040c, "fr_FR"},
357 {0x3c0c, "fr_HT"},
358 {0x140c, "fr_LU"},
359 {0x380c, "fr_MA"},
360 {0x180c, "fr_MC"},
361 {0x340c, "fr_ML"},
362 {0x200c, "fr_RE"},
363 {0x280c, "fr_SN"},
364 {0xe40c, "fr_015"},
365 {0x1c0c, "fr_029"}
366 };
367
368 ILCID_POSIX_ELEMENT_ARRAY(0x0467, fuv, fuv_NG)
369
370 ILCID_POSIX_ELEMENT_ARRAY(0x0462, fy, fy_NL)
371
ILCID_POSIX_SUBTABLE(ga)372 ILCID_POSIX_SUBTABLE(ga) { /* Gaelic (Ireland) */
373 {0x3c, "ga"},
374 {0x083c, "ga_IE"},
375 {0x043c, "gd_GB"}
376 };
377
ILCID_POSIX_SUBTABLE(gd)378 ILCID_POSIX_SUBTABLE(gd) { /* Gaelic (Scotland) */
379 {0x91, "gd"},
380 {0x0491, "gd_GB"}
381 };
382
383 ILCID_POSIX_ELEMENT_ARRAY(0x0456, gl, gl_ES)
384 ILCID_POSIX_ELEMENT_ARRAY(0x0447, gu, gu_IN)
385 ILCID_POSIX_ELEMENT_ARRAY(0x0474, gn, gn_PY)
386 ILCID_POSIX_ELEMENT_ARRAY(0x0484, gsw,gsw_FR)
387
ILCID_POSIX_SUBTABLE(ha)388 ILCID_POSIX_SUBTABLE(ha) {
389 {0x68, "ha"},
390 {0x7c68, "ha_Latn"},
391 {0x0468, "ha_Latn_NG"},
392 };
393
394 ILCID_POSIX_ELEMENT_ARRAY(0x0475, haw,haw_US)
395 ILCID_POSIX_ELEMENT_ARRAY(0x040d, he, he_IL)
396 ILCID_POSIX_ELEMENT_ARRAY(0x0439, hi, hi_IN)
397
398 /* This LCID is really four different locales.*/
ILCID_POSIX_SUBTABLE(hr)399 ILCID_POSIX_SUBTABLE(hr) {
400 {0x1a, "hr"},
401 {0x141a, "bs_Latn_BA"}, /* Bosnian, Bosnia and Herzegovina */
402 {0x681a, "bs_Latn"}, /* Bosnian, Bosnia and Herzegovina */
403 {0x141a, "bs_BA"}, /* Bosnian, Bosnia and Herzegovina */
404 {0x781a, "bs"}, /* Bosnian */
405 {0x201a, "bs_Cyrl_BA"}, /* Bosnian, Bosnia and Herzegovina */
406 {0x641a, "bs_Cyrl"}, /* Bosnian, Bosnia and Herzegovina */
407 {0x101a, "hr_BA"}, /* Croatian in Bosnia */
408 {0x041a, "hr_HR"}, /* Croatian*/
409 {0x2c1a, "sr_Latn_ME"},
410 {0x241a, "sr_Latn_RS"},
411 {0x181a, "sr_Latn_BA"}, /* Serbo-Croatian in Bosnia */
412 {0x081a, "sr_Latn_CS"}, /* Serbo-Croatian*/
413 {0x701a, "sr_Latn"}, /* It's 0x1a or 0x081a, pick one to make the test program happy. */
414 {0x1c1a, "sr_Cyrl_BA"}, /* Serbo-Croatian in Bosnia */
415 {0x0c1a, "sr_Cyrl_CS"}, /* Serbian*/
416 {0x301a, "sr_Cyrl_ME"},
417 {0x281a, "sr_Cyrl_RS"},
418 {0x6c1a, "sr_Cyrl"}, /* It's 0x1a or 0x0c1a, pick one to make the test program happy. */
419 {0x7c1a, "sr"} /* In CLDR sr is sr_Cyrl. */
420 };
421
ILCID_POSIX_SUBTABLE(hsb)422 ILCID_POSIX_SUBTABLE(hsb) {
423 {0x2E, "hsb"},
424 {0x042E, "hsb_DE"},
425 {0x082E, "dsb_DE"},
426 {0x7C2E, "dsb"},
427 };
428
429 ILCID_POSIX_ELEMENT_ARRAY(0x040e, hu, hu_HU)
430 ILCID_POSIX_ELEMENT_ARRAY(0x042b, hy, hy_AM)
431
ILCID_POSIX_SUBTABLE(ibb)432 ILCID_POSIX_SUBTABLE(ibb) {
433 {0x69, "ibb"},
434 {0x0469, "ibb_NG"}
435 };
436
437 ILCID_POSIX_ELEMENT_ARRAY(0x0421, id, id_ID)
438 ILCID_POSIX_ELEMENT_ARRAY(0x0470, ig, ig_NG)
439 ILCID_POSIX_ELEMENT_ARRAY(0x0478, ii, ii_CN)
440 ILCID_POSIX_ELEMENT_ARRAY(0x040f, is, is_IS)
441
ILCID_POSIX_SUBTABLE(it)442 ILCID_POSIX_SUBTABLE(it) {
443 {0x10, "it"},
444 {0x0810, "it_CH"},
445 {0x0410, "it_IT"}
446 };
447
ILCID_POSIX_SUBTABLE(iu)448 ILCID_POSIX_SUBTABLE(iu) {
449 {0x5d, "iu"},
450 {0x045d, "iu_Cans_CA"},
451 {0x785d, "iu_Cans"},
452 {0x085d, "iu_Latn_CA"},
453 {0x7c5d, "iu_Latn"}
454 };
455
456 ILCID_POSIX_ELEMENT_ARRAY(0x040d, iw, iw_IL) /*Left in for compatibility*/
457 ILCID_POSIX_ELEMENT_ARRAY(0x0411, ja, ja_JP)
458 ILCID_POSIX_ELEMENT_ARRAY(0x0437, ka, ka_GE)
459 ILCID_POSIX_ELEMENT_ARRAY(0x043f, kk, kk_KZ)
460 ILCID_POSIX_ELEMENT_ARRAY(0x046f, kl, kl_GL)
461 ILCID_POSIX_ELEMENT_ARRAY(0x0453, km, km_KH)
462 ILCID_POSIX_ELEMENT_ARRAY(0x044b, kn, kn_IN)
463
ILCID_POSIX_SUBTABLE(ko)464 ILCID_POSIX_SUBTABLE(ko) {
465 {0x12, "ko"},
466 {0x0812, "ko_KP"},
467 {0x0412, "ko_KR"}
468 };
469
470 ILCID_POSIX_ELEMENT_ARRAY(0x0457, kok, kok_IN)
471 ILCID_POSIX_ELEMENT_ARRAY(0x0471, kr, kr_NG)
472
ILCID_POSIX_SUBTABLE(ks)473 ILCID_POSIX_SUBTABLE(ks) { /* We could add PK and CN too */
474 {0x60, "ks"},
475 {0x0460, "ks_Arab_IN"},
476 {0x0860, "ks_Deva_IN"}
477 };
478
479 ILCID_POSIX_ELEMENT_ARRAY(0x0440, ky, ky_KG) /* Kyrgyz is spoken in Kyrgyzstan */
480
ILCID_POSIX_SUBTABLE(la)481 ILCID_POSIX_SUBTABLE(la) {
482 {0x76, "la"},
483 {0x0476, "la_001"},
484 {0x0476, "la_IT"} /*Left in for compatibility*/
485 };
486
487 ILCID_POSIX_ELEMENT_ARRAY(0x046e, lb, lb_LU)
488 ILCID_POSIX_ELEMENT_ARRAY(0x0454, lo, lo_LA)
489 ILCID_POSIX_ELEMENT_ARRAY(0x0427, lt, lt_LT)
490 ILCID_POSIX_ELEMENT_ARRAY(0x0426, lv, lv_LV)
491 ILCID_POSIX_ELEMENT_ARRAY(0x0481, mi, mi_NZ)
492 ILCID_POSIX_ELEMENT_ARRAY(0x042f, mk, mk_MK)
493 ILCID_POSIX_ELEMENT_ARRAY(0x044c, ml, ml_IN)
494
ILCID_POSIX_SUBTABLE(mn)495 ILCID_POSIX_SUBTABLE(mn) {
496 {0x50, "mn"},
497 {0x0450, "mn_MN"},
498 {0x7c50, "mn_Mong"},
499 {0x0850, "mn_Mong_CN"},
500 {0x0850, "mn_CN"},
501 {0x7850, "mn_Cyrl"},
502 {0x0c50, "mn_Mong_MN"}
503 };
504
505 ILCID_POSIX_ELEMENT_ARRAY(0x0458, mni,mni_IN)
506 ILCID_POSIX_ELEMENT_ARRAY(0x047c, moh,moh_CA)
507 ILCID_POSIX_ELEMENT_ARRAY(0x044e, mr, mr_IN)
508
ILCID_POSIX_SUBTABLE(ms)509 ILCID_POSIX_SUBTABLE(ms) {
510 {0x3e, "ms"},
511 {0x083e, "ms_BN"}, /* Brunei Darussalam*/
512 {0x043e, "ms_MY"} /* Malaysia*/
513 };
514
515 ILCID_POSIX_ELEMENT_ARRAY(0x043a, mt, mt_MT)
516 ILCID_POSIX_ELEMENT_ARRAY(0x0455, my, my_MM)
517
ILCID_POSIX_SUBTABLE(ne)518 ILCID_POSIX_SUBTABLE(ne) {
519 {0x61, "ne"},
520 {0x0861, "ne_IN"}, /* India*/
521 {0x0461, "ne_NP"} /* Nepal*/
522 };
523
ILCID_POSIX_SUBTABLE(nl)524 ILCID_POSIX_SUBTABLE(nl) {
525 {0x13, "nl"},
526 {0x0813, "nl_BE"},
527 {0x0413, "nl_NL"}
528 };
529
530 /* The "no" locale split into nb and nn. By default in ICU, "no" is nb.*/
531 // TODO: Not all of these are needed on Windows, but I don't know how ICU treats preferred ones here.
ILCID_POSIX_SUBTABLE(no)532 ILCID_POSIX_SUBTABLE(no) {
533 {0x14, "no"}, /* really nb_NO - actually Windows differentiates between neutral (no region) and specific (with region) */
534 {0x7c14, "nb"}, /* really nb */
535 {0x0414, "nb_NO"}, /* really nb_NO. Keep first in the 414 list. */
536 {0x0414, "no_NO"}, /* really nb_NO */
537 {0x0814, "nn_NO"}, /* really nn_NO. Keep first in the 814 list. */
538 {0x7814, "nn"}, /* It's 0x14 or 0x814, pick one to make the test program happy. */
539 {0x0814, "no_NO_NY"}/* really nn_NO */
540 };
541
542 ILCID_POSIX_ELEMENT_ARRAY(0x046c, nso,nso_ZA) /* TODO: Verify the ISO-639 code */
543 ILCID_POSIX_ELEMENT_ARRAY(0x0482, oc, oc_FR)
544
ILCID_POSIX_SUBTABLE(om)545 ILCID_POSIX_SUBTABLE(om) { /* TODO: Verify the country */
546 {0x72, "om"},
547 {0x0472, "om_ET"},
548 {0x0472, "gaz_ET"}
549 };
550
551 /* Declared as or_IN to get around compiler errors*/
ILCID_POSIX_SUBTABLE(or_IN)552 ILCID_POSIX_SUBTABLE(or_IN) {
553 {0x48, "or"},
554 {0x0448, "or_IN"},
555 };
556
ILCID_POSIX_SUBTABLE(pa)557 ILCID_POSIX_SUBTABLE(pa) {
558 {0x46, "pa"},
559 {0x0446, "pa_IN"},
560 {0x0846, "pa_Arab_PK"},
561 {0x0846, "pa_PK"}
562 };
563
ILCID_POSIX_SUBTABLE(pap)564 ILCID_POSIX_SUBTABLE(pap) {
565 {0x79, "pap"},
566 {0x0479, "pap_029"},
567 {0x0479, "pap_AN"} /*Left in for compatibility*/
568 };
569
570 ILCID_POSIX_ELEMENT_ARRAY(0x0415, pl, pl_PL)
571 ILCID_POSIX_ELEMENT_ARRAY(0x0463, ps, ps_AF)
572
ILCID_POSIX_SUBTABLE(pt)573 ILCID_POSIX_SUBTABLE(pt) {
574 {0x16, "pt"},
575 {0x0416, "pt_BR"},
576 {0x0816, "pt_PT"}
577 };
578
ILCID_POSIX_SUBTABLE(qu)579 ILCID_POSIX_SUBTABLE(qu) {
580 {0x6b, "qu"},
581 {0x046b, "qu_BO"},
582 {0x086b, "qu_EC"},
583 {0x0C6b, "qu_PE"},
584 {0x046b, "quz_BO"},
585 {0x086b, "quz_EC"},
586 {0x0C6b, "quz_PE"}
587 };
588
ILCID_POSIX_SUBTABLE(quc)589 ILCID_POSIX_SUBTABLE(quc) {
590 {0x93, "quc"},
591 {0x0493, "quc_CO"},
592 /*
593 "quc_Latn_GT" is an exceptional case. Language ID of "quc"
594 is 0x93, but LCID of "quc_Latn_GT" is 0x486, which should be
595 under the group of "qut". "qut" is a retired ISO 639-3 language
596 code for West Central Quiche, and merged to "quc".
597 It looks Windows previously reserved "qut" for K'iche', but,
598 decided to use "quc" when adding a locale for K'iche' (Guatemala).
599
600 This data structure used here assumes language ID bits in
601 LCID is unique for alphabetic language code. But this is not true
602 for "quc_Latn_GT". If we don't have the data below, LCID look up
603 by alphabetic locale ID (POSIX) will fail. The same entry is found
604 under "qut" below, which is required for reverse look up.
605 */
606 {0x0486, "quc_Latn_GT"}
607 };
608
ILCID_POSIX_SUBTABLE(qut)609 ILCID_POSIX_SUBTABLE(qut) {
610 {0x86, "qut"},
611 {0x0486, "qut_GT"},
612 /*
613 See the note in "quc" above.
614 */
615 {0x0486, "quc_Latn_GT"}
616 };
617
618 ILCID_POSIX_ELEMENT_ARRAY(0x0417, rm, rm_CH)
619
ILCID_POSIX_SUBTABLE(ro)620 ILCID_POSIX_SUBTABLE(ro) {
621 {0x18, "ro"},
622 {0x0418, "ro_RO"},
623 {0x0818, "ro_MD"}
624 };
625
626 // TODO: This is almost certainly 'wrong'. 0 in Windows is a synonym for LOCALE_USER_DEFAULT.
627 // More likely this is a similar concept to the Windows 0x7f Invariant locale ""
628 // (Except that it's not invariant in ICU)
ILCID_POSIX_SUBTABLE(root)629 ILCID_POSIX_SUBTABLE(root) {
630 {0x00, "root"}
631 };
632
ILCID_POSIX_SUBTABLE(ru)633 ILCID_POSIX_SUBTABLE(ru) {
634 {0x19, "ru"},
635 {0x0419, "ru_RU"},
636 {0x0819, "ru_MD"}
637 };
638
639 ILCID_POSIX_ELEMENT_ARRAY(0x0487, rw, rw_RW)
640 ILCID_POSIX_ELEMENT_ARRAY(0x044f, sa, sa_IN)
641 ILCID_POSIX_ELEMENT_ARRAY(0x0485, sah,sah_RU)
642
ILCID_POSIX_SUBTABLE(sd)643 ILCID_POSIX_SUBTABLE(sd) {
644 {0x59, "sd"},
645 {0x0459, "sd_Deva_IN"},
646 {0x0459, "sd_IN"},
647 {0x0859, "sd_Arab_PK"},
648 {0x0859, "sd_PK"},
649 {0x7c59, "sd_Arab"}
650 };
651
ILCID_POSIX_SUBTABLE(se)652 ILCID_POSIX_SUBTABLE(se) {
653 {0x3b, "se"},
654 {0x0c3b, "se_FI"},
655 {0x043b, "se_NO"},
656 {0x083b, "se_SE"},
657 {0x783b, "sma"},
658 {0x183b, "sma_NO"},
659 {0x1c3b, "sma_SE"},
660 {0x7c3b, "smj"},
661 {0x703b, "smn"},
662 {0x743b, "sms"},
663 {0x103b, "smj_NO"},
664 {0x143b, "smj_SE"},
665 {0x243b, "smn_FI"},
666 {0x203b, "sms_FI"},
667 };
668
669 ILCID_POSIX_ELEMENT_ARRAY(0x045b, si, si_LK)
670 ILCID_POSIX_ELEMENT_ARRAY(0x041b, sk, sk_SK)
671 ILCID_POSIX_ELEMENT_ARRAY(0x0424, sl, sl_SI)
672
ILCID_POSIX_SUBTABLE(so)673 ILCID_POSIX_SUBTABLE(so) {
674 {0x77, "so"},
675 {0x0477, "so_SO"}
676 };
677
678 ILCID_POSIX_ELEMENT_ARRAY(0x041c, sq, sq_AL)
679 ILCID_POSIX_ELEMENT_ARRAY(0x0430, st, st_ZA)
680
ILCID_POSIX_SUBTABLE(sv)681 ILCID_POSIX_SUBTABLE(sv) {
682 {0x1d, "sv"},
683 {0x081d, "sv_FI"},
684 {0x041d, "sv_SE"}
685 };
686
687 ILCID_POSIX_ELEMENT_ARRAY(0x0441, sw, sw_KE)
688 ILCID_POSIX_ELEMENT_ARRAY(0x045A, syr, syr_SY)
689
ILCID_POSIX_SUBTABLE(ta)690 ILCID_POSIX_SUBTABLE(ta) {
691 {0x49, "ta"},
692 {0x0449, "ta_IN"},
693 {0x0849, "ta_LK"}
694 };
695
696 ILCID_POSIX_ELEMENT_ARRAY(0x044a, te, te_IN)
697
698 /* Cyrillic based by default */
ILCID_POSIX_SUBTABLE(tg)699 ILCID_POSIX_SUBTABLE(tg) {
700 {0x28, "tg"},
701 {0x7c28, "tg_Cyrl"},
702 {0x0428, "tg_Cyrl_TJ"}
703 };
704
705 ILCID_POSIX_ELEMENT_ARRAY(0x041e, th, th_TH)
706
ILCID_POSIX_SUBTABLE(ti)707 ILCID_POSIX_SUBTABLE(ti) {
708 {0x73, "ti"},
709 {0x0873, "ti_ER"},
710 {0x0473, "ti_ET"}
711 };
712
713 ILCID_POSIX_ELEMENT_ARRAY(0x0442, tk, tk_TM)
714
ILCID_POSIX_SUBTABLE(tn)715 ILCID_POSIX_SUBTABLE(tn) {
716 {0x32, "tn"},
717 {0x0832, "tn_BW"},
718 {0x0432, "tn_ZA"}
719 };
720
721 ILCID_POSIX_ELEMENT_ARRAY(0x041f, tr, tr_TR)
722 ILCID_POSIX_ELEMENT_ARRAY(0x0431, ts, ts_ZA)
723 ILCID_POSIX_ELEMENT_ARRAY(0x0444, tt, tt_RU)
724
ILCID_POSIX_SUBTABLE(tzm)725 ILCID_POSIX_SUBTABLE(tzm) {
726 {0x5f, "tzm"},
727 {0x7c5f, "tzm_Latn"},
728 {0x085f, "tzm_Latn_DZ"},
729 {0x105f, "tzm_Tfng_MA"},
730 {0x045f, "tzm_Arab_MA"},
731 {0x045f, "tmz"}
732 };
733
ILCID_POSIX_SUBTABLE(ug)734 ILCID_POSIX_SUBTABLE(ug) {
735 {0x80, "ug"},
736 {0x0480, "ug_CN"},
737 {0x0480, "ug_Arab_CN"}
738 };
739
740 ILCID_POSIX_ELEMENT_ARRAY(0x0422, uk, uk_UA)
741
ILCID_POSIX_SUBTABLE(ur)742 ILCID_POSIX_SUBTABLE(ur) {
743 {0x20, "ur"},
744 {0x0820, "ur_IN"},
745 {0x0420, "ur_PK"}
746 };
747
ILCID_POSIX_SUBTABLE(uz)748 ILCID_POSIX_SUBTABLE(uz) {
749 {0x43, "uz"},
750 {0x0843, "uz_Cyrl_UZ"}, /* Cyrillic based */
751 {0x7843, "uz_Cyrl"}, /* Cyrillic based */
752 {0x0843, "uz_UZ"}, /* Cyrillic based */
753 {0x0443, "uz_Latn_UZ"}, /* Latin based */
754 {0x7c43, "uz_Latn"} /* Latin based */
755 };
756
ILCID_POSIX_SUBTABLE(ve)757 ILCID_POSIX_SUBTABLE(ve) { /* TODO: Verify the country */
758 {0x33, "ve"},
759 {0x0433, "ve_ZA"},
760 {0x0433, "ven_ZA"}
761 };
762
763 ILCID_POSIX_ELEMENT_ARRAY(0x042a, vi, vi_VN)
764 ILCID_POSIX_ELEMENT_ARRAY(0x0488, wo, wo_SN)
765 ILCID_POSIX_ELEMENT_ARRAY(0x0434, xh, xh_ZA)
766
ILCID_POSIX_SUBTABLE(yi)767 ILCID_POSIX_SUBTABLE(yi) {
768 {0x003d, "yi"},
769 {0x043d, "yi_001"}
770 };
771
772 ILCID_POSIX_ELEMENT_ARRAY(0x046a, yo, yo_NG)
773
774 // Windows & ICU tend to different names for some of these
775 // TODO: Windows probably does not need all of these entries, but I don't know how the precedence works.
ILCID_POSIX_SUBTABLE(zh)776 ILCID_POSIX_SUBTABLE(zh) {
777 {0x0004, "zh_Hans"},
778 {0x7804, "zh"},
779 {0x0804, "zh_CN"},
780 {0x0804, "zh_Hans_CN"},
781 {0x0c04, "zh_Hant_HK"},
782 {0x0c04, "zh_HK"},
783 {0x1404, "zh_Hant_MO"},
784 {0x1404, "zh_MO"},
785 {0x1004, "zh_Hans_SG"},
786 {0x1004, "zh_SG"},
787 {0x0404, "zh_Hant_TW"},
788 {0x7c04, "zh_Hant"},
789 {0x0404, "zh_TW"},
790 {0x30404,"zh_Hant_TW"}, /* Bopomofo order */
791 {0x30404,"zh_TW"}, /* Bopomofo order */
792 {0x20004,"zh@collation=stroke"},
793 {0x20404,"zh_Hant@collation=stroke"},
794 {0x20404,"zh_Hant_TW@collation=stroke"},
795 {0x20404,"zh_TW@collation=stroke"},
796 {0x20804,"zh_Hans@collation=stroke"},
797 {0x20804,"zh_Hans_CN@collation=stroke"},
798 {0x20804,"zh_CN@collation=stroke"}
799 // TODO: Alternate collations for other LCIDs are missing, eg: 0x50804
800 };
801
802 ILCID_POSIX_ELEMENT_ARRAY(0x0435, zu, zu_ZA)
803
804 /* This must be static and grouped by LCID. */
805 static const ILcidPosixMap gPosixIDmap[] = {
806 ILCID_POSIX_MAP(af), /* af Afrikaans 0x36 */
807 ILCID_POSIX_MAP(am), /* am Amharic 0x5e */
808 ILCID_POSIX_MAP(ar), /* ar Arabic 0x01 */
809 ILCID_POSIX_MAP(arn), /* arn Araucanian/Mapudungun 0x7a */
810 ILCID_POSIX_MAP(as), /* as Assamese 0x4d */
811 ILCID_POSIX_MAP(az), /* az Azerbaijani 0x2c */
812 ILCID_POSIX_MAP(ba), /* ba Bashkir 0x6d */
813 ILCID_POSIX_MAP(be), /* be Belarusian 0x23 */
814 /* ILCID_POSIX_MAP(ber), ber Berber/Tamazight 0x5f */
815 ILCID_POSIX_MAP(bg), /* bg Bulgarian 0x02 */
816 ILCID_POSIX_MAP(bin), /* bin Edo 0x66 */
817 ILCID_POSIX_MAP(bn), /* bn Bengali; Bangla 0x45 */
818 ILCID_POSIX_MAP(bo), /* bo Tibetan 0x51 */
819 ILCID_POSIX_MAP(br), /* br Breton 0x7e */
820 ILCID_POSIX_MAP(ca), /* ca Catalan 0x03 */
821 ILCID_POSIX_MAP(chr), /* chr Cherokee 0x5c */
822 ILCID_POSIX_MAP(ckb), /* ckb Sorani (Central Kurdish) 0x92 */
823 ILCID_POSIX_MAP(co), /* co Corsican 0x83 */
824 ILCID_POSIX_MAP(cs), /* cs Czech 0x05 */
825 ILCID_POSIX_MAP(cy), /* cy Welsh 0x52 */
826 ILCID_POSIX_MAP(da), /* da Danish 0x06 */
827 ILCID_POSIX_MAP(de), /* de German 0x07 */
828 ILCID_POSIX_MAP(dv), /* dv Divehi 0x65 */
829 ILCID_POSIX_MAP(el), /* el Greek 0x08 */
830 ILCID_POSIX_MAP(en), /* en English 0x09 */
831 ILCID_POSIX_MAP(en_US_POSIX), /* invariant 0x7f */
832 ILCID_POSIX_MAP(es), /* es Spanish 0x0a */
833 ILCID_POSIX_MAP(et), /* et Estonian 0x25 */
834 ILCID_POSIX_MAP(eu), /* eu Basque 0x2d */
835 ILCID_POSIX_MAP(fa), /* fa Persian/Farsi 0x29 */
836 ILCID_POSIX_MAP(fa_AF), /* fa Persian/Dari 0x8c */
837 ILCID_POSIX_MAP(ff), /* ff Fula 0x67 */
838 ILCID_POSIX_MAP(fi), /* fi Finnish 0x0b */
839 ILCID_POSIX_MAP(fil), /* fil Filipino 0x64 */
840 ILCID_POSIX_MAP(fo), /* fo Faroese 0x38 */
841 ILCID_POSIX_MAP(fr), /* fr French 0x0c */
842 ILCID_POSIX_MAP(fuv), /* fuv Fulfulde - Nigeria 0x67 */
843 ILCID_POSIX_MAP(fy), /* fy Frisian 0x62 */
844 ILCID_POSIX_MAP(ga), /* * Gaelic (Ireland,Scotland) 0x3c */
845 ILCID_POSIX_MAP(gd), /* gd Gaelic (United Kingdom) 0x91 */
846 ILCID_POSIX_MAP(gl), /* gl Galician 0x56 */
847 ILCID_POSIX_MAP(gn), /* gn Guarani 0x74 */
848 ILCID_POSIX_MAP(gsw), /* gsw Alemanic/Alsatian/Swiss German 0x84 */
849 ILCID_POSIX_MAP(gu), /* gu Gujarati 0x47 */
850 ILCID_POSIX_MAP(ha), /* ha Hausa 0x68 */
851 ILCID_POSIX_MAP(haw), /* haw Hawaiian 0x75 */
852 ILCID_POSIX_MAP(he), /* he Hebrew (formerly iw) 0x0d */
853 ILCID_POSIX_MAP(hi), /* hi Hindi 0x39 */
854 ILCID_POSIX_MAP(hr), /* * Croatian and others 0x1a */
855 ILCID_POSIX_MAP(hsb), /* hsb Upper Sorbian 0x2e */
856 ILCID_POSIX_MAP(hu), /* hu Hungarian 0x0e */
857 ILCID_POSIX_MAP(hy), /* hy Armenian 0x2b */
858 ILCID_POSIX_MAP(ibb), /* ibb Ibibio - Nigeria 0x69 */
859 ILCID_POSIX_MAP(id), /* id Indonesian (formerly in) 0x21 */
860 ILCID_POSIX_MAP(ig), /* ig Igbo 0x70 */
861 ILCID_POSIX_MAP(ii), /* ii Sichuan Yi 0x78 */
862 ILCID_POSIX_MAP(is), /* is Icelandic 0x0f */
863 ILCID_POSIX_MAP(it), /* it Italian 0x10 */
864 ILCID_POSIX_MAP(iu), /* iu Inuktitut 0x5d */
865 ILCID_POSIX_MAP(iw), /* iw Hebrew 0x0d */
866 ILCID_POSIX_MAP(ja), /* ja Japanese 0x11 */
867 ILCID_POSIX_MAP(ka), /* ka Georgian 0x37 */
868 ILCID_POSIX_MAP(kk), /* kk Kazakh 0x3f */
869 ILCID_POSIX_MAP(kl), /* kl Kalaallisut 0x6f */
870 ILCID_POSIX_MAP(km), /* km Khmer 0x53 */
871 ILCID_POSIX_MAP(kn), /* kn Kannada 0x4b */
872 ILCID_POSIX_MAP(ko), /* ko Korean 0x12 */
873 ILCID_POSIX_MAP(kok), /* kok Konkani 0x57 */
874 ILCID_POSIX_MAP(kr), /* kr Kanuri 0x71 */
875 ILCID_POSIX_MAP(ks), /* ks Kashmiri 0x60 */
876 ILCID_POSIX_MAP(ky), /* ky Kyrgyz 0x40 */
877 ILCID_POSIX_MAP(lb), /* lb Luxembourgish 0x6e */
878 ILCID_POSIX_MAP(la), /* la Latin 0x76 */
879 ILCID_POSIX_MAP(lo), /* lo Lao 0x54 */
880 ILCID_POSIX_MAP(lt), /* lt Lithuanian 0x27 */
881 ILCID_POSIX_MAP(lv), /* lv Latvian, Lettish 0x26 */
882 ILCID_POSIX_MAP(mi), /* mi Maori 0x81 */
883 ILCID_POSIX_MAP(mk), /* mk Macedonian 0x2f */
884 ILCID_POSIX_MAP(ml), /* ml Malayalam 0x4c */
885 ILCID_POSIX_MAP(mn), /* mn Mongolian 0x50 */
886 ILCID_POSIX_MAP(mni), /* mni Manipuri 0x58 */
887 ILCID_POSIX_MAP(moh), /* moh Mohawk 0x7c */
888 ILCID_POSIX_MAP(mr), /* mr Marathi 0x4e */
889 ILCID_POSIX_MAP(ms), /* ms Malay 0x3e */
890 ILCID_POSIX_MAP(mt), /* mt Maltese 0x3a */
891 ILCID_POSIX_MAP(my), /* my Burmese 0x55 */
892 /* ILCID_POSIX_MAP(nb), // no Norwegian 0x14 */
893 ILCID_POSIX_MAP(ne), /* ne Nepali 0x61 */
894 ILCID_POSIX_MAP(nl), /* nl Dutch 0x13 */
895 /* ILCID_POSIX_MAP(nn), // no Norwegian 0x14 */
896 ILCID_POSIX_MAP(no), /* * Norwegian 0x14 */
897 ILCID_POSIX_MAP(nso), /* nso Sotho, Northern (Sepedi dialect) 0x6c */
898 ILCID_POSIX_MAP(oc), /* oc Occitan 0x82 */
899 ILCID_POSIX_MAP(om), /* om Oromo 0x72 */
900 ILCID_POSIX_MAP(or_IN), /* or Oriya 0x48 */
901 ILCID_POSIX_MAP(pa), /* pa Punjabi 0x46 */
902 ILCID_POSIX_MAP(pap), /* pap Papiamentu 0x79 */
903 ILCID_POSIX_MAP(pl), /* pl Polish 0x15 */
904 ILCID_POSIX_MAP(ps), /* ps Pashto 0x63 */
905 ILCID_POSIX_MAP(pt), /* pt Portuguese 0x16 */
906 ILCID_POSIX_MAP(qu), /* qu Quechua 0x6B */
907 ILCID_POSIX_MAP(quc), /* quc K'iche 0x93 */
908 ILCID_POSIX_MAP(qut), /* qut K'iche 0x86 */
909 ILCID_POSIX_MAP(rm), /* rm Raeto-Romance/Romansh 0x17 */
910 ILCID_POSIX_MAP(ro), /* ro Romanian 0x18 */
911 ILCID_POSIX_MAP(root), /* root 0x00 */
912 ILCID_POSIX_MAP(ru), /* ru Russian 0x19 */
913 ILCID_POSIX_MAP(rw), /* rw Kinyarwanda 0x87 */
914 ILCID_POSIX_MAP(sa), /* sa Sanskrit 0x4f */
915 ILCID_POSIX_MAP(sah), /* sah Yakut 0x85 */
916 ILCID_POSIX_MAP(sd), /* sd Sindhi 0x59 */
917 ILCID_POSIX_MAP(se), /* se Sami 0x3b */
918 /* ILCID_POSIX_MAP(sh), // sh Serbo-Croatian 0x1a */
919 ILCID_POSIX_MAP(si), /* si Sinhalese 0x5b */
920 ILCID_POSIX_MAP(sk), /* sk Slovak 0x1b */
921 ILCID_POSIX_MAP(sl), /* sl Slovenian 0x24 */
922 ILCID_POSIX_MAP(so), /* so Somali 0x77 */
923 ILCID_POSIX_MAP(sq), /* sq Albanian 0x1c */
924 /* ILCID_POSIX_MAP(sr), // sr Serbian 0x1a */
925 ILCID_POSIX_MAP(st), /* st Sutu 0x30 */
926 ILCID_POSIX_MAP(sv), /* sv Swedish 0x1d */
927 ILCID_POSIX_MAP(sw), /* sw Swahili 0x41 */
928 ILCID_POSIX_MAP(syr), /* syr Syriac 0x5A */
929 ILCID_POSIX_MAP(ta), /* ta Tamil 0x49 */
930 ILCID_POSIX_MAP(te), /* te Telugu 0x4a */
931 ILCID_POSIX_MAP(tg), /* tg Tajik 0x28 */
932 ILCID_POSIX_MAP(th), /* th Thai 0x1e */
933 ILCID_POSIX_MAP(ti), /* ti Tigrigna 0x73 */
934 ILCID_POSIX_MAP(tk), /* tk Turkmen 0x42 */
935 ILCID_POSIX_MAP(tn), /* tn Tswana 0x32 */
936 ILCID_POSIX_MAP(tr), /* tr Turkish 0x1f */
937 ILCID_POSIX_MAP(ts), /* ts Tsonga 0x31 */
938 ILCID_POSIX_MAP(tt), /* tt Tatar 0x44 */
939 ILCID_POSIX_MAP(tzm), /* tzm Tamazight 0x5f */
940 ILCID_POSIX_MAP(ug), /* ug Uighur 0x80 */
941 ILCID_POSIX_MAP(uk), /* uk Ukrainian 0x22 */
942 ILCID_POSIX_MAP(ur), /* ur Urdu 0x20 */
943 ILCID_POSIX_MAP(uz), /* uz Uzbek 0x43 */
944 ILCID_POSIX_MAP(ve), /* ve Venda 0x33 */
945 ILCID_POSIX_MAP(vi), /* vi Vietnamese 0x2a */
946 ILCID_POSIX_MAP(wo), /* wo Wolof 0x88 */
947 ILCID_POSIX_MAP(xh), /* xh Xhosa 0x34 */
948 ILCID_POSIX_MAP(yi), /* yi Yiddish 0x3d */
949 ILCID_POSIX_MAP(yo), /* yo Yoruba 0x6a */
950 ILCID_POSIX_MAP(zh), /* zh Chinese 0x04 */
951 ILCID_POSIX_MAP(zu), /* zu Zulu 0x35 */
952 };
953
954 static const uint32_t gLocaleCount = UPRV_LENGTHOF(gPosixIDmap);
955
956 /**
957 * Do not call this function. It is called by hostID.
958 * The function is not private because this struct must stay as a C struct,
959 * and this is an internal class.
960 */
961 static int32_t
idCmp(const char * id1,const char * id2)962 idCmp(const char* id1, const char* id2)
963 {
964 int32_t diffIdx = 0;
965 while (*id1 == *id2 && *id1 != 0) {
966 diffIdx++;
967 id1++;
968 id2++;
969 }
970 return diffIdx;
971 }
972
973 /**
974 * Searches for a Windows LCID
975 *
976 * @param posixid the Posix style locale id.
977 * @param status gets set to U_ILLEGAL_ARGUMENT_ERROR when the Posix ID has
978 * no equivalent Windows LCID.
979 * @return the LCID
980 */
981 static uint32_t
getHostID(const ILcidPosixMap * this_0,const char * posixID,UErrorCode * status)982 getHostID(const ILcidPosixMap *this_0, const char* posixID, UErrorCode* status)
983 {
984 int32_t bestIdx = 0;
985 int32_t bestIdxDiff = 0;
986 int32_t posixIDlen = (int32_t)uprv_strlen(posixID);
987 uint32_t idx;
988
989 for (idx = 0; idx < this_0->numRegions; idx++ ) {
990 int32_t sameChars = idCmp(posixID, this_0->regionMaps[idx].posixID);
991 if (sameChars > bestIdxDiff && this_0->regionMaps[idx].posixID[sameChars] == 0) {
992 if (posixIDlen == sameChars) {
993 /* Exact match */
994 return this_0->regionMaps[idx].hostID;
995 }
996 bestIdxDiff = sameChars;
997 bestIdx = idx;
998 }
999 }
1000 /* We asked for something unusual, like en_ZZ, and we try to return the number for the same language. */
1001 /* We also have to make sure that sid and si and similar string subsets don't match. */
1002 if ((posixID[bestIdxDiff] == '_' || posixID[bestIdxDiff] == '@')
1003 && this_0->regionMaps[bestIdx].posixID[bestIdxDiff] == 0)
1004 {
1005 *status = U_USING_FALLBACK_WARNING;
1006 return this_0->regionMaps[bestIdx].hostID;
1007 }
1008
1009 /*no match found */
1010 *status = U_ILLEGAL_ARGUMENT_ERROR;
1011 return this_0->regionMaps->hostID;
1012 }
1013
1014 static const char*
getPosixID(const ILcidPosixMap * this_0,uint32_t hostID)1015 getPosixID(const ILcidPosixMap *this_0, uint32_t hostID)
1016 {
1017 uint32_t i;
1018 for (i = 0; i <= this_0->numRegions; i++)
1019 {
1020 if (this_0->regionMaps[i].hostID == hostID)
1021 {
1022 return this_0->regionMaps[i].posixID;
1023 }
1024 }
1025
1026 /* If you get here, then no matching region was found,
1027 so return the language id with the wild card region. */
1028 return this_0->regionMaps[0].posixID;
1029 }
1030
1031 /*
1032 //////////////////////////////////////
1033 //
1034 // LCID --> POSIX
1035 //
1036 /////////////////////////////////////
1037 */
1038 #ifdef USE_WINDOWS_LCID_MAPPING_API
1039 /*
1040 * Various language tags needs to be changed:
1041 * quz -> qu
1042 * prs -> fa
1043 */
1044 #define FIX_LANGUAGE_ID_TAG(buffer, len) \
1045 if (len >= 3) { \
1046 if (buffer[0] == 'q' && buffer[1] == 'u' && buffer[2] == 'z') {\
1047 buffer[2] = 0; \
1048 uprv_strcat(buffer, buffer+3); \
1049 } else if (buffer[0] == 'p' && buffer[1] == 'r' && buffer[2] == 's') {\
1050 buffer[0] = 'f'; buffer[1] = 'a'; buffer[2] = 0; \
1051 uprv_strcat(buffer, buffer+3); \
1052 } \
1053 }
1054
1055 #endif
1056 U_CAPI int32_t
uprv_convertToPosix(uint32_t hostid,char * posixID,int32_t posixIDCapacity,UErrorCode * status)1057 uprv_convertToPosix(uint32_t hostid, char *posixID, int32_t posixIDCapacity, UErrorCode* status)
1058 {
1059 uint16_t langID;
1060 uint32_t localeIndex;
1061 UBool bLookup = TRUE;
1062 const char *pPosixID = NULL;
1063
1064 #ifdef USE_WINDOWS_LCID_MAPPING_API
1065 char locName[LOCALE_NAME_MAX_LENGTH] = {}; // ICU name can't be longer than Windows name
1066
1067 // Note: Windows primary lang ID 0x92 in LCID is used for Central Kurdish and
1068 // GetLocaleInfo() maps such LCID to "ku". However, CLDR uses "ku" for
1069 // Northern Kurdish and "ckb" for Central Kurdish. For this reason, we cannot
1070 // use the Windows API to resolve locale ID for this specific case.
1071 if ((hostid & 0x3FF) != 0x92) {
1072 int32_t tmpLen = 0;
1073 UChar windowsLocaleName[LOCALE_NAME_MAX_LENGTH]; // ULOC_FULLNAME_CAPACITY > LOCALE_NAME_MAX_LENGTH
1074
1075 // Note: LOCALE_ALLOW_NEUTRAL_NAMES was enabled in Windows7+, prior versions did not handle neutral (no-region) locale names.
1076 tmpLen = LCIDToLocaleName(hostid, (PWSTR)windowsLocaleName, UPRV_LENGTHOF(windowsLocaleName), LOCALE_ALLOW_NEUTRAL_NAMES);
1077 if (tmpLen > 1) {
1078 int32_t i = 0;
1079 // Only need to look up in table if have _, eg for de-de_phoneb type alternate sort.
1080 bLookup = FALSE;
1081 for (i = 0; i < UPRV_LENGTHOF(locName); i++)
1082 {
1083 locName[i] = (char)(windowsLocaleName[i]);
1084
1085 // Windows locale name may contain sorting variant, such as "es-ES_tradnl".
1086 // In such cases, we need special mapping data found in the hardcoded table
1087 // in this source file.
1088 if (windowsLocaleName[i] == L'_')
1089 {
1090 // Keep the base locale, without variant
1091 // TODO: Should these be mapped from _phoneb to @collation=phonebook, etc.?
1092 locName[i] = '\0';
1093 tmpLen = i;
1094 bLookup = TRUE;
1095 break;
1096 }
1097 else if (windowsLocaleName[i] == L'-')
1098 {
1099 // Windows names use -, ICU uses _
1100 locName[i] = '_';
1101 }
1102 else if (windowsLocaleName[i] == L'\0')
1103 {
1104 // No point in doing more work than necessary
1105 break;
1106 }
1107 }
1108 // TODO: Need to understand this better, why isn't it an alias?
1109 FIX_LANGUAGE_ID_TAG(locName, tmpLen);
1110 pPosixID = locName;
1111 }
1112 }
1113 #endif // USE_WINDOWS_LCID_MAPPING_API
1114
1115 if (bLookup) {
1116 const char *pCandidate = NULL;
1117 langID = LANGUAGE_LCID(hostid);
1118
1119 for (localeIndex = 0; localeIndex < gLocaleCount; localeIndex++) {
1120 if (langID == gPosixIDmap[localeIndex].regionMaps->hostID) {
1121 pCandidate = getPosixID(&gPosixIDmap[localeIndex], hostid);
1122 break;
1123 }
1124 }
1125
1126 /* On Windows, when locale name has a variant, we still look up the hardcoded table.
1127 If a match in the hardcoded table is longer than the Windows locale name without
1128 variant, we use the one as the result */
1129 if (pCandidate && (pPosixID == NULL || uprv_strlen(pCandidate) > uprv_strlen(pPosixID))) {
1130 pPosixID = pCandidate;
1131 }
1132 }
1133
1134 if (pPosixID) {
1135 int32_t resLen = static_cast<int32_t>(uprv_strlen(pPosixID));
1136 int32_t copyLen = resLen <= posixIDCapacity ? resLen : posixIDCapacity;
1137 uprv_memcpy(posixID, pPosixID, copyLen);
1138 if (resLen < posixIDCapacity) {
1139 posixID[resLen] = 0;
1140 if (*status == U_STRING_NOT_TERMINATED_WARNING) {
1141 *status = U_ZERO_ERROR;
1142 }
1143 } else if (resLen == posixIDCapacity) {
1144 *status = U_STRING_NOT_TERMINATED_WARNING;
1145 } else {
1146 *status = U_BUFFER_OVERFLOW_ERROR;
1147 }
1148 return resLen;
1149 }
1150
1151 /* no match found */
1152 *status = U_ILLEGAL_ARGUMENT_ERROR;
1153 return -1;
1154 }
1155
1156 /*
1157 //////////////////////////////////////
1158 //
1159 // POSIX --> LCID
1160 // This should only be called from uloc_getLCID.
1161 // The locale ID must be in canonical form.
1162 //
1163 /////////////////////////////////////
1164 */
1165 U_CAPI uint32_t
uprv_convertToLCIDPlatform(const char * localeID)1166 uprv_convertToLCIDPlatform(const char* localeID)
1167 {
1168 // The purpose of this function is to leverage native platform name->lcid
1169 // conversion functionality when available.
1170 #ifdef USE_WINDOWS_LCID_MAPPING_API
1171 DWORD nameLCIDFlags = 0;
1172 UErrorCode myStatus = U_ZERO_ERROR;
1173
1174 // First check for a Windows name->LCID match, fall through to catch
1175 // ICU special cases, but Windows may know it already.
1176 #if LOCALE_ALLOW_NEUTRAL_NAMES
1177 nameLCIDFlags = LOCALE_ALLOW_NEUTRAL_NAMES;
1178 #endif /* LOCALE_ALLOW_NEUTRAL_NAMES */
1179
1180 int32_t len;
1181 char collVal[ULOC_KEYWORDS_CAPACITY] = {};
1182 char baseName[ULOC_FULLNAME_CAPACITY] = {};
1183 const char * mylocaleID = localeID;
1184
1185 // Check any for keywords.
1186 if (uprv_strchr(localeID, '@'))
1187 {
1188 len = uloc_getKeywordValue(localeID, "collation", collVal, UPRV_LENGTHOF(collVal) - 1, &myStatus);
1189 if (U_SUCCESS(myStatus) && len > 0)
1190 {
1191 // If it contains the keyword collation, return 0 so that the LCID lookup table will be used.
1192 return 0;
1193 }
1194 else
1195 {
1196 // If the locale ID contains keywords other than collation, just use the base name.
1197 len = uloc_getBaseName(localeID, baseName, UPRV_LENGTHOF(baseName) - 1, &myStatus);
1198
1199 if (U_SUCCESS(myStatus) && len > 0)
1200 {
1201 baseName[len] = 0;
1202 mylocaleID = baseName;
1203 }
1204 }
1205 }
1206
1207 char asciiBCP47Tag[LOCALE_NAME_MAX_LENGTH] = {};
1208 // this will change it from de_DE@collation=phonebook to de-DE-u-co-phonebk form
1209 (void)uloc_toLanguageTag(mylocaleID, asciiBCP47Tag, UPRV_LENGTHOF(asciiBCP47Tag), FALSE, &myStatus);
1210
1211 if (U_SUCCESS(myStatus))
1212 {
1213 // Need it to be UTF-16, not 8-bit
1214 wchar_t bcp47Tag[LOCALE_NAME_MAX_LENGTH] = {};
1215 int32_t i;
1216 for (i = 0; i < UPRV_LENGTHOF(bcp47Tag); i++)
1217 {
1218 if (asciiBCP47Tag[i] == '\0')
1219 {
1220 break;
1221 }
1222 else
1223 {
1224 // Copy the character
1225 bcp47Tag[i] = static_cast<wchar_t>(asciiBCP47Tag[i]);
1226 }
1227 }
1228
1229 if (i < (UPRV_LENGTHOF(bcp47Tag) - 1))
1230 {
1231 // Ensure it's null terminated
1232 bcp47Tag[i] = L'\0';
1233 LCID lcid = LocaleNameToLCID(bcp47Tag, nameLCIDFlags);
1234 if (lcid > 0)
1235 {
1236 // Found LCID from windows, return that one, unless its completely ambiguous
1237 // LOCALE_USER_DEFAULT and transients are OK because they will round trip
1238 // for this process.
1239 if (lcid != LOCALE_CUSTOM_UNSPECIFIED)
1240 {
1241 return lcid;
1242 }
1243 }
1244 }
1245 }
1246 #else
1247 (void)localeID; // Suppress unused variable warning.
1248 #endif /* USE_WINDOWS_LCID_MAPPING_API */
1249
1250 // No found, or not implemented on platforms without native name->lcid conversion
1251 return 0;
1252 }
1253
1254 U_CAPI uint32_t
uprv_convertToLCID(const char * langID,const char * posixID,UErrorCode * status)1255 uprv_convertToLCID(const char *langID, const char* posixID, UErrorCode* status)
1256 {
1257 // This function does the table lookup when native platform name->lcid conversion isn't available,
1258 // or for locales that don't follow patterns the platform expects.
1259 uint32_t low = 0;
1260 uint32_t high = gLocaleCount;
1261 uint32_t mid;
1262 uint32_t oldmid = 0;
1263 int32_t compVal;
1264
1265 uint32_t value = 0;
1266 uint32_t fallbackValue = (uint32_t)-1;
1267 UErrorCode myStatus;
1268 uint32_t idx;
1269
1270 /* Check for incomplete id. */
1271 if (!langID || !posixID || uprv_strlen(langID) < 2 || uprv_strlen(posixID) < 2) {
1272 return 0;
1273 }
1274
1275 /*Binary search for the map entry for normal cases */
1276
1277 while (high > low) /*binary search*/{
1278
1279 mid = (high+low) >> 1; /*Finds median*/
1280
1281 if (mid == oldmid)
1282 break;
1283
1284 compVal = uprv_strcmp(langID, gPosixIDmap[mid].regionMaps->posixID);
1285 if (compVal < 0){
1286 high = mid;
1287 }
1288 else if (compVal > 0){
1289 low = mid;
1290 }
1291 else /*we found it*/{
1292 return getHostID(&gPosixIDmap[mid], posixID, status);
1293 }
1294 oldmid = mid;
1295 }
1296
1297 /*
1298 * Sometimes we can't do a binary search on posixID because some LCIDs
1299 * go to different locales. We hit one of those special cases.
1300 */
1301 for (idx = 0; idx < gLocaleCount; idx++ ) {
1302 myStatus = U_ZERO_ERROR;
1303 value = getHostID(&gPosixIDmap[idx], posixID, &myStatus);
1304 if (myStatus == U_ZERO_ERROR) {
1305 return value;
1306 }
1307 else if (myStatus == U_USING_FALLBACK_WARNING) {
1308 fallbackValue = value;
1309 }
1310 }
1311
1312 if (fallbackValue != (uint32_t)-1) {
1313 *status = U_USING_FALLBACK_WARNING;
1314 return fallbackValue;
1315 }
1316
1317 /* no match found */
1318 *status = U_ILLEGAL_ARGUMENT_ERROR;
1319 return 0; /* return international (root) */
1320 }
1321