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