src/third_party/icu/source/common/locmap.c

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