| /* |
| ********************************************************************** |
| * Copyright (C) 1997-1999, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| ********************************************************************** |
| * |
| * File locid.cpp |
| * |
| * Created by: Richard Gillam |
| * |
| * Modification History: |
| * |
| * Date Name Description |
| * 02/11/97 aliu Changed gLocPath to fgDataDirectory and added |
| * methods to get and set it. |
| * 04/02/97 aliu Made operator!= inline; fixed return value |
| * of getName(). |
| * 04/15/97 aliu Cleanup for AIX/Win32. |
| * 04/24/97 aliu Numerous changes per code review. |
| * 08/18/98 stephen Changed getDisplayName() |
| * Added SIMPLIFIED_CHINESE, TRADITIONAL_CHINESE |
| * Added getISOCountries(), getISOLanguages(), |
| * getLanguagesForCountry() |
| * 03/16/99 bertrand rehaul. |
| * 07/21/99 stephen Added U_CFUNC setDefault |
| * 11/09/99 weiv Added const char * getName() const; |
| * 04/12/00 srl removing unicodestring api's and cached hash code |
| ******************************************************************************* |
| */ |
| |
| |
| |
| #include "uhash.h" |
| #include "unicode/locid.h" |
| #include "unicode/uloc.h" |
| #include "unicode/resbund.h" |
| #include "uresimp.h" |
| #include "mutex.h" |
| #include "unicode/unicode.h" |
| #include "cmemory.h" |
| #include "cstring.h" |
| |
| /** |
| * static variables |
| */ |
| Locale Locale::fgDefaultLocale; |
| |
| Locale* Locale::localeList = NULL; |
| int32_t Locale::localeListCount; |
| UnicodeString* Locale::isoLanguages = NULL; |
| int32_t Locale::isoLanguagesCount; |
| UnicodeString* Locale::isoCountries = NULL;; |
| int32_t Locale::isoCountriesCount; |
| |
| |
| |
| |
| /** |
| * Constant definitions |
| */ |
| const Locale Locale::ENGLISH("en"); |
| const Locale Locale::FRENCH("fr"); |
| const Locale Locale::GERMAN("de"); |
| const Locale Locale::ITALIAN("it"); |
| const Locale Locale::JAPANESE("ja"); |
| const Locale Locale::KOREAN("ko"); |
| const Locale Locale::CHINESE("zh"); |
| const Locale Locale::SIMPLIFIED_CHINESE("zh", "CN"); |
| const Locale Locale::TRADITIONAL_CHINESE("zh", "TW"); |
| |
| // Useful constant for country. |
| |
| const Locale Locale::FRANCE ("fr", "FR"); |
| const Locale Locale::GERMANY ("de", "DE"); |
| const Locale Locale::ITALY ("it", "IT"); |
| const Locale Locale::JAPAN ("ja", "JP"); |
| const Locale Locale::KOREA ("ko", "KR"); |
| const Locale Locale::CHINA ("zh", "CN"); |
| const Locale Locale::PRC ("zh", "CN"); |
| const Locale Locale::TAIWAN ("zh", "TW"); |
| const Locale Locale::UK ("en", "GB"); |
| const Locale Locale::US ("en", "US"); |
| const Locale Locale::CANADA ("en", "CA"); |
| const Locale Locale::CANADA_FRENCH("fr", "CA"); |
| |
| |
| /** |
| * Table mapping ISO country codes to the ISO language codes of the languages spoken |
| * in those countries. |
| * (Because the Java VM specification for building arrays and hashtables causes |
| * code that builds the tables element by element to be produces, we compress the data |
| * into a single encoded String, and lazy evaluate the table from it.) |
| */ |
| UHashtable* Locale::ctry2LangMapping = 0; |
| const UnicodeString Locale::compressedCtry2LangMapping = UnicodeString( |
| "ADfresAEarenAFpsAGenAIrnALsqAMhyruANnlenAOptAResASensmATdeAUenAWnlenAZazhyru" |
| "BAsrshhrslmksqBBenBDbnhibhenBEfrnldeBFfrBGbgtrBHarenBIrnfrswBJfrBMenBNmsenzh" |
| "BOesayquBRptBSenBTdzenneBVnoBWentnBYberuBZenesCAenfrCCenCFfrsgCGfrCHfrdeitrm" |
| "CIfrCKmienCLesCMenfrCNzhboCOesCResCUesCVptCXenCYeltrenCZcsskDEdeDJarfrsoDKda" |
| "DMenfrDOesDZarfrECesquEEetruEGarenfrEHarfritERamtiarenitESeseucaglETamaren" |
| "FIfisvFJenfjhiFKenFMenFOfodaFRfreubrcoFXfrGAfrGBengdcyGDenfrGEkahyruGFfrGHen" |
| "GIenesGLdaikklGMenwoGNfrGPfrenGQesGRelGTesGUenGWptGYenhiurHKzhenHNesHRhrHTfr" |
| "HUhuIDinennlIEengaILiwarjiINhienguknksmlmrneorpasatateIOenIQarkutkIRfaarku" |
| "ISisITitfrdeJMenJOarJPjaKEenswKGkyKHkmKIenKMfrarKNenKPkoKRkoKWarenKYenKZkkru" |
| "LAlofrLBarenfrLCenfrLIdeLKtasienLRenLSstenLTltruplLUfrdeLVlvltruLYarenit" |
| "MAarfresMCfrenitMDmorobgMGmgenfrMKmkshtrMLfrMMmyMNmnruMOzhptMQfrMRarfrMSen" |
| "MTmtenitMUenfrhiMWenMXesMYmsenMZptNAenafdeNEfrhaNFenNGenhayoNIesNLnlfyNOno" |
| "NPneNRnaenNUenNZenmiOMarenPAesenPEesquayPFfrPGenPHentlesPKurenpspasdPLplPMfren" |
| "PNenPResenPTptPWenPYesgnQAarenREfrtaROrohuRUruRWenfrrwSAarSBenSCenfrSDarsu" |
| "SEsvSGzhenmstaSHenSIslSJnoSKskhuplshSLenSMitSNfrSOarenitsoSRnleneshiSTptSVes" |
| "SYarSZenssTCenTDfrarTFfrTGfrTHthTJtgruuzTKenmiTMtkruTNarTOentoTRtrkuTTenTVen" |
| "TWzhTZenswUAukruUGenswUMenUSenesUYesUZuzruVAlaitVCenVEesVGenVIenVNvizhfr" |
| "VUenfrbiWFfrWSensmYEarYTfrmgswYUsrshmkhuZAafenZMenZRfrswZWensn", |
| ""); |
| |
| /*Used for stack allocation of temporary buffers |
| *can be tweaked for speed and likelihood of resorting to heap allocation*/ |
| #define BUFFER_SIZE 50 |
| |
| /*Character separating the posix id fields*/ |
| const UChar sep = 0x005F; // '_' |
| const char sepchar = '_'; // In the platform codepage. |
| |
| Locale::~Locale() |
| { |
| /*if fullName is on the heap, we delete it*/ |
| if (fullName != fullNameBuffer) |
| { |
| delete []fullName; |
| } |
| } |
| |
| Locale::Locale() |
| { |
| init(uloc_getDefault()); |
| } |
| |
| Locale::Locale( const char * newLanguage, |
| const char * newCountry, |
| const char * newVariant) |
| { |
| char togo_stack[ULOC_FULLNAME_CAPACITY]; |
| char *togo; |
| char *togo_heap = NULL; |
| int32_t size = 0; |
| int32_t lsize = 0; |
| int32_t csize = 0; |
| int32_t vsize = 0; |
| char *p; |
| |
| if( (newLanguage==NULL) && (newCountry == NULL) && (newVariant == NULL) ) |
| { |
| init(NULL); /* shortcut */ |
| } |
| else |
| { |
| // Calculate the size of the resulting string. |
| |
| // Language |
| if ( newLanguage != NULL ) |
| { |
| lsize = (int32_t)uprv_strlen(newLanguage); |
| size = lsize; |
| } |
| |
| // _Country |
| if ( newCountry != NULL ) |
| { |
| csize = (int32_t)uprv_strlen(newCountry); |
| size += csize; |
| } |
| |
| // _Variant |
| if ( newVariant != NULL ) |
| { |
| // remove leading _'s |
| while(newVariant[0] == sepchar) |
| { |
| newVariant++; |
| } |
| |
| // remove trailing _'s |
| vsize = (int32_t)uprv_strlen(newVariant); |
| while( (vsize>1) && (newVariant[vsize-1] == sepchar) ) |
| { |
| vsize--; |
| } |
| } |
| |
| if( vsize > 0 ) |
| { |
| size += vsize; |
| } |
| |
| // Separator rules: |
| if ( vsize > 0 ) |
| { |
| size += 2; // at least: __v |
| } |
| else if ( csize > 0 ) |
| { |
| size += 1; // at least: _v |
| } |
| |
| // NOW we have the full locale string.. |
| |
| /*if the whole string is longer than our internal limit, we need |
| to go to the heap for temporary buffers*/ |
| if (size > ULOC_FULLNAME_CAPACITY) |
| { |
| togo_heap = new char[size+1]; |
| togo = togo_heap; |
| } |
| else |
| { |
| togo = togo_stack; |
| } |
| |
| togo[0] = 0; |
| |
| // Now, copy it back. |
| p = togo; |
| if ( lsize != 0 ) |
| { |
| uprv_strcpy(p, newLanguage); |
| p += lsize; |
| } |
| |
| if ( ( vsize != 0 ) || (csize != 0) ) // at least: __v |
| { // ^ |
| *p++ = sepchar; |
| } |
| |
| if ( csize != 0 ) |
| { |
| |
| uprv_strcpy(p, newCountry); |
| p += csize; |
| } |
| |
| if ( vsize != 0) |
| { |
| *p++ = sepchar; // at least: __v |
| |
| uprv_strncpy(p, newVariant, vsize); // Must use strncpy because |
| p += vsize; // of trimming (above). |
| *p = 0; // terminate |
| } |
| |
| // Parse it, because for example 'language' might really be a complete |
| // string. |
| init(togo); |
| |
| delete [] togo_heap; /* If it was needed */ |
| } |
| } |
| |
| Locale::Locale(const Locale& other) |
| |
| { |
| int j; |
| /*Copy the language and country fields*/ |
| uprv_strcpy(language, other.language); |
| uprv_strcpy(country, other.country); |
| |
| /*make fullName point to the heap if necessary*/ |
| if ((j=(int)uprv_strlen(other.fullName)) > ULOC_FULLNAME_CAPACITY) |
| { |
| fullName = new char[j+1]; |
| } |
| else |
| fullName = fullNameBuffer; |
| |
| uprv_strcpy(fullName, other.fullName); |
| |
| /*Make the variant point to the same offset as the copied*/ |
| variant = fullName + (other.variant - other.fullName) ; |
| } |
| |
| UBool |
| Locale::operator==( const Locale& other) const |
| { |
| if (uprv_strcmp(other.language, language) == 0 |
| && uprv_strcmp(other.country, country) == 0 |
| && uprv_strcmp(other.variant, variant) == 0) |
| { |
| return TRUE; |
| } |
| |
| return FALSE; |
| } |
| |
| /*This function initializes a Locale from a C locale ID*/ |
| Locale& Locale::init(const char* localeID) |
| { |
| int k,l; |
| UErrorCode err = U_ZERO_ERROR; |
| |
| if (localeID == NULL) |
| localeID = uloc_getDefault(); |
| |
| l = uloc_getLanguage(localeID, |
| this->language, |
| ULOC_LANG_CAPACITY, |
| &err); |
| |
| l += k = uloc_getCountry(localeID, |
| this->country, |
| ULOC_COUNTRY_CAPACITY, |
| &err); |
| |
| l--; //adjust for the 2 zero terminators |
| |
| /*Go to heap for the fullName if necessary*/ |
| int j; |
| if ((j=(int)uprv_strlen(localeID)) > ULOC_FULLNAME_CAPACITY) |
| { |
| this->fullName = new char[j+1]; |
| } |
| else { |
| this->fullName = this->fullNameBuffer; |
| } |
| |
| uprv_strcpy(this->fullName, localeID); |
| |
| /*Setting up the variant: |
| -point to the zero terminator of fullName if there is none |
| -point to the first character of the variant if ther is one |
| */ |
| if (k > 1) |
| { |
| if (this->fullName[l] == '\0') |
| { |
| this->variant = this->fullName + l; |
| } |
| else |
| { |
| int32_t varLength; |
| UErrorCode intErr = U_ZERO_ERROR; |
| varLength = uloc_getVariant(this->fullName, NULL, 0, &intErr); |
| |
| if(U_FAILURE(intErr) && (intErr != U_BUFFER_OVERFLOW_ERROR)) |
| { |
| this->variant = (char*)u_errorName(intErr); |
| } |
| else if(varLength <= 0) |
| { /* bail - point at the null*/ |
| // this->variant = this->fullName + j; |
| this->variant = "Len<=0"; |
| } |
| else |
| { |
| /* variant is at the end. We just don't know where exactly it might be. */ |
| this->variant = this->fullName + j - varLength + 1 ; |
| } |
| } |
| } |
| else |
| this->variant = this->fullName + l - 1; |
| |
| return *this; |
| } |
| |
| Locale& Locale::operator=(const Locale& other) |
| { |
| uprv_strcpy(language, other.language); |
| uprv_strcpy(country, other.country); |
| if (other.fullName == other.fullNameBuffer) |
| { |
| fullName = fullNameBuffer; |
| } |
| else |
| { |
| /*In case the assigner has some of its data on the heap |
| * we need to do the same*/ |
| if (fullName != fullNameBuffer) delete []fullName; |
| fullName = new char[(uprv_strlen(other.fullName)+1)]; |
| } |
| uprv_strcpy(fullName, other.fullName); |
| /*Make the variant point to the same offset as the assigner*/ |
| variant = fullName + (other.variant - other.fullName) ; |
| |
| return *this; |
| } |
| |
| int32_t |
| Locale::hashCode() const |
| { |
| UnicodeString fullNameUString(language, ""); |
| return fullNameUString.append(UnicodeString(country, "")).append(UnicodeString(variant, "")).hashCode(); |
| } |
| |
| |
| Locale& |
| Locale::getDefault() |
| { |
| return fgDefaultLocale; |
| } |
| |
| |
| void locale_set_default_internal(const char *id) |
| { |
| Locale::getDefault().init(id); |
| } |
| |
| /* sfb 07/21/99 */ |
| U_CFUNC void |
| locale_set_default(const char *id) |
| { |
| locale_set_default_internal(id); |
| } |
| /* end */ |
| |
| |
| void |
| Locale::setDefault( const Locale& newLocale, |
| UErrorCode& status) |
| { |
| if (U_FAILURE(status)) |
| return; |
| |
| uloc_setDefault(newLocale.fullName, &status); |
| |
| fgDefaultLocale = newLocale; |
| } |
| |
| Locale |
| Locale::createFromName (const char *name) |
| { |
| char stack[128]; |
| char *heap = NULL; |
| char *buf = stack; |
| int32_t buflen = 128; |
| UErrorCode status; |
| |
| status = U_ZERO_ERROR; |
| |
| /* for some reason */ |
| if(uprv_strlen(name) > buflen) { |
| buflen = (int32_t)uprv_strlen(name)+1; |
| heap = (char*)uprv_malloc(buflen); |
| buf = heap; |
| } |
| |
| uloc_getName(name, buf, buflen, &status); |
| |
| Locale l(buf); |
| if(heap != NULL) |
| { |
| free(heap); |
| } |
| return l; |
| } |
| |
| const char * |
| Locale::getCountry() const |
| { |
| return country; |
| } |
| |
| const char * |
| Locale::getLanguage() const |
| { |
| return language; |
| } |
| |
| const char * |
| Locale::getVariant() const |
| { |
| return variant; |
| } |
| |
| #ifdef ICU_LOCID_USE_DEPRECATES |
| UnicodeString& |
| Locale::getLanguage(UnicodeString& lang) const |
| { |
| lang = language; |
| return lang; |
| } |
| |
| UnicodeString& |
| Locale::getCountry(UnicodeString& cntry) const |
| { |
| cntry = country; |
| return cntry; |
| } |
| |
| UnicodeString& |
| Locale::getVariant(UnicodeString& var) const |
| { |
| var = variant; |
| return var; |
| } |
| |
| UnicodeString& |
| Locale::getName(UnicodeString& name) const |
| { |
| name = UnicodeString(fullName,""); |
| return name; |
| } |
| #endif |
| |
| const char * |
| Locale::getName() const |
| { |
| return fullName; |
| } |
| |
| const char * |
| Locale::getISO3Language() const |
| { |
| return uloc_getISO3Language(fullName); |
| } |
| |
| |
| const char * |
| Locale::getISO3Country() const |
| { |
| return uloc_getISO3Country(fullName); |
| } |
| |
| #ifdef ICU_LOCID_USE_DEPRECATES |
| UnicodeString& |
| Locale::getISO3Language(UnicodeString& lang, UErrorCode& status) const |
| { |
| if(U_FAILURE(status)) |
| return lang; |
| |
| lang = uloc_getISO3Language(fullName); |
| if (lang.length() == 0) |
| status = U_MISSING_RESOURCE_ERROR; |
| |
| return lang; |
| } |
| |
| UnicodeString& |
| Locale::getISO3Country(UnicodeString& cntry, UErrorCode& status) const |
| { |
| if(U_FAILURE(status)) |
| return cntry; |
| |
| cntry = uloc_getISO3Country(fullName); |
| if (cntry.length() == 0) |
| status = U_MISSING_RESOURCE_ERROR; |
| |
| return cntry; |
| } |
| #endif |
| |
| /** |
| * Return the LCID value as specified in the "LocaleID" resource for this |
| * locale. The LocaleID must be expressed as a hexadecimal number, from |
| * one to four digits. If the LocaleID resource is not present, or is |
| * in an incorrect format, 0 is returned. The LocaleID is for use in |
| * Windows (it is an LCID), but is available on all platforms. |
| */ |
| uint32_t |
| Locale::getLCID() const |
| { |
| return uloc_getLCID(fullName); |
| } |
| |
| UnicodeString& |
| Locale::getDisplayLanguage(UnicodeString& dispLang) const |
| { |
| return this->getDisplayLanguage(getDefault(), dispLang); |
| } |
| |
| /*We cannot make any assumptions on the size of the output display strings |
| * Yet, since we are calling through to a C API, we need to set limits on |
| * buffer size. For all the following getDisplay functions we first attempt |
| * to fill up a stack allocated buffer. If it is to small we heap allocated |
| * the exact buffer we need copy it to the UnicodeString and delete it*/ |
| |
| UnicodeString& |
| Locale::getDisplayLanguage( const Locale& inLocale, |
| UnicodeString& dispLang) const |
| { |
| UErrorCode status = U_ZERO_ERROR; |
| UChar bufBuffer[BUFFER_SIZE]; |
| UChar* buf = bufBuffer; |
| |
| // dispLang = "result"; |
| // return dispLang; |
| int size = uloc_getDisplayLanguage(fullName, |
| inLocale.fullName, |
| buf, |
| BUFFER_SIZE, |
| &status); |
| |
| |
| if (status == U_BUFFER_OVERFLOW_ERROR) |
| { |
| status = U_ZERO_ERROR; |
| buf = new UChar[size]; |
| |
| uloc_getDisplayLanguage(fullName, |
| inLocale.fullName, |
| buf, |
| size, |
| &status); |
| |
| } |
| |
| dispLang = buf; |
| |
| if (buf != bufBuffer) |
| delete []buf; |
| |
| return dispLang; |
| } |
| |
| UnicodeString& |
| Locale::getDisplayCountry(UnicodeString& dispCntry) const |
| { |
| return this->getDisplayCountry(getDefault(), dispCntry); |
| } |
| |
| UnicodeString& |
| Locale::getDisplayCountry( const Locale& inLocale, |
| UnicodeString& dispCntry) const |
| { |
| UErrorCode status = U_ZERO_ERROR; |
| UChar bufBuffer[BUFFER_SIZE]; |
| UChar* buf = bufBuffer; |
| |
| int size = uloc_getDisplayCountry(fullName, |
| inLocale.fullName, |
| buf, |
| BUFFER_SIZE, |
| &status); |
| |
| if (status == U_BUFFER_OVERFLOW_ERROR) |
| { |
| status = U_ZERO_ERROR; |
| buf = new UChar[size]; |
| uloc_getDisplayCountry(fullName, |
| inLocale.fullName, |
| buf, |
| size, |
| &status); |
| } |
| |
| dispCntry = buf; |
| |
| if (buf != bufBuffer) |
| delete []buf; |
| |
| return dispCntry; |
| } |
| |
| UnicodeString& |
| Locale::getDisplayVariant(UnicodeString& dispVar) const |
| { |
| return this->getDisplayVariant(getDefault(), dispVar); |
| } |
| |
| UnicodeString& Locale::getDisplayVariant(const Locale& inLocale, |
| UnicodeString& dispVar) const |
| { |
| UErrorCode status = U_ZERO_ERROR; |
| UChar bufBuffer[BUFFER_SIZE]; |
| UChar* buf = bufBuffer; |
| |
| int size = uloc_getDisplayVariant(fullName, |
| inLocale.fullName, |
| buf, |
| BUFFER_SIZE, |
| &status); |
| |
| if (status == U_BUFFER_OVERFLOW_ERROR) |
| { |
| status = U_ZERO_ERROR; |
| buf = new UChar[size]; |
| uloc_getDisplayVariant(fullName, |
| inLocale.fullName, |
| buf, |
| size, |
| &status); |
| } |
| |
| dispVar = buf; |
| |
| if (buf != bufBuffer) |
| delete []buf; |
| |
| return dispVar; |
| } |
| |
| UnicodeString& |
| Locale::getDisplayName( UnicodeString& name ) const |
| { |
| return this->getDisplayName(getDefault(), name); |
| } |
| |
| UnicodeString& |
| Locale::getDisplayName( const Locale& inLocale, |
| UnicodeString& result) const |
| { |
| UErrorCode status = U_ZERO_ERROR; |
| UChar bufBuffer[BUFFER_SIZE]; |
| UChar* buf = bufBuffer; |
| |
| int size = uloc_getDisplayName(fullName, |
| inLocale.fullName, |
| buf, |
| BUFFER_SIZE, |
| &status); |
| |
| if (status == U_BUFFER_OVERFLOW_ERROR) |
| { |
| status = U_ZERO_ERROR; |
| |
| buf = new UChar[size]; |
| uloc_getDisplayName(fullName, |
| inLocale.fullName, |
| buf, |
| size, |
| &status); |
| } |
| |
| result = buf; |
| |
| if (buf != bufBuffer) { |
| delete []buf; |
| } |
| |
| return result; |
| } |
| |
| const Locale* |
| Locale::getAvailableLocales(int32_t& count) |
| { |
| // for now, there is a hardcoded list, so just walk through that list and set it up. |
| if (localeList == 0) { |
| UErrorCode status = U_ZERO_ERROR; |
| ResourceBundle index(UnicodeString(""), Locale(kIndexLocaleName), status); |
| ResourceBundle locales = index.get(kIndexTag, status); |
| |
| char name[96]; |
| locales.resetIterator(); |
| |
| count = locales.getSize(); |
| |
| Locale *newLocaleList = new Locale[count]; |
| |
| int32_t i = 0; |
| UnicodeString temp; |
| while(locales.hasNext()) { |
| temp = locales.getNextString(status); |
| temp.extract(0, temp.length(), name); |
| name[temp.length()] = '\0'; |
| newLocaleList[i++].setFromPOSIXID(name); |
| } |
| |
| Mutex mutex; |
| if(localeList != 0) { |
| delete []newLocaleList; |
| } |
| else { |
| localeListCount = count; |
| localeList = newLocaleList; |
| } |
| } |
| count = localeListCount; |
| return localeList; |
| } |
| |
| const char* const* Locale::getISOCountries() |
| { |
| return uloc_getISOCountries(); |
| } |
| |
| const char* const* Locale::getISOLanguages() |
| { |
| return uloc_getISOLanguages(); |
| } |
| |
| |
| #ifdef ICU_LOCID_USE_DEPRECATES |
| /** |
| * Returns a list of all 2-letter country codes defined in ISO 3166. |
| * Can be used to create Locales. |
| */ |
| const UnicodeString* |
| Locale::getISOCountries(int32_t& count) |
| { |
| if(isoCountries == 0) { |
| const char* const* cResult = uloc_getISOCountries(); |
| int32_t tempCount; |
| |
| int i; |
| tempCount = 0; |
| for (i = 0; cResult[i] != NULL; i++) ++tempCount; |
| |
| UnicodeString *temp = new UnicodeString [tempCount]; |
| |
| for(i = 0; i < tempCount; ++i) |
| temp[i] = cResult[i]; |
| |
| Mutex mutex; |
| if(isoCountries != 0) |
| delete [] temp; |
| else { |
| isoCountries = temp; |
| isoCountriesCount = tempCount; |
| } |
| } |
| |
| count = isoCountriesCount; |
| |
| |
| return isoCountries; |
| } |
| |
| /** |
| * Returns a list of all 2-letter language codes defined in ISO 639. |
| * Can be used to create Locales. |
| * [NOTE: ISO 639 is not a stable standard-- some languages' codes have changed. |
| * The list this function returns includes both the new and the old codes for the |
| * languages whose codes have changed.] |
| */ |
| const UnicodeString* |
| Locale::getISOLanguages(int32_t& count) |
| { |
| if(isoLanguages == 0) { |
| const char* const* cResult = uloc_getISOLanguages(); |
| int32_t tempCount; |
| |
| int i; |
| tempCount = 0; |
| for (i = 0; cResult[i] != NULL; i++) ++tempCount; |
| |
| UnicodeString *temp = new UnicodeString [tempCount]; |
| |
| for(i = 0; i < tempCount; ++i) |
| temp[i] = cResult[i]; |
| |
| Mutex mutex; |
| if(isoLanguages != 0) |
| delete [] temp; |
| else { |
| isoLanguages = temp; |
| isoLanguagesCount = tempCount; |
| } |
| } |
| |
| count = isoLanguagesCount; |
| return isoLanguages; |
| } |
| #endif |
| |
| /** |
| * Given an ISO country code, returns an array of Strings containing the ISO |
| * codes of the languages spoken in that country. Official languages are listed |
| * in the returned table before unofficial languages, but other than that, the |
| * order of the returned list is indeterminate. If the value the user passes in |
| * for "country" is not a valid ISO 316 country code, or if we don't have language |
| * information for the specified country, this function returns an empty array. |
| * |
| * [This function is not currently part of Locale's API, but is needed in the |
| * implementation. We hope to add it to the API in a future release.] |
| */ |
| const UnicodeString* |
| Locale::getLanguagesForCountry(const UnicodeString& country, int32_t& count) |
| { |
| // To save on the size of a static array in the .class file, we keep the |
| // data around encoded into a String. The first time this function is called, |
| // the String s parsed to produce a Hashtable, which is then used for all |
| // lookups. |
| if(ctry2LangMapping == 0) { |
| UErrorCode err = U_ZERO_ERROR; |
| UHashtable *temp = uhash_open(uhash_hashUnicodeString, uhash_compareUnicodeString, &err); |
| if (U_FAILURE(err)) |
| { |
| count = 0; |
| return NULL; |
| } |
| |
| uhash_setKeyDeleter(temp, uhash_deleteUnicodeString); |
| |
| int32_t i = 0; |
| int32_t j; |
| int32_t count = (int32_t)(sizeof(compressedCtry2LangMapping) / sizeof(compressedCtry2LangMapping[0])); |
| while (i < count) { |
| UnicodeString key; |
| compressedCtry2LangMapping.extractBetween(i, i + 2, key); |
| i += 2; |
| for(j = i; j < count; j += 2) |
| if(Unicode::isUpperCase(compressedCtry2LangMapping[j])) |
| break; |
| UnicodeString compressedValues; |
| compressedCtry2LangMapping.extractBetween(i, j, compressedValues); |
| UnicodeString *values = new UnicodeString[compressedValues.length() / 2]; |
| int32_t valLen = (int32_t)(sizeof(values) / sizeof(values[0])); |
| for (int32_t k = 0; k < valLen; ++k) |
| compressedValues.extractBetween(k * 2, (k * 2) + 2, values[k]); |
| uhash_put(temp, new UnicodeString(key), values, &err); |
| i = j; |
| } |
| |
| Mutex mutex; |
| if(ctry2LangMapping != 0) |
| uhash_close(temp); |
| else |
| ctry2LangMapping = temp; |
| } |
| |
| const UnicodeString *result = (const UnicodeString*)uhash_get(ctry2LangMapping, &country); |
| if(result == 0) |
| count = 0; |
| else |
| count = (int32_t)(sizeof(result) / sizeof(result[0])); |
| |
| return result; |
| } |
| |
| |
| // ================= privates ===================================== |
| |
| |
| |
| |
| // Set the locale's data based on a posix id. |
| void Locale::setFromPOSIXID(const char *posixID) |
| { |
| init(posixID); |
| } |
| |
| #ifdef ICU_LOCID_USE_DEPRECATES |
| // Deprecated APIs |
| Locale::Locale( const UnicodeString& newLanguage) |
| { |
| char myLocaleID[ULOC_FULLNAME_CAPACITY]; |
| |
| myLocaleID[newLanguage.extract(0, 0x7fffffff, myLocaleID, "")] = '\0'; |
| init(myLocaleID); |
| } |
| |
| Locale::Locale( const UnicodeString& newLanguage, |
| const UnicodeString& newCountry) |
| { |
| UnicodeString togo(newLanguage); |
| char myLocaleID[ULOC_FULLNAME_CAPACITY]; |
| |
| if(newCountry.length()>0) { |
| togo += sep; |
| togo += newCountry; |
| } |
| |
| myLocaleID[togo.extract(0, 0x7fffffff, myLocaleID, "")] = '\0'; |
| init(myLocaleID); |
| } |
| |
| |
| Locale::Locale( const UnicodeString& newLanguage, |
| const UnicodeString& newCountry, |
| const UnicodeString& newVariant) |
| { |
| UnicodeString togo(newLanguage); |
| |
| char myLocaleID[ULOC_FULLNAME_CAPACITY]; |
| UnicodeString newVariantCopy(newVariant); |
| |
| |
| if (newCountry.length() > 0 || |
| newVariantCopy.length() > 0 ) |
| { |
| togo += sep; |
| togo += newCountry; |
| } |
| |
| int vsize = newVariantCopy.length(); |
| if (vsize > 0) |
| { |
| int i = 0; |
| //We need to trim variant codes : (_*)$var(_*) --> $var |
| while ((i<vsize) && newVariantCopy[i] == sep) newVariantCopy.remove(i++, 1); |
| i = newVariantCopy.length() - 1; |
| while (i && (newVariantCopy[i] == sep)) newVariantCopy.remove(i--, 1); |
| |
| togo += sep ; |
| togo += newVariantCopy ; |
| } |
| |
| int size = togo.length(); |
| |
| /*if the variant is longer than our internal limit, we need |
| to go to the heap for temporary buffers*/ |
| if (size > ULOC_FULLNAME_CAPACITY) |
| { |
| char *togo_heap = new char[size+1]; |
| togo.extract(0,size, togo_heap, ""); |
| togo_heap[size] = '\0'; |
| init(togo_heap); |
| delete []togo_heap; |
| } |
| else |
| { |
| togo.extract(0,size, myLocaleID, ""); |
| myLocaleID[size] = '\0'; |
| init(myLocaleID); |
| } |
| |
| } |
| #endif |
| |
| //eof |
| |
| |
| |
| |
