AuroraMiddleware/scuffed-code
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
cac0aa8819
scuffed-code/icu4c/source/common/locid.cpp
Markus Scherer 07a2bc0937 ICU-6 more renaming of constant names 
FAILURE -> U_FAILURE etc.

X-SVN-Rev: 76
1999-10-18 22:48:32 +00:00

847 lines
22 KiB
C++
Raw Blame History

/*
*******************************************************************************
* *
* COPYRIGHT: *
* (C) Copyright Taligent, Inc., 1996 *
* (C) Copyright International Business Machines Corporation, 1996-1998 *
* Licensed Material - Program-Property of IBM - All Rights Reserved. *
* US Government Users Restricted Rights - Use, duplication, or disclosure *
* restricted by GSA ADP Schedule Contract with IBM Corp. *
* *
*******************************************************************************
*
* 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
*******************************************************************************
*/
#include "uhash.h"
#include "locid.h"
#include "uloc.h"
#include "resbund.h"
#include "mutex.h"
#include "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("en", "GB");
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 =
"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; // '_'
Locale::~Locale()
{
/*if fullName is on the heap, we delete it*/
if (fullName != fullNameBuffer)
{
delete []fullName;
}
}
Locale::Locale()
{
init(uloc_getDefault());
}
Locale::Locale( const UnicodeString& newLanguage)
{
UnicodeString togo(newLanguage);
char myLocaleID[ULOC_FULLNAME_CAPACITY];
int32_t size = newLanguage.size();
togo.extract(0,size, myLocaleID);
myLocaleID[size] = '\0';
init(myLocaleID);
}
Locale::Locale( const UnicodeString& newLanguage,
const UnicodeString& newCountry)
{
UnicodeString togo(newLanguage);
char myLocaleID[ULOC_FULLNAME_CAPACITY];
togo += sep;
togo += newCountry;
int size = togo.size();
togo.extract(0,size, myLocaleID);
myLocaleID[size] = '\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.size() > 0 ||
newVariantCopy.size() > 0 )
{
togo += sep;
togo += newCountry;
}
int vsize = newVariantCopy.size();
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.size() - 1;
while (i && (newVariantCopy[i] == sep)) newVariantCopy.remove(i--, 1);
togo += sep ;
togo += newVariantCopy ;
}
int size = togo.size();
/*is 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);
}
}
Locale::Locale(const Locale& other)
{
int j;
/*Copy the language and country fields*/
icu_strcpy(language, other.language);
icu_strcpy(country, other.country);
/*make fullName point to the heap if necessary*/
if ((j=icu_strlen(other.fullName)) > ULOC_FULLNAME_CAPACITY)
{
fullName = new char[j+1];
}
else fullName = fullNameBuffer;
icu_strcpy(fullName, other.fullName);
/*Make the variant point to the same offset as the copied*/
variant = fullName + (other.variant - other.fullName) ;
khashCode = other.khashCode;
}
bool_t
Locale::operator==( const Locale& other) const
{
if (icu_strcmp(other.language, language) == 0)
{
if (icu_strcmp(other.country, country) == 0)
{
if (icu_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=icu_strlen(localeID)) > ULOC_FULLNAME_CAPACITY)
{
this->fullName = new char[j+1];
}
else this->fullName = this->fullNameBuffer;
icu_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 this->variant = this->fullName + l + 1 ;
}
else this->variant = this->fullName + l - 1;
setHashCode();
return *this;
}
Locale& Locale::operator=(const Locale& other)
{
icu_strcpy(language, other.language);
icu_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[(icu_strlen(other.fullName)+1)];
}
icu_strcpy(fullName, other.fullName);
/*Make the variant point to the same offset as the assigner*/
variant = fullName + (other.variant - other.fullName) ;
khashCode = other.khashCode;
return *this;
}
int32_t
Locale::hashCode() const
{
return khashCode;
}
void
Locale::setHashCode()
{
UnicodeString fullNameUString = language;
fullNameUString += country;
fullNameUString += variant;
const UChar *key = fullNameUString.getUChars();
int32_t len = fullNameUString.size();
int32_t hash = 0;
const UChar *limit = key + len;
int32_t inc = (len >= 128 ? len/64 : 1);
/*
We compute the hash by iterating sparsely over 64 (at most) characters
spaced evenly through the string. For each character, we multiply the
previous hash value by a prime number and add the new character in,
in the manner of a additive linear congruential random number generator,
thus producing a pseudorandom deterministic value which should be well
distributed over the output range. [LIU]
*/
while(key < limit)
{
hash = (hash * 37) + (char)*key;
key += inc;
}
if(hash == 0) hash = 1;
khashCode = hash & 0x7FFFFFFF;
}
Locale&
Locale::getDefault()
{
return fgDefaultLocale;
}
/* sfb 07/21/99 */
U_CFUNC void
locale_set_default(const char *id)
{
Locale::getDefault().init(id);
}
/* end */
void
Locale::setDefault( const Locale& newLocale,
UErrorCode& status)
{
if (U_FAILURE(status)) return;
uloc_setDefault(newLocale.fullName, &status);
fgDefaultLocale = newLocale;
}
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 = fullName;
return name;
}
// deprecated
UnicodeString&
Locale::getISO3Language(UnicodeString& lang) const
{
lang = uloc_getISO3Language(fullName);
return lang;
}
UnicodeString&
Locale::getISO3Language(UnicodeString& lang, UErrorCode& status) const
{
if(U_FAILURE(status))
return lang;
lang = uloc_getISO3Language(fullName);
if (lang.size() == 0)
status = U_MISSING_RESOURCE_ERROR;
return lang;
}
// deprecated
UnicodeString&
Locale::getISO3Country(UnicodeString& cntry) const
{
cntry = uloc_getISO3Country(fullName);
return cntry;
}
UnicodeString&
Locale::getISO3Country(UnicodeString& cntry, UErrorCode& status) const
{
if(U_FAILURE(status))
return cntry;
cntry = uloc_getISO3Country(fullName);
if (cntry.size() == 0)
status = U_MISSING_RESOURCE_ERROR;
return cntry;
}
/**
* 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)
{
const UnicodeString* ids = ResourceBundle::listInstalledLocales(getDataDirectory(), count);
Locale *newLocaleList = new Locale[count];
for(int32_t i = 0; i < count; i++)
newLocaleList[i].setFromPOSIXID(ids[i]);
Mutex mutex;
if(localeList != 0) {
delete []newLocaleList;
}
else {
localeListCount = count;
localeList = newLocaleList;
}
}
count = localeListCount;
return localeList;
}
/**
* 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;
}
/**
* 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_hashUString, &err);
if (U_FAILURE(err))
{
count = 0;
return NULL;
}
int32_t i = 0;
int32_t j;
int32_t count = 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.size() / 2];
int32_t valLen = sizeof(values) / sizeof(values[0]);
for (int32_t k = 0; k < valLen; ++k)
compressedValues.extractBetween(k * 2, (k * 2) + 2, values[k]);
uhash_putKey(temp, uhash_hashUString((void*)key.getUChars()),values,&err);
i = j;
}
Mutex mutex;
if(ctry2LangMapping != 0)
uhash_close(temp);
else
ctry2LangMapping = temp;
}
const UnicodeString *result = (const UnicodeString*)uhash_get(ctry2LangMapping,uhash_hashUString(country.getUChars()));
if(result == 0)
count = 0;
else
count = sizeof(result) / sizeof(result[0]);
return result;
}
/**
* Get the path to the locale files. This path will be a platform-specific
* path name ending in a directory separator, so that file names may be
* concatenated to it.
*/
const char* Locale::getDataDirectory()
{
return uloc_getDataDirectory();
}
/**
* Set the path to the locale files.
*/
void Locale::setDataDirectory(const char* path)
{
uloc_setDataDirectory(path);
}
// ================= privates =====================================
// Set the locale's data based on a posix id.
void Locale::setFromPOSIXID(const char *posixID)
{
init(posixID);
}
// Set the locale's data based on a posix id.
void Locale::setFromPOSIXID(const UnicodeString &posixIDString)
{
char onStack[20];
char* buffer = onStack;
if (posixIDString.size() >= 20) buffer = new char[posixIDString.size()+1];
posixIDString.extract(0, posixIDString.size(), buffer);
buffer[posixIDString.size()] = '\0';
init(buffer);
if (buffer != onStack) delete [] buffer;
}
//eof
Reference in New Issue View Git Blame Copy Permalink