1013 lines
26 KiB
C++
1013 lines
26 KiB
C++
/*
|
|
**********************************************************************
|
|
* 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
|
|
|
|
|
|
|
|
|