| /* |
| ******************************************************************************* |
| * |
| * Copyright (C) 1997-2013, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| * |
| ******************************************************************************* |
| * file name: locdispnames.cpp |
| * encoding: US-ASCII |
| * tab size: 8 (not used) |
| * indentation:4 |
| * |
| * created on: 2010feb25 |
| * created by: Markus W. Scherer |
| * |
| * Code for locale display names, separated out from other .cpp files |
| * that then do not depend on resource bundle code and display name data. |
| */ |
| |
| #include "unicode/utypes.h" |
| #include "unicode/brkiter.h" |
| #include "unicode/locid.h" |
| #include "unicode/uloc.h" |
| #include "unicode/ures.h" |
| #include "unicode/ustring.h" |
| #include "cmemory.h" |
| #include "cstring.h" |
| #include "putilimp.h" |
| #include "ulocimp.h" |
| #include "uresimp.h" |
| #include "ureslocs.h" |
| #include "ustr_imp.h" |
| |
| // C++ API ----------------------------------------------------------------- *** |
| |
| U_NAMESPACE_BEGIN |
| |
| 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 &displayLocale, |
| UnicodeString &result) const { |
| UChar *buffer; |
| UErrorCode errorCode=U_ZERO_ERROR; |
| int32_t length; |
| |
| buffer=result.getBuffer(ULOC_FULLNAME_CAPACITY); |
| if(buffer==0) { |
| result.truncate(0); |
| return result; |
| } |
| |
| length=uloc_getDisplayLanguage(fullName, displayLocale.fullName, |
| buffer, result.getCapacity(), |
| &errorCode); |
| result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0); |
| |
| if(errorCode==U_BUFFER_OVERFLOW_ERROR) { |
| buffer=result.getBuffer(length); |
| if(buffer==0) { |
| result.truncate(0); |
| return result; |
| } |
| errorCode=U_ZERO_ERROR; |
| length=uloc_getDisplayLanguage(fullName, displayLocale.fullName, |
| buffer, result.getCapacity(), |
| &errorCode); |
| result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0); |
| } |
| |
| return result; |
| } |
| |
| UnicodeString& |
| Locale::getDisplayScript(UnicodeString& dispScript) const |
| { |
| return this->getDisplayScript(getDefault(), dispScript); |
| } |
| |
| UnicodeString& |
| Locale::getDisplayScript(const Locale &displayLocale, |
| UnicodeString &result) const { |
| UChar *buffer; |
| UErrorCode errorCode=U_ZERO_ERROR; |
| int32_t length; |
| |
| buffer=result.getBuffer(ULOC_FULLNAME_CAPACITY); |
| if(buffer==0) { |
| result.truncate(0); |
| return result; |
| } |
| |
| length=uloc_getDisplayScript(fullName, displayLocale.fullName, |
| buffer, result.getCapacity(), |
| &errorCode); |
| result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0); |
| |
| if(errorCode==U_BUFFER_OVERFLOW_ERROR) { |
| buffer=result.getBuffer(length); |
| if(buffer==0) { |
| result.truncate(0); |
| return result; |
| } |
| errorCode=U_ZERO_ERROR; |
| length=uloc_getDisplayScript(fullName, displayLocale.fullName, |
| buffer, result.getCapacity(), |
| &errorCode); |
| result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0); |
| } |
| |
| return result; |
| } |
| |
| UnicodeString& |
| Locale::getDisplayCountry(UnicodeString& dispCntry) const |
| { |
| return this->getDisplayCountry(getDefault(), dispCntry); |
| } |
| |
| UnicodeString& |
| Locale::getDisplayCountry(const Locale &displayLocale, |
| UnicodeString &result) const { |
| UChar *buffer; |
| UErrorCode errorCode=U_ZERO_ERROR; |
| int32_t length; |
| |
| buffer=result.getBuffer(ULOC_FULLNAME_CAPACITY); |
| if(buffer==0) { |
| result.truncate(0); |
| return result; |
| } |
| |
| length=uloc_getDisplayCountry(fullName, displayLocale.fullName, |
| buffer, result.getCapacity(), |
| &errorCode); |
| result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0); |
| |
| if(errorCode==U_BUFFER_OVERFLOW_ERROR) { |
| buffer=result.getBuffer(length); |
| if(buffer==0) { |
| result.truncate(0); |
| return result; |
| } |
| errorCode=U_ZERO_ERROR; |
| length=uloc_getDisplayCountry(fullName, displayLocale.fullName, |
| buffer, result.getCapacity(), |
| &errorCode); |
| result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0); |
| } |
| |
| return result; |
| } |
| |
| UnicodeString& |
| Locale::getDisplayVariant(UnicodeString& dispVar) const |
| { |
| return this->getDisplayVariant(getDefault(), dispVar); |
| } |
| |
| UnicodeString& |
| Locale::getDisplayVariant(const Locale &displayLocale, |
| UnicodeString &result) const { |
| UChar *buffer; |
| UErrorCode errorCode=U_ZERO_ERROR; |
| int32_t length; |
| |
| buffer=result.getBuffer(ULOC_FULLNAME_CAPACITY); |
| if(buffer==0) { |
| result.truncate(0); |
| return result; |
| } |
| |
| length=uloc_getDisplayVariant(fullName, displayLocale.fullName, |
| buffer, result.getCapacity(), |
| &errorCode); |
| result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0); |
| |
| if(errorCode==U_BUFFER_OVERFLOW_ERROR) { |
| buffer=result.getBuffer(length); |
| if(buffer==0) { |
| result.truncate(0); |
| return result; |
| } |
| errorCode=U_ZERO_ERROR; |
| length=uloc_getDisplayVariant(fullName, displayLocale.fullName, |
| buffer, result.getCapacity(), |
| &errorCode); |
| result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0); |
| } |
| |
| return result; |
| } |
| |
| UnicodeString& |
| Locale::getDisplayName( UnicodeString& name ) const |
| { |
| return this->getDisplayName(getDefault(), name); |
| } |
| |
| UnicodeString& |
| Locale::getDisplayName(const Locale &displayLocale, |
| UnicodeString &result) const { |
| UChar *buffer; |
| UErrorCode errorCode=U_ZERO_ERROR; |
| int32_t length; |
| |
| buffer=result.getBuffer(ULOC_FULLNAME_CAPACITY); |
| if(buffer==0) { |
| result.truncate(0); |
| return result; |
| } |
| |
| length=uloc_getDisplayName(fullName, displayLocale.fullName, |
| buffer, result.getCapacity(), |
| &errorCode); |
| result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0); |
| |
| if(errorCode==U_BUFFER_OVERFLOW_ERROR) { |
| buffer=result.getBuffer(length); |
| if(buffer==0) { |
| result.truncate(0); |
| return result; |
| } |
| errorCode=U_ZERO_ERROR; |
| length=uloc_getDisplayName(fullName, displayLocale.fullName, |
| buffer, result.getCapacity(), |
| &errorCode); |
| result.releaseBuffer(U_SUCCESS(errorCode) ? length : 0); |
| } |
| |
| return result; |
| } |
| |
| #if ! UCONFIG_NO_BREAK_ITERATION |
| |
| // ------------------------------------- |
| // Gets the objectLocale display name in the default locale language. |
| UnicodeString& U_EXPORT2 |
| BreakIterator::getDisplayName(const Locale& objectLocale, |
| UnicodeString& name) |
| { |
| return objectLocale.getDisplayName(name); |
| } |
| |
| // ------------------------------------- |
| // Gets the objectLocale display name in the displayLocale language. |
| UnicodeString& U_EXPORT2 |
| BreakIterator::getDisplayName(const Locale& objectLocale, |
| const Locale& displayLocale, |
| UnicodeString& name) |
| { |
| return objectLocale.getDisplayName(displayLocale, name); |
| } |
| |
| #endif |
| |
| |
| U_NAMESPACE_END |
| |
| // C API ------------------------------------------------------------------- *** |
| |
| U_NAMESPACE_USE |
| |
| /* ### Constants **************************************************/ |
| |
| /* These strings describe the resources we attempt to load from |
| the locale ResourceBundle data file.*/ |
| static const char _kLanguages[] = "Languages"; |
| static const char _kScripts[] = "Scripts"; |
| static const char _kScriptsStandAlone[] = "Scripts%stand-alone"; |
| static const char _kCountries[] = "Countries"; |
| static const char _kVariants[] = "Variants"; |
| static const char _kKeys[] = "Keys"; |
| static const char _kTypes[] = "Types"; |
| //static const char _kRootName[] = "root"; |
| static const char _kCurrency[] = "currency"; |
| static const char _kCurrencies[] = "Currencies"; |
| static const char _kLocaleDisplayPattern[] = "localeDisplayPattern"; |
| static const char _kPattern[] = "pattern"; |
| static const char _kSeparator[] = "separator"; |
| |
| /* ### Display name **************************************************/ |
| |
| static int32_t |
| _getStringOrCopyKey(const char *path, const char *locale, |
| const char *tableKey, |
| const char* subTableKey, |
| const char *itemKey, |
| const char *substitute, |
| UChar *dest, int32_t destCapacity, |
| UErrorCode *pErrorCode) { |
| const UChar *s = NULL; |
| int32_t length = 0; |
| |
| if(itemKey==NULL) { |
| /* top-level item: normal resource bundle access */ |
| UResourceBundle *rb; |
| |
| rb=ures_open(path, locale, pErrorCode); |
| |
| if(U_SUCCESS(*pErrorCode)) { |
| s=ures_getStringByKey(rb, tableKey, &length, pErrorCode); |
| /* see comment about closing rb near "return item;" in _res_getTableStringWithFallback() */ |
| ures_close(rb); |
| } |
| } else { |
| /* Language code should not be a number. If it is, set the error code. */ |
| if (!uprv_strncmp(tableKey, "Languages", 9) && uprv_strtol(itemKey, NULL, 10)) { |
| *pErrorCode = U_MISSING_RESOURCE_ERROR; |
| } else { |
| /* second-level item, use special fallback */ |
| s=uloc_getTableStringWithFallback(path, locale, |
| tableKey, |
| subTableKey, |
| itemKey, |
| &length, |
| pErrorCode); |
| } |
| } |
| |
| if(U_SUCCESS(*pErrorCode)) { |
| int32_t copyLength=uprv_min(length, destCapacity); |
| if(copyLength>0 && s != NULL) { |
| u_memcpy(dest, s, copyLength); |
| } |
| } else { |
| /* no string from a resource bundle: convert the substitute */ |
| length=(int32_t)uprv_strlen(substitute); |
| u_charsToUChars(substitute, dest, uprv_min(length, destCapacity)); |
| *pErrorCode=U_USING_DEFAULT_WARNING; |
| } |
| |
| return u_terminateUChars(dest, destCapacity, length, pErrorCode); |
| } |
| |
| typedef int32_t U_CALLCONV UDisplayNameGetter(const char *, char *, int32_t, UErrorCode *); |
| |
| static int32_t |
| _getDisplayNameForComponent(const char *locale, |
| const char *displayLocale, |
| UChar *dest, int32_t destCapacity, |
| UDisplayNameGetter *getter, |
| const char *tag, |
| UErrorCode *pErrorCode) { |
| char localeBuffer[ULOC_FULLNAME_CAPACITY*4]; |
| int32_t length; |
| UErrorCode localStatus; |
| const char* root = NULL; |
| |
| /* argument checking */ |
| if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { |
| return 0; |
| } |
| |
| if(destCapacity<0 || (destCapacity>0 && dest==NULL)) { |
| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; |
| return 0; |
| } |
| |
| localStatus = U_ZERO_ERROR; |
| length=(*getter)(locale, localeBuffer, sizeof(localeBuffer), &localStatus); |
| if(U_FAILURE(localStatus) || localStatus==U_STRING_NOT_TERMINATED_WARNING) { |
| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; |
| return 0; |
| } |
| if(length==0) { |
| return u_terminateUChars(dest, destCapacity, 0, pErrorCode); |
| } |
| |
| root = tag == _kCountries ? U_ICUDATA_REGION : U_ICUDATA_LANG; |
| |
| return _getStringOrCopyKey(root, displayLocale, |
| tag, NULL, localeBuffer, |
| localeBuffer, |
| dest, destCapacity, |
| pErrorCode); |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| uloc_getDisplayLanguage(const char *locale, |
| const char *displayLocale, |
| UChar *dest, int32_t destCapacity, |
| UErrorCode *pErrorCode) { |
| return _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity, |
| uloc_getLanguage, _kLanguages, pErrorCode); |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| uloc_getDisplayScript(const char* locale, |
| const char* displayLocale, |
| UChar *dest, int32_t destCapacity, |
| UErrorCode *pErrorCode) |
| { |
| UErrorCode err = U_ZERO_ERROR; |
| int32_t res = _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity, |
| uloc_getScript, _kScriptsStandAlone, &err); |
| |
| if ( err == U_USING_DEFAULT_WARNING ) { |
| return _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity, |
| uloc_getScript, _kScripts, pErrorCode); |
| } else { |
| *pErrorCode = err; |
| return res; |
| } |
| } |
| |
| U_INTERNAL int32_t U_EXPORT2 |
| uloc_getDisplayScriptInContext(const char* locale, |
| const char* displayLocale, |
| UChar *dest, int32_t destCapacity, |
| UErrorCode *pErrorCode) |
| { |
| return _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity, |
| uloc_getScript, _kScripts, pErrorCode); |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| uloc_getDisplayCountry(const char *locale, |
| const char *displayLocale, |
| UChar *dest, int32_t destCapacity, |
| UErrorCode *pErrorCode) { |
| return _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity, |
| uloc_getCountry, _kCountries, pErrorCode); |
| } |
| |
| /* |
| * TODO separate variant1_variant2_variant3... |
| * by getting each tag's display string and concatenating them with ", " |
| * in between - similar to uloc_getDisplayName() |
| */ |
| U_CAPI int32_t U_EXPORT2 |
| uloc_getDisplayVariant(const char *locale, |
| const char *displayLocale, |
| UChar *dest, int32_t destCapacity, |
| UErrorCode *pErrorCode) { |
| return _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity, |
| uloc_getVariant, _kVariants, pErrorCode); |
| } |
| |
| /* Instead of having a separate pass for 'special' patterns, reintegrate the two |
| * so we don't get bitten by preflight bugs again. We can be reasonably efficient |
| * without two separate code paths, this code isn't that performance-critical. |
| * |
| * This code is general enough to deal with patterns that have a prefix or swap the |
| * language and remainder components, since we gave developers enough rope to do such |
| * things if they futz with the pattern data. But since we don't give them a way to |
| * specify a pattern for arbitrary combinations of components, there's not much use in |
| * that. I don't think our data includes such patterns, the only variable I know if is |
| * whether there is a space before the open paren, or not. Oh, and zh uses different |
| * chars than the standard open/close paren (which ja and ko use, btw). |
| */ |
| U_CAPI int32_t U_EXPORT2 |
| uloc_getDisplayName(const char *locale, |
| const char *displayLocale, |
| UChar *dest, int32_t destCapacity, |
| UErrorCode *pErrorCode) |
| { |
| static const UChar defaultSeparator[9] = { 0x007b, 0x0030, 0x007d, 0x002c, 0x0020, 0x007b, 0x0031, 0x007d, 0x0000 }; /* "{0}, {1}" */ |
| static const UChar sub0[4] = { 0x007b, 0x0030, 0x007d , 0x0000 } ; /* {0} */ |
| static const UChar sub1[4] = { 0x007b, 0x0031, 0x007d , 0x0000 } ; /* {1} */ |
| static const int32_t subLen = 3; |
| static const UChar defaultPattern[10] = { |
| 0x007b, 0x0030, 0x007d, 0x0020, 0x0028, 0x007b, 0x0031, 0x007d, 0x0029, 0x0000 |
| }; /* {0} ({1}) */ |
| static const int32_t defaultPatLen = 9; |
| static const int32_t defaultSub0Pos = 0; |
| static const int32_t defaultSub1Pos = 5; |
| |
| int32_t length; /* of formatted result */ |
| |
| const UChar *separator; |
| int32_t sepLen = 0; |
| const UChar *pattern; |
| int32_t patLen = 0; |
| int32_t sub0Pos, sub1Pos; |
| |
| UChar formatOpenParen = 0x0028; // ( |
| UChar formatReplaceOpenParen = 0x005B; // [ |
| UChar formatCloseParen = 0x0029; // ) |
| UChar formatReplaceCloseParen = 0x005D; // ] |
| |
| UBool haveLang = TRUE; /* assume true, set false if we find we don't have |
| a lang component in the locale */ |
| UBool haveRest = TRUE; /* assume true, set false if we find we don't have |
| any other component in the locale */ |
| UBool retry = FALSE; /* set true if we need to retry, see below */ |
| |
| int32_t langi = 0; /* index of the language substitution (0 or 1), virtually always 0 */ |
| |
| if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { |
| return 0; |
| } |
| |
| if(destCapacity<0 || (destCapacity>0 && dest==NULL)) { |
| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; |
| return 0; |
| } |
| |
| { |
| UErrorCode status = U_ZERO_ERROR; |
| UResourceBundle* locbundle=ures_open(U_ICUDATA_LANG, displayLocale, &status); |
| UResourceBundle* dspbundle=ures_getByKeyWithFallback(locbundle, _kLocaleDisplayPattern, |
| NULL, &status); |
| |
| separator=ures_getStringByKeyWithFallback(dspbundle, _kSeparator, &sepLen, &status); |
| pattern=ures_getStringByKeyWithFallback(dspbundle, _kPattern, &patLen, &status); |
| |
| ures_close(dspbundle); |
| ures_close(locbundle); |
| } |
| |
| /* If we couldn't find any data, then use the defaults */ |
| if(sepLen == 0) { |
| separator = defaultSeparator; |
| } |
| /* #10244: Even though separator is now a pattern, it is awkward to handle it as such |
| * here since we are trying to build the display string in place in the dest buffer, |
| * and to handle it as a pattern would entail having separate storage for the |
| * substrings that need to be combined (the first of which may be the result of |
| * previous such combinations). So for now we continue to treat the portion between |
| * {0} and {1} as a string to be appended when joining substrings, ignoring anything |
| * that is before {0} or after {1} (no existing separator pattern has any such thing). |
| * This is similar to how pattern is handled below. |
| */ |
| { |
| UChar *p0=u_strstr(separator, sub0); |
| UChar *p1=u_strstr(separator, sub1); |
| if (p0==NULL || p1==NULL || p1<p0) { |
| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; |
| return 0; |
| } |
| separator = (const UChar *)p0 + subLen; |
| sepLen = p1 - separator; |
| } |
| |
| if(patLen==0 || (patLen==defaultPatLen && !u_strncmp(pattern, defaultPattern, patLen))) { |
| pattern=defaultPattern; |
| patLen=defaultPatLen; |
| sub0Pos=defaultSub0Pos; |
| sub1Pos=defaultSub1Pos; |
| // use default formatOpenParen etc. set above |
| } else { /* non-default pattern */ |
| UChar *p0=u_strstr(pattern, sub0); |
| UChar *p1=u_strstr(pattern, sub1); |
| if (p0==NULL || p1==NULL) { |
| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; |
| return 0; |
| } |
| sub0Pos=p0-pattern; |
| sub1Pos=p1-pattern; |
| if (sub1Pos < sub0Pos) { /* a very odd pattern */ |
| int32_t t=sub0Pos; sub0Pos=sub1Pos; sub1Pos=t; |
| langi=1; |
| } |
| if (u_strchr(pattern, 0xFF08) != NULL) { |
| formatOpenParen = 0xFF08; // fullwidth ( |
| formatReplaceOpenParen = 0xFF3B; // fullwidth [ |
| formatCloseParen = 0xFF09; // fullwidth ) |
| formatReplaceCloseParen = 0xFF3D; // fullwidth ] |
| } |
| } |
| |
| /* We loop here because there is one case in which after the first pass we could need to |
| * reextract the data. If there's initial padding before the first element, we put in |
| * the padding and then write that element. If it turns out there's no second element, |
| * we didn't need the padding. If we do need the data (no preflight), and the first element |
| * would have fit but for the padding, we need to reextract. In this case (only) we |
| * adjust the parameters so padding is not added, and repeat. |
| */ |
| do { |
| UChar* p=dest; |
| int32_t patPos=0; /* position in the pattern, used for non-substitution portions */ |
| int32_t langLen=0; /* length of language substitution */ |
| int32_t langPos=0; /* position in output of language substitution */ |
| int32_t restLen=0; /* length of 'everything else' substitution */ |
| int32_t restPos=0; /* position in output of 'everything else' substitution */ |
| UEnumeration* kenum = NULL; /* keyword enumeration */ |
| |
| /* prefix of pattern, extremely likely to be empty */ |
| if(sub0Pos) { |
| if(destCapacity >= sub0Pos) { |
| while (patPos < sub0Pos) { |
| *p++ = pattern[patPos++]; |
| } |
| } else { |
| patPos=sub0Pos; |
| } |
| length=sub0Pos; |
| } else { |
| length=0; |
| } |
| |
| for(int32_t subi=0,resti=0;subi<2;) { /* iterate through patterns 0 and 1*/ |
| UBool subdone = FALSE; /* set true when ready to move to next substitution */ |
| |
| /* prep p and cap for calls to get display components, pin cap to 0 since |
| they complain if cap is negative */ |
| int32_t cap=destCapacity-length; |
| if (cap <= 0) { |
| cap=0; |
| } else { |
| p=dest+length; |
| } |
| |
| if (subi == langi) { /* {0}*/ |
| if(haveLang) { |
| langPos=length; |
| langLen=uloc_getDisplayLanguage(locale, displayLocale, p, cap, pErrorCode); |
| length+=langLen; |
| haveLang=langLen>0; |
| } |
| subdone=TRUE; |
| } else { /* {1} */ |
| if(!haveRest) { |
| subdone=TRUE; |
| } else { |
| int32_t len; /* length of component (plus other stuff) we just fetched */ |
| switch(resti++) { |
| case 0: |
| restPos=length; |
| len=uloc_getDisplayScriptInContext(locale, displayLocale, p, cap, pErrorCode); |
| break; |
| case 1: |
| len=uloc_getDisplayCountry(locale, displayLocale, p, cap, pErrorCode); |
| break; |
| case 2: |
| len=uloc_getDisplayVariant(locale, displayLocale, p, cap, pErrorCode); |
| break; |
| case 3: |
| kenum = uloc_openKeywords(locale, pErrorCode); |
| /* fall through */ |
| default: { |
| const char* kw=uenum_next(kenum, &len, pErrorCode); |
| if (kw == NULL) { |
| uenum_close(kenum); |
| len=0; /* mark that we didn't add a component */ |
| subdone=TRUE; |
| } else { |
| /* incorporating this behavior into the loop made it even more complex, |
| so just special case it here */ |
| len = uloc_getDisplayKeyword(kw, displayLocale, p, cap, pErrorCode); |
| if(len) { |
| if(len < cap) { |
| p[len]=0x3d; /* '=', assume we'll need it */ |
| } |
| len+=1; |
| |
| /* adjust for call to get keyword */ |
| cap-=len; |
| if(cap <= 0) { |
| cap=0; |
| } else { |
| p+=len; |
| } |
| } |
| /* reset for call below */ |
| if(*pErrorCode == U_BUFFER_OVERFLOW_ERROR) { |
| *pErrorCode=U_ZERO_ERROR; |
| } |
| int32_t vlen = uloc_getDisplayKeywordValue(locale, kw, displayLocale, |
| p, cap, pErrorCode); |
| if(len) { |
| if(vlen==0) { |
| --len; /* remove unneeded '=' */ |
| } |
| /* restore cap and p to what they were at start */ |
| cap=destCapacity-length; |
| if(cap <= 0) { |
| cap=0; |
| } else { |
| p=dest+length; |
| } |
| } |
| len+=vlen; /* total we added for key + '=' + value */ |
| } |
| } break; |
| } /* end switch */ |
| |
| if (len>0) { |
| /* we addeed a component, so add separator and write it if there's room. */ |
| if(len+sepLen<=cap) { |
| const UChar * plimit = p + len; |
| for (; p < plimit; p++) { |
| if (*p == formatOpenParen) { |
| *p = formatReplaceOpenParen; |
| } else if (*p == formatCloseParen) { |
| *p = formatReplaceCloseParen; |
| } |
| } |
| for(int32_t i=0;i<sepLen;++i) { |
| *p++=separator[i]; |
| } |
| } |
| length+=len+sepLen; |
| } else if(subdone) { |
| /* remove separator if we added it */ |
| if (length!=restPos) { |
| length-=sepLen; |
| } |
| restLen=length-restPos; |
| haveRest=restLen>0; |
| } |
| } |
| } |
| |
| if(*pErrorCode == U_BUFFER_OVERFLOW_ERROR) { |
| *pErrorCode=U_ZERO_ERROR; |
| } |
| |
| if(subdone) { |
| if(haveLang && haveRest) { |
| /* append internal portion of pattern, the first time, |
| or last portion of pattern the second time */ |
| int32_t padLen; |
| patPos+=subLen; |
| padLen=(subi==0 ? sub1Pos : patLen)-patPos; |
| if(length+padLen < destCapacity) { |
| p=dest+length; |
| for(int32_t i=0;i<padLen;++i) { |
| *p++=pattern[patPos++]; |
| } |
| } else { |
| patPos+=padLen; |
| } |
| length+=padLen; |
| } else if(subi==0) { |
| /* don't have first component, reset for second component */ |
| sub0Pos=0; |
| length=0; |
| } else if(length>0) { |
| /* true length is the length of just the component we got. */ |
| length=haveLang?langLen:restLen; |
| if(dest && sub0Pos!=0) { |
| if (sub0Pos+length<=destCapacity) { |
| /* first component not at start of result, |
| but we have full component in buffer. */ |
| u_memmove(dest, dest+(haveLang?langPos:restPos), length); |
| } else { |
| /* would have fit, but didn't because of pattern prefix. */ |
| sub0Pos=0; /* stops initial padding (and a second retry, |
| so we won't end up here again) */ |
| retry=TRUE; |
| } |
| } |
| } |
| |
| ++subi; /* move on to next substitution */ |
| } |
| } |
| } while(retry); |
| |
| return u_terminateUChars(dest, destCapacity, length, pErrorCode); |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| uloc_getDisplayKeyword(const char* keyword, |
| const char* displayLocale, |
| UChar* dest, |
| int32_t destCapacity, |
| UErrorCode* status){ |
| |
| /* argument checking */ |
| if(status==NULL || U_FAILURE(*status)) { |
| return 0; |
| } |
| |
| if(destCapacity<0 || (destCapacity>0 && dest==NULL)) { |
| *status=U_ILLEGAL_ARGUMENT_ERROR; |
| return 0; |
| } |
| |
| |
| /* pass itemKey=NULL to look for a top-level item */ |
| return _getStringOrCopyKey(U_ICUDATA_LANG, displayLocale, |
| _kKeys, NULL, |
| keyword, |
| keyword, |
| dest, destCapacity, |
| status); |
| |
| } |
| |
| |
| #define UCURRENCY_DISPLAY_NAME_INDEX 1 |
| |
| U_CAPI int32_t U_EXPORT2 |
| uloc_getDisplayKeywordValue( const char* locale, |
| const char* keyword, |
| const char* displayLocale, |
| UChar* dest, |
| int32_t destCapacity, |
| UErrorCode* status){ |
| |
| |
| char keywordValue[ULOC_FULLNAME_CAPACITY*4]; |
| int32_t capacity = ULOC_FULLNAME_CAPACITY*4; |
| int32_t keywordValueLen =0; |
| |
| /* argument checking */ |
| if(status==NULL || U_FAILURE(*status)) { |
| return 0; |
| } |
| |
| if(destCapacity<0 || (destCapacity>0 && dest==NULL)) { |
| *status=U_ILLEGAL_ARGUMENT_ERROR; |
| return 0; |
| } |
| |
| /* get the keyword value */ |
| keywordValue[0]=0; |
| keywordValueLen = uloc_getKeywordValue(locale, keyword, keywordValue, capacity, status); |
| |
| /* |
| * if the keyword is equal to currency .. then to get the display name |
| * we need to do the fallback ourselves |
| */ |
| if(uprv_stricmp(keyword, _kCurrency)==0){ |
| |
| int32_t dispNameLen = 0; |
| const UChar *dispName = NULL; |
| |
| UResourceBundle *bundle = ures_open(U_ICUDATA_CURR, displayLocale, status); |
| UResourceBundle *currencies = ures_getByKey(bundle, _kCurrencies, NULL, status); |
| UResourceBundle *currency = ures_getByKeyWithFallback(currencies, keywordValue, NULL, status); |
| |
| dispName = ures_getStringByIndex(currency, UCURRENCY_DISPLAY_NAME_INDEX, &dispNameLen, status); |
| |
| /*close the bundles */ |
| ures_close(currency); |
| ures_close(currencies); |
| ures_close(bundle); |
| |
| if(U_FAILURE(*status)){ |
| if(*status == U_MISSING_RESOURCE_ERROR){ |
| /* we just want to write the value over if nothing is available */ |
| *status = U_USING_DEFAULT_WARNING; |
| }else{ |
| return 0; |
| } |
| } |
| |
| /* now copy the dispName over if not NULL */ |
| if(dispName != NULL){ |
| if(dispNameLen <= destCapacity){ |
| uprv_memcpy(dest, dispName, dispNameLen * U_SIZEOF_UCHAR); |
| return u_terminateUChars(dest, destCapacity, dispNameLen, status); |
| }else{ |
| *status = U_BUFFER_OVERFLOW_ERROR; |
| return dispNameLen; |
| } |
| }else{ |
| /* we have not found the display name for the value .. just copy over */ |
| if(keywordValueLen <= destCapacity){ |
| u_charsToUChars(keywordValue, dest, keywordValueLen); |
| return u_terminateUChars(dest, destCapacity, keywordValueLen, status); |
| }else{ |
| *status = U_BUFFER_OVERFLOW_ERROR; |
| return keywordValueLen; |
| } |
| } |
| |
| |
| }else{ |
| |
| return _getStringOrCopyKey(U_ICUDATA_LANG, displayLocale, |
| _kTypes, keyword, |
| keywordValue, |
| keywordValue, |
| dest, destCapacity, |
| status); |
| } |
| } |
