| /* |
| ********************************************************************** |
| * Copyright (c) 2002-2014, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| ********************************************************************** |
| */ |
| |
| #include "unicode/utypes.h" |
| |
| #if !UCONFIG_NO_FORMATTING |
| |
| #include "starboard/client_porting/poem/assert_poem.h" |
| #include "starboard/client_porting/poem/string_poem.h" |
| #include "starboard/client_porting/poem/stdlib_poem.h" |
| #include "unicode/ucurr.h" |
| #include "unicode/locid.h" |
| #include "unicode/ures.h" |
| #include "unicode/ustring.h" |
| #include "unicode/choicfmt.h" |
| #include "unicode/parsepos.h" |
| #include "ustr_imp.h" |
| #include "cmemory.h" |
| #include "cstring.h" |
| #include "uassert.h" |
| #include "umutex.h" |
| #include "ucln_in.h" |
| #include "uenumimp.h" |
| #include "uhash.h" |
| #include "hash.h" |
| #include "uresimp.h" |
| #include "ulist.h" |
| #include "ureslocs.h" |
| |
| //#define UCURR_DEBUG_EQUIV 1 |
| #ifdef UCURR_DEBUG_EQUIV |
| #include "stdio.h" |
| #endif |
| //#define UCURR_DEBUG 1 |
| #ifdef UCURR_DEBUG |
| #include "stdio.h" |
| #endif |
| |
| typedef struct IsoCodeEntry { |
| const UChar *isoCode; /* const because it's a reference to a resource bundle string. */ |
| UDate from; |
| UDate to; |
| } IsoCodeEntry; |
| |
| //------------------------------------------------------------ |
| // Constants |
| |
| // Default currency meta data of last resort. We try to use the |
| // defaults encoded in the meta data resource bundle. If there is a |
| // configuration/build error and these are not available, we use these |
| // hard-coded defaults (which should be identical). |
| static const int32_t LAST_RESORT_DATA[] = { 2, 0, 2, 0 }; |
| |
| // POW10[i] = 10^i, i=0..MAX_POW10 |
| static const int32_t POW10[] = { 1, 10, 100, 1000, 10000, 100000, |
| 1000000, 10000000, 100000000, 1000000000 }; |
| |
| static const int32_t MAX_POW10 = (sizeof(POW10)/sizeof(POW10[0])) - 1; |
| |
| // Defines equivalent currency symbols. |
| static const char *EQUIV_CURRENCY_SYMBOLS[][2] = { |
| {"\\u00a5", "\\uffe5"}, |
| {"$", "\\ufe69"}, |
| {"$", "\\uff04"}, |
| {"\\u20a8", "\\u20b9"}, |
| {"\\u00a3", "\\u20a4"}}; |
| |
| #define ISO_CURRENCY_CODE_LENGTH 3 |
| |
| //------------------------------------------------------------ |
| // Resource tags |
| // |
| |
| static const char CURRENCY_DATA[] = "supplementalData"; |
| // Tag for meta-data, in root. |
| static const char CURRENCY_META[] = "CurrencyMeta"; |
| |
| // Tag for map from countries to currencies, in root. |
| static const char CURRENCY_MAP[] = "CurrencyMap"; |
| |
| // Tag for default meta-data, in CURRENCY_META |
| static const char DEFAULT_META[] = "DEFAULT"; |
| |
| // Variant for legacy pre-euro mapping in CurrencyMap |
| static const char VAR_PRE_EURO[] = "PREEURO"; |
| |
| // Variant for legacy euro mapping in CurrencyMap |
| static const char VAR_EURO[] = "EURO"; |
| |
| // Variant delimiter |
| static const char VAR_DELIM = '_'; |
| static const char VAR_DELIM_STR[] = "_"; |
| |
| // Variant for legacy euro mapping in CurrencyMap |
| //static const char VAR_DELIM_EURO[] = "_EURO"; |
| |
| #define VARIANT_IS_EMPTY 0 |
| #define VARIANT_IS_EURO 0x1 |
| #define VARIANT_IS_PREEURO 0x2 |
| |
| // Tag for localized display names (symbols) of currencies |
| static const char CURRENCIES[] = "Currencies"; |
| static const char CURRENCYPLURALS[] = "CurrencyPlurals"; |
| |
| // Marker character indicating that a display name is a ChoiceFormat |
| // pattern. Strings that start with one mark are ChoiceFormat |
| // patterns. Strings that start with 2 marks are static strings, and |
| // the first mark is deleted. |
| static const UChar CHOICE_FORMAT_MARK = 0x003D; // Equals sign |
| |
| static const UChar EUR_STR[] = {0x0045,0x0055,0x0052,0}; |
| |
| // ISO codes mapping table |
| static const UHashtable* gIsoCodes = NULL; |
| static icu::UInitOnce gIsoCodesInitOnce = U_INITONCE_INITIALIZER; |
| |
| // Currency symbol equivalances |
| static const icu::Hashtable* gCurrSymbolsEquiv = NULL; |
| static icu::UInitOnce gCurrSymbolsEquivInitOnce = U_INITONCE_INITIALIZER; |
| |
| U_NAMESPACE_BEGIN |
| |
| // EquivIterator iterates over all strings that are equivalent to a given |
| // string, s. Note that EquivIterator will never yield s itself. |
| class EquivIterator : icu::UMemory { |
| public: |
| // Constructor. hash stores the equivalence relationships; s is the string |
| // for which we find equivalent strings. |
| inline EquivIterator(const icu::Hashtable& hash, const icu::UnicodeString& s) |
| : _hash(hash) { |
| _start = _current = &s; |
| } |
| inline ~EquivIterator() { } |
| |
| // next returns the next equivalent string or NULL if there are no more. |
| // If s has no equivalent strings, next returns NULL on the first call. |
| const icu::UnicodeString *next(); |
| private: |
| const icu::Hashtable& _hash; |
| const icu::UnicodeString* _start; |
| const icu::UnicodeString* _current; |
| }; |
| |
| const icu::UnicodeString * |
| EquivIterator::next() { |
| const icu::UnicodeString* _next = (const icu::UnicodeString*) _hash.get(*_current); |
| if (_next == NULL) { |
| U_ASSERT(_current == _start); |
| return NULL; |
| } |
| if (*_next == *_start) { |
| return NULL; |
| } |
| _current = _next; |
| return _next; |
| } |
| |
| U_NAMESPACE_END |
| |
| // makeEquivalent makes lhs and rhs equivalent by updating the equivalence |
| // relations in hash accordingly. |
| static void makeEquivalent( |
| const icu::UnicodeString &lhs, |
| const icu::UnicodeString &rhs, |
| icu::Hashtable* hash, UErrorCode &status) { |
| if (U_FAILURE(status)) { |
| return; |
| } |
| if (lhs == rhs) { |
| // already equivalent |
| return; |
| } |
| icu::EquivIterator leftIter(*hash, lhs); |
| icu::EquivIterator rightIter(*hash, rhs); |
| const icu::UnicodeString *firstLeft = leftIter.next(); |
| const icu::UnicodeString *firstRight = rightIter.next(); |
| const icu::UnicodeString *nextLeft = firstLeft; |
| const icu::UnicodeString *nextRight = firstRight; |
| while (nextLeft != NULL && nextRight != NULL) { |
| if (*nextLeft == rhs || *nextRight == lhs) { |
| // Already equivalent |
| return; |
| } |
| nextLeft = leftIter.next(); |
| nextRight = rightIter.next(); |
| } |
| // Not equivalent. Must join. |
| icu::UnicodeString *newFirstLeft; |
| icu::UnicodeString *newFirstRight; |
| if (firstRight == NULL && firstLeft == NULL) { |
| // Neither lhs or rhs belong to an equivalence circle, so we form |
| // a new equivalnce circle of just lhs and rhs. |
| newFirstLeft = new icu::UnicodeString(rhs); |
| newFirstRight = new icu::UnicodeString(lhs); |
| } else if (firstRight == NULL) { |
| // lhs belongs to an equivalence circle, but rhs does not, so we link |
| // rhs into lhs' circle. |
| newFirstLeft = new icu::UnicodeString(rhs); |
| newFirstRight = new icu::UnicodeString(*firstLeft); |
| } else if (firstLeft == NULL) { |
| // rhs belongs to an equivlance circle, but lhs does not, so we link |
| // lhs into rhs' circle. |
| newFirstLeft = new icu::UnicodeString(*firstRight); |
| newFirstRight = new icu::UnicodeString(lhs); |
| } else { |
| // Both lhs and rhs belong to different equivalnce circles. We link |
| // them together to form one single, larger equivalnce circle. |
| newFirstLeft = new icu::UnicodeString(*firstRight); |
| newFirstRight = new icu::UnicodeString(*firstLeft); |
| } |
| if (newFirstLeft == NULL || newFirstRight == NULL) { |
| delete newFirstLeft; |
| delete newFirstRight; |
| status = U_MEMORY_ALLOCATION_ERROR; |
| return; |
| } |
| hash->put(lhs, (void *) newFirstLeft, status); |
| hash->put(rhs, (void *) newFirstRight, status); |
| } |
| |
| // countEquivalent counts how many strings are equivalent to s. |
| // hash stores all the equivalnce relations. |
| // countEquivalent does not include s itself in the count. |
| static int32_t countEquivalent(const icu::Hashtable &hash, const icu::UnicodeString &s) { |
| int32_t result = 0; |
| icu::EquivIterator iter(hash, s); |
| while (iter.next() != NULL) { |
| ++result; |
| } |
| #ifdef UCURR_DEBUG_EQUIV |
| { |
| char tmp[200]; |
| s.extract(0,s.length(),tmp, "UTF-8"); |
| printf("CountEquivalent('%s') = %d\n", tmp, result); |
| } |
| #endif |
| return result; |
| } |
| |
| static const icu::Hashtable* getCurrSymbolsEquiv(); |
| |
| //------------------------------------------------------------ |
| // Code |
| |
| /** |
| * Cleanup callback func |
| */ |
| static UBool U_CALLCONV |
| isoCodes_cleanup(void) |
| { |
| if (gIsoCodes != NULL) { |
| uhash_close(const_cast<UHashtable *>(gIsoCodes)); |
| gIsoCodes = NULL; |
| } |
| gIsoCodesInitOnce.reset(); |
| return TRUE; |
| } |
| |
| /** |
| * Cleanup callback func |
| */ |
| static UBool U_CALLCONV |
| currSymbolsEquiv_cleanup(void) |
| { |
| delete const_cast<icu::Hashtable *>(gCurrSymbolsEquiv); |
| gCurrSymbolsEquiv = NULL; |
| gCurrSymbolsEquivInitOnce.reset(); |
| return TRUE; |
| } |
| |
| /** |
| * Deleter for OlsonToMetaMappingEntry |
| */ |
| static void U_CALLCONV |
| deleteIsoCodeEntry(void *obj) { |
| IsoCodeEntry *entry = (IsoCodeEntry*)obj; |
| uprv_free(entry); |
| } |
| |
| /** |
| * Deleter for gCurrSymbolsEquiv. |
| */ |
| static void U_CALLCONV |
| deleteUnicode(void *obj) { |
| icu::UnicodeString *entry = (icu::UnicodeString*)obj; |
| delete entry; |
| } |
| |
| /** |
| * Unfortunately, we have to convert the UChar* currency code to char* |
| * to use it as a resource key. |
| */ |
| static inline char* |
| myUCharsToChars(char* resultOfLen4, const UChar* currency) { |
| u_UCharsToChars(currency, resultOfLen4, ISO_CURRENCY_CODE_LENGTH); |
| resultOfLen4[ISO_CURRENCY_CODE_LENGTH] = 0; |
| return resultOfLen4; |
| } |
| |
| /** |
| * Internal function to look up currency data. Result is an array of |
| * four integers. The first is the fraction digits. The second is the |
| * rounding increment, or 0 if none. The rounding increment is in |
| * units of 10^(-fraction_digits). The third and fourth are the same |
| * except that they are those used in cash transations ( cashDigits |
| * and cashRounding ). |
| */ |
| static const int32_t* |
| _findMetaData(const UChar* currency, UErrorCode& ec) { |
| |
| if (currency == 0 || *currency == 0) { |
| if (U_SUCCESS(ec)) { |
| ec = U_ILLEGAL_ARGUMENT_ERROR; |
| } |
| return LAST_RESORT_DATA; |
| } |
| |
| // Get CurrencyMeta resource out of root locale file. [This may |
| // move out of the root locale file later; if it does, update this |
| // code.] |
| UResourceBundle* currencyData = ures_openDirect(U_ICUDATA_CURR, CURRENCY_DATA, &ec); |
| UResourceBundle* currencyMeta = ures_getByKey(currencyData, CURRENCY_META, currencyData, &ec); |
| |
| if (U_FAILURE(ec)) { |
| ures_close(currencyMeta); |
| // Config/build error; return hard-coded defaults |
| return LAST_RESORT_DATA; |
| } |
| |
| // Look up our currency, or if that's not available, then DEFAULT |
| char buf[ISO_CURRENCY_CODE_LENGTH+1]; |
| UErrorCode ec2 = U_ZERO_ERROR; // local error code: soft failure |
| UResourceBundle* rb = ures_getByKey(currencyMeta, myUCharsToChars(buf, currency), NULL, &ec2); |
| if (U_FAILURE(ec2)) { |
| ures_close(rb); |
| rb = ures_getByKey(currencyMeta,DEFAULT_META, NULL, &ec); |
| if (U_FAILURE(ec)) { |
| ures_close(currencyMeta); |
| ures_close(rb); |
| // Config/build error; return hard-coded defaults |
| return LAST_RESORT_DATA; |
| } |
| } |
| |
| int32_t len; |
| const int32_t *data = ures_getIntVector(rb, &len, &ec); |
| if (U_FAILURE(ec) || len != 4) { |
| // Config/build error; return hard-coded defaults |
| if (U_SUCCESS(ec)) { |
| ec = U_INVALID_FORMAT_ERROR; |
| } |
| ures_close(currencyMeta); |
| ures_close(rb); |
| return LAST_RESORT_DATA; |
| } |
| |
| ures_close(currencyMeta); |
| ures_close(rb); |
| return data; |
| } |
| |
| // ------------------------------------- |
| |
| /** |
| * @see VARIANT_IS_EURO |
| * @see VARIANT_IS_PREEURO |
| */ |
| static uint32_t |
| idForLocale(const char* locale, char* countryAndVariant, int capacity, UErrorCode* ec) |
| { |
| uint32_t variantType = 0; |
| // !!! this is internal only, assumes buffer is not null and capacity is sufficient |
| // Extract the country name and variant name. We only |
| // recognize two variant names, EURO and PREEURO. |
| char variant[ULOC_FULLNAME_CAPACITY]; |
| uloc_getCountry(locale, countryAndVariant, capacity, ec); |
| uloc_getVariant(locale, variant, sizeof(variant), ec); |
| if (variant[0] != 0) { |
| variantType = (uint32_t)(0 == uprv_strcmp(variant, VAR_EURO)) |
| | ((uint32_t)(0 == uprv_strcmp(variant, VAR_PRE_EURO)) << 1); |
| if (variantType) |
| { |
| uprv_strcat(countryAndVariant, VAR_DELIM_STR); |
| uprv_strcat(countryAndVariant, variant); |
| } |
| } |
| return variantType; |
| } |
| |
| // ------------------------------------------ |
| // |
| // Registration |
| // |
| //------------------------------------------- |
| |
| // don't use ICUService since we don't need fallback |
| |
| U_CDECL_BEGIN |
| static UBool U_CALLCONV currency_cleanup(void); |
| U_CDECL_END |
| |
| #if !UCONFIG_NO_SERVICE |
| struct CReg; |
| |
| static UMutex gCRegLock = U_MUTEX_INITIALIZER; |
| static CReg* gCRegHead = 0; |
| |
| struct CReg : public icu::UMemory { |
| CReg *next; |
| UChar iso[ISO_CURRENCY_CODE_LENGTH+1]; |
| char id[ULOC_FULLNAME_CAPACITY]; |
| |
| CReg(const UChar* _iso, const char* _id) |
| : next(0) |
| { |
| int32_t len = (int32_t)uprv_strlen(_id); |
| if (len > (int32_t)(sizeof(id)-1)) { |
| len = (sizeof(id)-1); |
| } |
| uprv_strncpy(id, _id, len); |
| id[len] = 0; |
| uprv_memcpy(iso, _iso, ISO_CURRENCY_CODE_LENGTH * sizeof(const UChar)); |
| iso[ISO_CURRENCY_CODE_LENGTH] = 0; |
| } |
| |
| static UCurrRegistryKey reg(const UChar* _iso, const char* _id, UErrorCode* status) |
| { |
| if (status && U_SUCCESS(*status) && _iso && _id) { |
| CReg* n = new CReg(_iso, _id); |
| if (n) { |
| umtx_lock(&gCRegLock); |
| if (!gCRegHead) { |
| /* register for the first time */ |
| ucln_i18n_registerCleanup(UCLN_I18N_CURRENCY, currency_cleanup); |
| } |
| n->next = gCRegHead; |
| gCRegHead = n; |
| umtx_unlock(&gCRegLock); |
| return n; |
| } |
| *status = U_MEMORY_ALLOCATION_ERROR; |
| } |
| return 0; |
| } |
| |
| static UBool unreg(UCurrRegistryKey key) { |
| UBool found = FALSE; |
| umtx_lock(&gCRegLock); |
| |
| CReg** p = &gCRegHead; |
| while (*p) { |
| if (*p == key) { |
| *p = ((CReg*)key)->next; |
| delete (CReg*)key; |
| found = TRUE; |
| break; |
| } |
| p = &((*p)->next); |
| } |
| |
| umtx_unlock(&gCRegLock); |
| return found; |
| } |
| |
| static const UChar* get(const char* id) { |
| const UChar* result = NULL; |
| umtx_lock(&gCRegLock); |
| CReg* p = gCRegHead; |
| |
| /* register cleanup of the mutex */ |
| ucln_i18n_registerCleanup(UCLN_I18N_CURRENCY, currency_cleanup); |
| while (p) { |
| if (uprv_strcmp(id, p->id) == 0) { |
| result = p->iso; |
| break; |
| } |
| p = p->next; |
| } |
| umtx_unlock(&gCRegLock); |
| return result; |
| } |
| |
| /* This doesn't need to be thread safe. It's for u_cleanup only. */ |
| static void cleanup(void) { |
| while (gCRegHead) { |
| CReg* n = gCRegHead; |
| gCRegHead = gCRegHead->next; |
| delete n; |
| } |
| } |
| }; |
| |
| // ------------------------------------- |
| |
| U_CAPI UCurrRegistryKey U_EXPORT2 |
| ucurr_register(const UChar* isoCode, const char* locale, UErrorCode *status) |
| { |
| if (status && U_SUCCESS(*status)) { |
| char id[ULOC_FULLNAME_CAPACITY]; |
| idForLocale(locale, id, sizeof(id), status); |
| return CReg::reg(isoCode, id, status); |
| } |
| return NULL; |
| } |
| |
| // ------------------------------------- |
| |
| U_CAPI UBool U_EXPORT2 |
| ucurr_unregister(UCurrRegistryKey key, UErrorCode* status) |
| { |
| if (status && U_SUCCESS(*status)) { |
| return CReg::unreg(key); |
| } |
| return FALSE; |
| } |
| #endif /* UCONFIG_NO_SERVICE */ |
| |
| // ------------------------------------- |
| |
| /** |
| * Release all static memory held by currency. |
| */ |
| /*The declaration here is needed so currency_cleanup(void) |
| * can call this function. |
| */ |
| static UBool U_CALLCONV |
| currency_cache_cleanup(void); |
| |
| U_CDECL_BEGIN |
| static UBool U_CALLCONV currency_cleanup(void) { |
| #if !UCONFIG_NO_SERVICE |
| CReg::cleanup(); |
| #endif |
| /* |
| * There might be some cached currency data or isoCodes data. |
| */ |
| currency_cache_cleanup(); |
| isoCodes_cleanup(); |
| currSymbolsEquiv_cleanup(); |
| |
| return TRUE; |
| } |
| U_CDECL_END |
| |
| // ------------------------------------- |
| |
| U_CAPI int32_t U_EXPORT2 |
| ucurr_forLocale(const char* locale, |
| UChar* buff, |
| int32_t buffCapacity, |
| UErrorCode* ec) |
| { |
| int32_t resLen = 0; |
| const UChar* s = NULL; |
| if (ec != NULL && U_SUCCESS(*ec)) { |
| if ((buff && buffCapacity) || !buffCapacity) { |
| UErrorCode localStatus = U_ZERO_ERROR; |
| char id[ULOC_FULLNAME_CAPACITY]; |
| if ((resLen = uloc_getKeywordValue(locale, "currency", id, ULOC_FULLNAME_CAPACITY, &localStatus))) { |
| // there is a currency keyword. Try to see if it's valid |
| if(buffCapacity > resLen) { |
| /* Normalize the currency keyword value to upper case. */ |
| T_CString_toUpperCase(id); |
| u_charsToUChars(id, buff, resLen); |
| } |
| } else { |
| // get country or country_variant in `id' |
| uint32_t variantType = idForLocale(locale, id, sizeof(id), ec); |
| |
| if (U_FAILURE(*ec)) { |
| return 0; |
| } |
| |
| #if !UCONFIG_NO_SERVICE |
| const UChar* result = CReg::get(id); |
| if (result) { |
| if(buffCapacity > u_strlen(result)) { |
| u_strcpy(buff, result); |
| } |
| return u_strlen(result); |
| } |
| #endif |
| // Remove variants, which is only needed for registration. |
| char *idDelim = strchr(id, VAR_DELIM); |
| if (idDelim) { |
| idDelim[0] = 0; |
| } |
| |
| // Look up the CurrencyMap element in the root bundle. |
| UResourceBundle *rb = ures_openDirect(U_ICUDATA_CURR, CURRENCY_DATA, &localStatus); |
| UResourceBundle *cm = ures_getByKey(rb, CURRENCY_MAP, rb, &localStatus); |
| UResourceBundle *countryArray = ures_getByKey(rb, id, cm, &localStatus); |
| UResourceBundle *currencyReq = ures_getByIndex(countryArray, 0, NULL, &localStatus); |
| s = ures_getStringByKey(currencyReq, "id", &resLen, &localStatus); |
| |
| /* |
| Get the second item when PREEURO is requested, and this is a known Euro country. |
| If the requested variant is PREEURO, and this isn't a Euro country, assume |
| that the country changed over to the Euro in the future. This is probably |
| an old version of ICU that hasn't been updated yet. The latest currency is |
| probably correct. |
| */ |
| if (U_SUCCESS(localStatus)) { |
| if ((variantType & VARIANT_IS_PREEURO) && u_strcmp(s, EUR_STR) == 0) { |
| currencyReq = ures_getByIndex(countryArray, 1, currencyReq, &localStatus); |
| s = ures_getStringByKey(currencyReq, "id", &resLen, &localStatus); |
| } |
| else if ((variantType & VARIANT_IS_EURO)) { |
| s = EUR_STR; |
| } |
| } |
| ures_close(countryArray); |
| ures_close(currencyReq); |
| |
| if ((U_FAILURE(localStatus)) && strchr(id, '_') != 0) |
| { |
| // We don't know about it. Check to see if we support the variant. |
| uloc_getParent(locale, id, sizeof(id), ec); |
| *ec = U_USING_FALLBACK_WARNING; |
| return ucurr_forLocale(id, buff, buffCapacity, ec); |
| } |
| else if (*ec == U_ZERO_ERROR || localStatus != U_ZERO_ERROR) { |
| // There is nothing to fallback to. Report the failure/warning if possible. |
| *ec = localStatus; |
| } |
| if (U_SUCCESS(*ec)) { |
| if(buffCapacity > resLen) { |
| u_strcpy(buff, s); |
| } |
| } |
| } |
| return u_terminateUChars(buff, buffCapacity, resLen, ec); |
| } else { |
| *ec = U_ILLEGAL_ARGUMENT_ERROR; |
| } |
| } |
| return resLen; |
| } |
| |
| // end registration |
| |
| /** |
| * Modify the given locale name by removing the rightmost _-delimited |
| * element. If there is none, empty the string ("" == root). |
| * NOTE: The string "root" is not recognized; do not use it. |
| * @return TRUE if the fallback happened; FALSE if locale is already |
| * root (""). |
| */ |
| static UBool fallback(char *loc) { |
| if (!*loc) { |
| return FALSE; |
| } |
| UErrorCode status = U_ZERO_ERROR; |
| uloc_getParent(loc, loc, (int32_t)uprv_strlen(loc), &status); |
| /* |
| char *i = uprv_strrchr(loc, '_'); |
| if (i == NULL) { |
| i = loc; |
| } |
| *i = 0; |
| */ |
| return TRUE; |
| } |
| |
| |
| U_CAPI const UChar* U_EXPORT2 |
| ucurr_getName(const UChar* currency, |
| const char* locale, |
| UCurrNameStyle nameStyle, |
| UBool* isChoiceFormat, // fillin |
| int32_t* len, // fillin |
| UErrorCode* ec) { |
| |
| // Look up the Currencies resource for the given locale. The |
| // Currencies locale data looks like this: |
| //|en { |
| //| Currencies { |
| //| USD { "US$", "US Dollar" } |
| //| CHF { "Sw F", "Swiss Franc" } |
| //| INR { "=0#Rs|1#Re|1<Rs", "=0#Rupees|1#Rupee|1<Rupees" } |
| //| //... |
| //| } |
| //|} |
| |
| if (U_FAILURE(*ec)) { |
| return 0; |
| } |
| |
| int32_t choice = (int32_t) nameStyle; |
| if (choice < 0 || choice > 1) { |
| *ec = U_ILLEGAL_ARGUMENT_ERROR; |
| return 0; |
| } |
| |
| // In the future, resource bundles may implement multi-level |
| // fallback. That is, if a currency is not found in the en_US |
| // Currencies data, then the en Currencies data will be searched. |
| // Currently, if a Currencies datum exists in en_US and en, the |
| // en_US entry hides that in en. |
| |
| // We want multi-level fallback for this resource, so we implement |
| // it manually. |
| |
| // Use a separate UErrorCode here that does not propagate out of |
| // this function. |
| UErrorCode ec2 = U_ZERO_ERROR; |
| |
| char loc[ULOC_FULLNAME_CAPACITY]; |
| uloc_getName(locale, loc, sizeof(loc), &ec2); |
| if (U_FAILURE(ec2) || ec2 == U_STRING_NOT_TERMINATED_WARNING) { |
| *ec = U_ILLEGAL_ARGUMENT_ERROR; |
| return 0; |
| } |
| |
| char buf[ISO_CURRENCY_CODE_LENGTH+1]; |
| myUCharsToChars(buf, currency); |
| |
| /* Normalize the keyword value to uppercase */ |
| T_CString_toUpperCase(buf); |
| |
| const UChar* s = NULL; |
| ec2 = U_ZERO_ERROR; |
| UResourceBundle* rb = ures_open(U_ICUDATA_CURR, loc, &ec2); |
| |
| rb = ures_getByKey(rb, CURRENCIES, rb, &ec2); |
| |
| // Fetch resource with multi-level resource inheritance fallback |
| rb = ures_getByKeyWithFallback(rb, buf, rb, &ec2); |
| |
| s = ures_getStringByIndex(rb, choice, len, &ec2); |
| ures_close(rb); |
| |
| // If we've succeeded we're done. Otherwise, try to fallback. |
| // If that fails (because we are already at root) then exit. |
| if (U_SUCCESS(ec2)) { |
| if (ec2 == U_USING_DEFAULT_WARNING |
| || (ec2 == U_USING_FALLBACK_WARNING && *ec != U_USING_DEFAULT_WARNING)) { |
| *ec = ec2; |
| } |
| } |
| |
| // Determine if this is a ChoiceFormat pattern. One leading mark |
| // indicates a ChoiceFormat. Two indicates a static string that |
| // starts with a mark. In either case, the first mark is ignored, |
| // if present. Marks in the rest of the string have no special |
| // meaning. |
| *isChoiceFormat = FALSE; |
| if (U_SUCCESS(ec2)) { |
| U_ASSERT(s != NULL); |
| int32_t i=0; |
| while (i < *len && s[i] == CHOICE_FORMAT_MARK && i < 2) { |
| ++i; |
| } |
| *isChoiceFormat = (i == 1); |
| if (i != 0) ++s; // Skip over first mark |
| return s; |
| } |
| |
| // If we fail to find a match, use the ISO 4217 code |
| *len = u_strlen(currency); // Should == ISO_CURRENCY_CODE_LENGTH, but maybe not...? |
| *ec = U_USING_DEFAULT_WARNING; |
| return currency; |
| } |
| |
| U_CAPI const UChar* U_EXPORT2 |
| ucurr_getPluralName(const UChar* currency, |
| const char* locale, |
| UBool* isChoiceFormat, |
| const char* pluralCount, |
| int32_t* len, // fillin |
| UErrorCode* ec) { |
| // Look up the Currencies resource for the given locale. The |
| // Currencies locale data looks like this: |
| //|en { |
| //| CurrencyPlurals { |
| //| USD{ |
| //| one{"US dollar"} |
| //| other{"US dollars"} |
| //| } |
| //| } |
| //|} |
| |
| if (U_FAILURE(*ec)) { |
| return 0; |
| } |
| |
| // Use a separate UErrorCode here that does not propagate out of |
| // this function. |
| UErrorCode ec2 = U_ZERO_ERROR; |
| |
| char loc[ULOC_FULLNAME_CAPACITY]; |
| uloc_getName(locale, loc, sizeof(loc), &ec2); |
| if (U_FAILURE(ec2) || ec2 == U_STRING_NOT_TERMINATED_WARNING) { |
| *ec = U_ILLEGAL_ARGUMENT_ERROR; |
| return 0; |
| } |
| |
| char buf[ISO_CURRENCY_CODE_LENGTH+1]; |
| myUCharsToChars(buf, currency); |
| |
| const UChar* s = NULL; |
| ec2 = U_ZERO_ERROR; |
| UResourceBundle* rb = ures_open(U_ICUDATA_CURR, loc, &ec2); |
| |
| rb = ures_getByKey(rb, CURRENCYPLURALS, rb, &ec2); |
| |
| // Fetch resource with multi-level resource inheritance fallback |
| rb = ures_getByKeyWithFallback(rb, buf, rb, &ec2); |
| |
| s = ures_getStringByKeyWithFallback(rb, pluralCount, len, &ec2); |
| if (U_FAILURE(ec2)) { |
| // fall back to "other" |
| ec2 = U_ZERO_ERROR; |
| s = ures_getStringByKeyWithFallback(rb, "other", len, &ec2); |
| if (U_FAILURE(ec2)) { |
| ures_close(rb); |
| // fall back to long name in Currencies |
| return ucurr_getName(currency, locale, UCURR_LONG_NAME, |
| isChoiceFormat, len, ec); |
| } |
| } |
| ures_close(rb); |
| |
| // If we've succeeded we're done. Otherwise, try to fallback. |
| // If that fails (because we are already at root) then exit. |
| if (U_SUCCESS(ec2)) { |
| if (ec2 == U_USING_DEFAULT_WARNING |
| || (ec2 == U_USING_FALLBACK_WARNING && *ec != U_USING_DEFAULT_WARNING)) { |
| *ec = ec2; |
| } |
| U_ASSERT(s != NULL); |
| return s; |
| } |
| |
| // If we fail to find a match, use the ISO 4217 code |
| *len = u_strlen(currency); // Should == ISO_CURRENCY_CODE_LENGTH, but maybe not...? |
| *ec = U_USING_DEFAULT_WARNING; |
| return currency; |
| } |
| |
| |
| //======================================================================== |
| // Following are structure and function for parsing currency names |
| |
| #define NEED_TO_BE_DELETED 0x1 |
| |
| // TODO: a better way to define this? |
| #define MAX_CURRENCY_NAME_LEN 100 |
| |
| typedef struct { |
| const char* IsoCode; // key |
| UChar* currencyName; // value |
| int32_t currencyNameLen; // value length |
| int32_t flag; // flags |
| } CurrencyNameStruct; |
| |
| |
| #ifndef MIN |
| #define MIN(a,b) (((a)<(b)) ? (a) : (b)) |
| #endif |
| |
| #ifndef MAX |
| #define MAX(a,b) (((a)<(b)) ? (b) : (a)) |
| #endif |
| |
| |
| // Comparason function used in quick sort. |
| static int U_CALLCONV currencyNameComparator(const void* a, const void* b) { |
| const CurrencyNameStruct* currName_1 = (const CurrencyNameStruct*)a; |
| const CurrencyNameStruct* currName_2 = (const CurrencyNameStruct*)b; |
| for (int32_t i = 0; |
| i < MIN(currName_1->currencyNameLen, currName_2->currencyNameLen); |
| ++i) { |
| if (currName_1->currencyName[i] < currName_2->currencyName[i]) { |
| return -1; |
| } |
| if (currName_1->currencyName[i] > currName_2->currencyName[i]) { |
| return 1; |
| } |
| } |
| if (currName_1->currencyNameLen < currName_2->currencyNameLen) { |
| return -1; |
| } else if (currName_1->currencyNameLen > currName_2->currencyNameLen) { |
| return 1; |
| } |
| return 0; |
| } |
| |
| |
| // Give a locale, return the maximum number of currency names associated with |
| // this locale. |
| // It gets currency names from resource bundles using fallback. |
| // It is the maximum number because in the fallback chain, some of the |
| // currency names are duplicated. |
| // For example, given locale as "en_US", the currency names get from resource |
| // bundle in "en_US" and "en" are duplicated. The fallback mechanism will count |
| // all currency names in "en_US" and "en". |
| static void |
| getCurrencyNameCount(const char* loc, int32_t* total_currency_name_count, int32_t* total_currency_symbol_count) { |
| U_NAMESPACE_USE |
| *total_currency_name_count = 0; |
| *total_currency_symbol_count = 0; |
| const UChar* s = NULL; |
| char locale[ULOC_FULLNAME_CAPACITY]; |
| uprv_strcpy(locale, loc); |
| const icu::Hashtable *currencySymbolsEquiv = getCurrSymbolsEquiv(); |
| for (;;) { |
| UErrorCode ec2 = U_ZERO_ERROR; |
| // TODO: ures_openDirect? |
| UResourceBundle* rb = ures_open(U_ICUDATA_CURR, locale, &ec2); |
| UResourceBundle* curr = ures_getByKey(rb, CURRENCIES, NULL, &ec2); |
| int32_t n = ures_getSize(curr); |
| for (int32_t i=0; i<n; ++i) { |
| UResourceBundle* names = ures_getByIndex(curr, i, NULL, &ec2); |
| int32_t len; |
| s = ures_getStringByIndex(names, UCURR_SYMBOL_NAME, &len, &ec2); |
| UBool isChoice = FALSE; |
| if (len > 0 && s[0] == CHOICE_FORMAT_MARK) { |
| ++s; |
| --len; |
| if (len > 0 && s[0] != CHOICE_FORMAT_MARK) { |
| isChoice = TRUE; |
| } |
| } |
| if (isChoice) { |
| ChoiceFormat fmt(UnicodeString(TRUE, s, len), ec2); |
| int32_t fmt_count; |
| fmt.getFormats(fmt_count); |
| *total_currency_symbol_count += fmt_count; |
| } else { |
| ++(*total_currency_symbol_count); // currency symbol |
| if (currencySymbolsEquiv != NULL) { |
| *total_currency_symbol_count += countEquivalent(*currencySymbolsEquiv, UnicodeString(TRUE, s, len)); |
| } |
| } |
| |
| ++(*total_currency_symbol_count); // iso code |
| ++(*total_currency_name_count); // long name |
| ures_close(names); |
| } |
| |
| // currency plurals |
| UErrorCode ec3 = U_ZERO_ERROR; |
| UResourceBundle* curr_p = ures_getByKey(rb, CURRENCYPLURALS, NULL, &ec3); |
| n = ures_getSize(curr_p); |
| for (int32_t i=0; i<n; ++i) { |
| UResourceBundle* names = ures_getByIndex(curr_p, i, NULL, &ec3); |
| *total_currency_name_count += ures_getSize(names); |
| ures_close(names); |
| } |
| ures_close(curr_p); |
| ures_close(curr); |
| ures_close(rb); |
| |
| if (!fallback(locale)) { |
| break; |
| } |
| } |
| } |
| |
| static UChar* |
| toUpperCase(const UChar* source, int32_t len, const char* locale) { |
| UChar* dest = NULL; |
| UErrorCode ec = U_ZERO_ERROR; |
| int32_t destLen = u_strToUpper(dest, 0, source, len, locale, &ec); |
| |
| ec = U_ZERO_ERROR; |
| dest = (UChar*)uprv_malloc(sizeof(UChar) * MAX(destLen, len)); |
| u_strToUpper(dest, destLen, source, len, locale, &ec); |
| if (U_FAILURE(ec)) { |
| uprv_memcpy(dest, source, sizeof(UChar) * len); |
| } |
| return dest; |
| } |
| |
| |
| // Collect all available currency names associated with the given locale |
| // (enable fallback chain). |
| // Read currenc names defined in resource bundle "Currencies" and |
| // "CurrencyPlural", enable fallback chain. |
| // return the malloc-ed currency name arrays and the total number of currency |
| // names in the array. |
| static void |
| collectCurrencyNames(const char* locale, |
| CurrencyNameStruct** currencyNames, |
| int32_t* total_currency_name_count, |
| CurrencyNameStruct** currencySymbols, |
| int32_t* total_currency_symbol_count, |
| UErrorCode& ec) { |
| U_NAMESPACE_USE |
| const icu::Hashtable *currencySymbolsEquiv = getCurrSymbolsEquiv(); |
| // Look up the Currencies resource for the given locale. |
| UErrorCode ec2 = U_ZERO_ERROR; |
| |
| char loc[ULOC_FULLNAME_CAPACITY]; |
| uloc_getName(locale, loc, sizeof(loc), &ec2); |
| if (U_FAILURE(ec2) || ec2 == U_STRING_NOT_TERMINATED_WARNING) { |
| ec = U_ILLEGAL_ARGUMENT_ERROR; |
| } |
| |
| // Get maximum currency name count first. |
| getCurrencyNameCount(loc, total_currency_name_count, total_currency_symbol_count); |
| |
| *currencyNames = (CurrencyNameStruct*)uprv_malloc |
| (sizeof(CurrencyNameStruct) * (*total_currency_name_count)); |
| *currencySymbols = (CurrencyNameStruct*)uprv_malloc |
| (sizeof(CurrencyNameStruct) * (*total_currency_symbol_count)); |
| |
| if(currencyNames == NULL || currencySymbols == NULL) { |
| ec = U_MEMORY_ALLOCATION_ERROR; |
| } |
| |
| if (U_FAILURE(ec)) return; |
| |
| const UChar* s = NULL; // currency name |
| char* iso = NULL; // currency ISO code |
| |
| *total_currency_name_count = 0; |
| *total_currency_symbol_count = 0; |
| |
| UErrorCode ec3 = U_ZERO_ERROR; |
| UErrorCode ec4 = U_ZERO_ERROR; |
| |
| // Using hash to remove duplicates caused by locale fallback |
| UHashtable* currencyIsoCodes = uhash_open(uhash_hashChars, uhash_compareChars, NULL, &ec3); |
| UHashtable* currencyPluralIsoCodes = uhash_open(uhash_hashChars, uhash_compareChars, NULL, &ec4); |
| for (int32_t localeLevel = 0; ; ++localeLevel) { |
| ec2 = U_ZERO_ERROR; |
| // TODO: ures_openDirect |
| UResourceBundle* rb = ures_open(U_ICUDATA_CURR, loc, &ec2); |
| UResourceBundle* curr = ures_getByKey(rb, CURRENCIES, NULL, &ec2); |
| int32_t n = ures_getSize(curr); |
| for (int32_t i=0; i<n; ++i) { |
| UResourceBundle* names = ures_getByIndex(curr, i, NULL, &ec2); |
| int32_t len; |
| s = ures_getStringByIndex(names, UCURR_SYMBOL_NAME, &len, &ec2); |
| // TODO: uhash_put wont change key/value? |
| iso = (char*)ures_getKey(names); |
| if (localeLevel == 0) { |
| uhash_put(currencyIsoCodes, iso, iso, &ec3); |
| } else { |
| if (uhash_get(currencyIsoCodes, iso) != NULL) { |
| ures_close(names); |
| continue; |
| } else { |
| uhash_put(currencyIsoCodes, iso, iso, &ec3); |
| } |
| } |
| UBool isChoice = FALSE; |
| if (len > 0 && s[0] == CHOICE_FORMAT_MARK) { |
| ++s; |
| --len; |
| if (len > 0 && s[0] != CHOICE_FORMAT_MARK) { |
| isChoice = TRUE; |
| } |
| } |
| if (isChoice) { |
| ChoiceFormat fmt(UnicodeString(TRUE, s, len), ec2); |
| int32_t fmt_count; |
| const UnicodeString* formats = fmt.getFormats(fmt_count); |
| for (int i = 0; i < fmt_count; ++i) { |
| // put iso, formats[i]; into array |
| int32_t length = formats[i].length(); |
| UChar* name = (UChar*)uprv_malloc(sizeof(UChar)*length); |
| formats[i].extract(0, length, name); |
| (*currencySymbols)[*total_currency_symbol_count].IsoCode = iso; |
| (*currencySymbols)[*total_currency_symbol_count].currencyName = name; |
| (*currencySymbols)[*total_currency_symbol_count].flag = NEED_TO_BE_DELETED; |
| (*currencySymbols)[(*total_currency_symbol_count)++].currencyNameLen = length; |
| } |
| } else { |
| // Add currency symbol. |
| (*currencySymbols)[*total_currency_symbol_count].IsoCode = iso; |
| (*currencySymbols)[*total_currency_symbol_count].currencyName = (UChar*)s; |
| (*currencySymbols)[*total_currency_symbol_count].flag = 0; |
| (*currencySymbols)[(*total_currency_symbol_count)++].currencyNameLen = len; |
| // Add equivalent symbols |
| if (currencySymbolsEquiv != NULL) { |
| icu::EquivIterator iter(*currencySymbolsEquiv, UnicodeString(TRUE, s, len)); |
| const UnicodeString *symbol; |
| while ((symbol = iter.next()) != NULL) { |
| (*currencySymbols)[*total_currency_symbol_count].IsoCode = iso; |
| (*currencySymbols)[*total_currency_symbol_count].currencyName = (UChar*) symbol->getBuffer(); |
| (*currencySymbols)[*total_currency_symbol_count].flag = 0; |
| (*currencySymbols)[(*total_currency_symbol_count)++].currencyNameLen = symbol->length(); |
| } |
| } |
| } |
| |
| // Add currency long name. |
| s = ures_getStringByIndex(names, UCURR_LONG_NAME, &len, &ec2); |
| (*currencyNames)[*total_currency_name_count].IsoCode = iso; |
| UChar* upperName = toUpperCase(s, len, locale); |
| (*currencyNames)[*total_currency_name_count].currencyName = upperName; |
| (*currencyNames)[*total_currency_name_count].flag = NEED_TO_BE_DELETED; |
| (*currencyNames)[(*total_currency_name_count)++].currencyNameLen = len; |
| |
| // put (iso, 3, and iso) in to array |
| // Add currency ISO code. |
| (*currencySymbols)[*total_currency_symbol_count].IsoCode = iso; |
| (*currencySymbols)[*total_currency_symbol_count].currencyName = (UChar*)uprv_malloc(sizeof(UChar)*3); |
| // Must convert iso[] into Unicode |
| u_charsToUChars(iso, (*currencySymbols)[*total_currency_symbol_count].currencyName, 3); |
| (*currencySymbols)[*total_currency_symbol_count].flag = NEED_TO_BE_DELETED; |
| (*currencySymbols)[(*total_currency_symbol_count)++].currencyNameLen = 3; |
| |
| ures_close(names); |
| } |
| |
| // currency plurals |
| UErrorCode ec3 = U_ZERO_ERROR; |
| UResourceBundle* curr_p = ures_getByKey(rb, CURRENCYPLURALS, NULL, &ec3); |
| n = ures_getSize(curr_p); |
| for (int32_t i=0; i<n; ++i) { |
| UResourceBundle* names = ures_getByIndex(curr_p, i, NULL, &ec3); |
| iso = (char*)ures_getKey(names); |
| // Using hash to remove duplicated ISO codes in fallback chain. |
| if (localeLevel == 0) { |
| uhash_put(currencyPluralIsoCodes, iso, iso, &ec4); |
| } else { |
| if (uhash_get(currencyPluralIsoCodes, iso) != NULL) { |
| ures_close(names); |
| continue; |
| } else { |
| uhash_put(currencyPluralIsoCodes, iso, iso, &ec4); |
| } |
| } |
| int32_t num = ures_getSize(names); |
| int32_t len; |
| for (int32_t j = 0; j < num; ++j) { |
| // TODO: remove duplicates between singular name and |
| // currency long name? |
| s = ures_getStringByIndex(names, j, &len, &ec3); |
| (*currencyNames)[*total_currency_name_count].IsoCode = iso; |
| UChar* upperName = toUpperCase(s, len, locale); |
| (*currencyNames)[*total_currency_name_count].currencyName = upperName; |
| (*currencyNames)[*total_currency_name_count].flag = NEED_TO_BE_DELETED; |
| (*currencyNames)[(*total_currency_name_count)++].currencyNameLen = len; |
| } |
| ures_close(names); |
| } |
| ures_close(curr_p); |
| ures_close(curr); |
| ures_close(rb); |
| |
| if (!fallback(loc)) { |
| break; |
| } |
| } |
| |
| uhash_close(currencyIsoCodes); |
| uhash_close(currencyPluralIsoCodes); |
| |
| // quick sort the struct |
| qsort(*currencyNames, *total_currency_name_count, |
| sizeof(CurrencyNameStruct), currencyNameComparator); |
| qsort(*currencySymbols, *total_currency_symbol_count, |
| sizeof(CurrencyNameStruct), currencyNameComparator); |
| |
| #ifdef UCURR_DEBUG |
| printf("currency name count: %d\n", *total_currency_name_count); |
| for (int32_t index = 0; index < *total_currency_name_count; ++index) { |
| printf("index: %d\n", index); |
| printf("iso: %s\n", (*currencyNames)[index].IsoCode); |
| char curNameBuf[1024]; |
| memset(curNameBuf, 0, 1024); |
| u_austrncpy(curNameBuf, (*currencyNames)[index].currencyName, (*currencyNames)[index].currencyNameLen); |
| printf("currencyName: %s\n", curNameBuf); |
| printf("len: %d\n", (*currencyNames)[index].currencyNameLen); |
| } |
| printf("currency symbol count: %d\n", *total_currency_symbol_count); |
| for (int32_t index = 0; index < *total_currency_symbol_count; ++index) { |
| printf("index: %d\n", index); |
| printf("iso: %s\n", (*currencySymbols)[index].IsoCode); |
| char curNameBuf[1024]; |
| memset(curNameBuf, 0, 1024); |
| u_austrncpy(curNameBuf, (*currencySymbols)[index].currencyName, (*currencySymbols)[index].currencyNameLen); |
| printf("currencySymbol: %s\n", curNameBuf); |
| printf("len: %d\n", (*currencySymbols)[index].currencyNameLen); |
| } |
| #endif |
| // fail on hashtable errors |
| if (U_FAILURE(ec3)) { |
| ec = ec3; |
| return; |
| } |
| if (U_FAILURE(ec4)) { |
| ec = ec4; |
| return; |
| } |
| } |
| |
| // @param currencyNames: currency names array |
| // @param indexInCurrencyNames: the index of the character in currency names |
| // array against which the comparison is done |
| // @param key: input text char to compare against |
| // @param begin(IN/OUT): the begin index of matching range in currency names array |
| // @param end(IN/OUT): the end index of matching range in currency names array. |
| static int32_t |
| binarySearch(const CurrencyNameStruct* currencyNames, |
| int32_t indexInCurrencyNames, |
| const UChar key, |
| int32_t* begin, int32_t* end) { |
| #ifdef UCURR_DEBUG |
| printf("key = %x\n", key); |
| #endif |
| int32_t first = *begin; |
| int32_t last = *end; |
| while (first <= last) { |
| int32_t mid = (first + last) / 2; // compute mid point. |
| if (indexInCurrencyNames >= currencyNames[mid].currencyNameLen) { |
| first = mid + 1; |
| } else { |
| if (key > currencyNames[mid].currencyName[indexInCurrencyNames]) { |
| first = mid + 1; |
| } |
| else if (key < currencyNames[mid].currencyName[indexInCurrencyNames]) { |
| last = mid - 1; |
| } |
| else { |
| // Find a match, and looking for ranges |
| // Now do two more binary searches. First, on the left side for |
| // the greatest L such that CurrencyNameStruct[L] < key. |
| int32_t L = *begin; |
| int32_t R = mid; |
| |
| #ifdef UCURR_DEBUG |
| printf("mid = %d\n", mid); |
| #endif |
| while (L < R) { |
| int32_t M = (L + R) / 2; |
| #ifdef UCURR_DEBUG |
| printf("L = %d, R = %d, M = %d\n", L, R, M); |
| #endif |
| if (indexInCurrencyNames >= currencyNames[M].currencyNameLen) { |
| L = M + 1; |
| } else { |
| if (currencyNames[M].currencyName[indexInCurrencyNames] < key) { |
| L = M + 1; |
| } else { |
| #ifdef UCURR_DEBUG |
| U_ASSERT(currencyNames[M].currencyName[indexInCurrencyNames] == key); |
| #endif |
| R = M; |
| } |
| } |
| } |
| #ifdef UCURR_DEBUG |
| U_ASSERT(L == R); |
| #endif |
| *begin = L; |
| #ifdef UCURR_DEBUG |
| printf("begin = %d\n", *begin); |
| U_ASSERT(currencyNames[*begin].currencyName[indexInCurrencyNames] == key); |
| #endif |
| |
| // Now for the second search, finding the least R such that |
| // key < CurrencyNameStruct[R]. |
| L = mid; |
| R = *end; |
| while (L < R) { |
| int32_t M = (L + R) / 2; |
| #ifdef UCURR_DEBUG |
| printf("L = %d, R = %d, M = %d\n", L, R, M); |
| #endif |
| if (currencyNames[M].currencyNameLen < indexInCurrencyNames) { |
| L = M + 1; |
| } else { |
| if (currencyNames[M].currencyName[indexInCurrencyNames] > key) { |
| R = M; |
| } else { |
| #ifdef UCURR_DEBUG |
| U_ASSERT(currencyNames[M].currencyName[indexInCurrencyNames] == key); |
| #endif |
| L = M + 1; |
| } |
| } |
| } |
| #ifdef UCURR_DEBUG |
| U_ASSERT(L == R); |
| #endif |
| if (currencyNames[R].currencyName[indexInCurrencyNames] > key) { |
| *end = R - 1; |
| } else { |
| *end = R; |
| } |
| #ifdef UCURR_DEBUG |
| printf("end = %d\n", *end); |
| #endif |
| |
| // now, found the range. check whether there is exact match |
| if (currencyNames[*begin].currencyNameLen == indexInCurrencyNames + 1) { |
| return *begin; // find range and exact match. |
| } |
| return -1; // find range, but no exact match. |
| } |
| } |
| } |
| *begin = -1; |
| *end = -1; |
| return -1; // failed to find range. |
| } |
| |
| |
| // Linear search "text" in "currencyNames". |
| // @param begin, end: the begin and end index in currencyNames, within which |
| // range should the search be performed. |
| // @param textLen: the length of the text to be compared |
| // @param maxMatchLen(IN/OUT): passing in the computed max matching length |
| // pass out the new max matching length |
| // @param maxMatchIndex: the index in currencyName which has the longest |
| // match with input text. |
| static void |
| linearSearch(const CurrencyNameStruct* currencyNames, |
| int32_t begin, int32_t end, |
| const UChar* text, int32_t textLen, |
| int32_t *maxMatchLen, int32_t* maxMatchIndex) { |
| for (int32_t index = begin; index <= end; ++index) { |
| int32_t len = currencyNames[index].currencyNameLen; |
| if (len > *maxMatchLen && len <= textLen && |
| uprv_memcmp(currencyNames[index].currencyName, text, len * sizeof(UChar)) == 0) { |
| *maxMatchIndex = index; |
| *maxMatchLen = len; |
| #ifdef UCURR_DEBUG |
| printf("maxMatchIndex = %d, maxMatchLen = %d\n", |
| *maxMatchIndex, *maxMatchLen); |
| #endif |
| } |
| } |
| } |
| |
| #define LINEAR_SEARCH_THRESHOLD 10 |
| |
| // Find longest match between "text" and currency names in "currencyNames". |
| // @param total_currency_count: total number of currency names in CurrencyNames. |
| // @param textLen: the length of the text to be compared |
| // @param maxMatchLen: passing in the computed max matching length |
| // pass out the new max matching length |
| // @param maxMatchIndex: the index in currencyName which has the longest |
| // match with input text. |
| static void |
| searchCurrencyName(const CurrencyNameStruct* currencyNames, |
| int32_t total_currency_count, |
| const UChar* text, int32_t textLen, |
| int32_t* maxMatchLen, int32_t* maxMatchIndex) { |
| *maxMatchIndex = -1; |
| *maxMatchLen = 0; |
| int32_t matchIndex = -1; |
| int32_t binarySearchBegin = 0; |
| int32_t binarySearchEnd = total_currency_count - 1; |
| // It is a variant of binary search. |
| // For example, given the currency names in currencyNames array are: |
| // A AB ABC AD AZ B BB BBEX BBEXYZ BS C D E.... |
| // and the input text is BBEXST |
| // The first round binary search search "B" in the text against |
| // the first char in currency names, and find the first char matching range |
| // to be "B BB BBEX BBEXYZ BS" (and the maximum matching "B"). |
| // The 2nd round binary search search the second "B" in the text against |
| // the 2nd char in currency names, and narrow the matching range to |
| // "BB BBEX BBEXYZ" (and the maximum matching "BB"). |
| // The 3rd round returnes the range as "BBEX BBEXYZ" (without changing |
| // maximum matching). |
| // The 4th round returns the same range (the maximum matching is "BBEX"). |
| // The 5th round returns no matching range. |
| for (int32_t index = 0; index < textLen; ++index) { |
| // matchIndex saves the one with exact match till the current point. |
| // [binarySearchBegin, binarySearchEnd] saves the matching range. |
| matchIndex = binarySearch(currencyNames, index, |
| text[index], |
| &binarySearchBegin, &binarySearchEnd); |
| if (binarySearchBegin == -1) { // did not find the range |
| break; |
| } |
| if (matchIndex != -1) { |
| // find an exact match for text from text[0] to text[index] |
| // in currencyNames array. |
| *maxMatchLen = index + 1; |
| *maxMatchIndex = matchIndex; |
| } |
| if (binarySearchEnd - binarySearchBegin < LINEAR_SEARCH_THRESHOLD) { |
| // linear search if within threshold. |
| linearSearch(currencyNames, binarySearchBegin, binarySearchEnd, |
| text, textLen, |
| maxMatchLen, maxMatchIndex); |
| break; |
| } |
| } |
| return; |
| } |
| |
| //========================= currency name cache ===================== |
| typedef struct { |
| char locale[ULOC_FULLNAME_CAPACITY]; //key |
| // currency names, case insensitive |
| CurrencyNameStruct* currencyNames; // value |
| int32_t totalCurrencyNameCount; // currency name count |
| // currency symbols and ISO code, case sensitive |
| CurrencyNameStruct* currencySymbols; // value |
| int32_t totalCurrencySymbolCount; // count |
| // reference count. |
| // reference count is set to 1 when an entry is put to cache. |
| // it increases by 1 before accessing, and decreased by 1 after accessing. |
| // The entry is deleted when ref count is zero, which means |
| // the entry is replaced out of cache and no process is accessing it. |
| int32_t refCount; |
| } CurrencyNameCacheEntry; |
| |
| |
| #define CURRENCY_NAME_CACHE_NUM 10 |
| |
| // Reserve 10 cache entries. |
| static CurrencyNameCacheEntry* currCache[CURRENCY_NAME_CACHE_NUM] = {NULL}; |
| // Using an index to indicate which entry to be replaced when cache is full. |
| // It is a simple round-robin replacement strategy. |
| static int8_t currentCacheEntryIndex = 0; |
| |
| static UMutex gCurrencyCacheMutex = U_MUTEX_INITIALIZER; |
| |
| // Cache deletion |
| static void |
| deleteCurrencyNames(CurrencyNameStruct* currencyNames, int32_t count) { |
| for (int32_t index = 0; index < count; ++index) { |
| if ( (currencyNames[index].flag & NEED_TO_BE_DELETED) ) { |
| uprv_free(currencyNames[index].currencyName); |
| } |
| } |
| uprv_free(currencyNames); |
| } |
| |
| |
| static void |
| deleteCacheEntry(CurrencyNameCacheEntry* entry) { |
| deleteCurrencyNames(entry->currencyNames, entry->totalCurrencyNameCount); |
| deleteCurrencyNames(entry->currencySymbols, entry->totalCurrencySymbolCount); |
| uprv_free(entry); |
| } |
| |
| |
| // Cache clean up |
| static UBool U_CALLCONV |
| currency_cache_cleanup(void) { |
| for (int32_t i = 0; i < CURRENCY_NAME_CACHE_NUM; ++i) { |
| if (currCache[i]) { |
| deleteCacheEntry(currCache[i]); |
| currCache[i] = 0; |
| } |
| } |
| return TRUE; |
| } |
| |
| |
| U_CFUNC void |
| uprv_parseCurrency(const char* locale, |
| const icu::UnicodeString& text, |
| icu::ParsePosition& pos, |
| int8_t type, |
| UChar* result, |
| UErrorCode& ec) |
| { |
| U_NAMESPACE_USE |
| |
| if (U_FAILURE(ec)) { |
| return; |
| } |
| |
| int32_t total_currency_name_count = 0; |
| CurrencyNameStruct* currencyNames = NULL; |
| int32_t total_currency_symbol_count = 0; |
| CurrencyNameStruct* currencySymbols = NULL; |
| CurrencyNameCacheEntry* cacheEntry = NULL; |
| |
| umtx_lock(&gCurrencyCacheMutex); |
| // in order to handle racing correctly, |
| // not putting 'search' in a separate function. |
| int8_t found = -1; |
| for (int8_t i = 0; i < CURRENCY_NAME_CACHE_NUM; ++i) { |
| if (currCache[i]!= NULL && |
| uprv_strcmp(locale, currCache[i]->locale) == 0) { |
| found = i; |
| break; |
| } |
| } |
| if (found != -1) { |
| cacheEntry = currCache[found]; |
| currencyNames = cacheEntry->currencyNames; |
| total_currency_name_count = cacheEntry->totalCurrencyNameCount; |
| currencySymbols = cacheEntry->currencySymbols; |
| total_currency_symbol_count = cacheEntry->totalCurrencySymbolCount; |
| ++(cacheEntry->refCount); |
| } |
| umtx_unlock(&gCurrencyCacheMutex); |
| if (found == -1) { |
| collectCurrencyNames(locale, ¤cyNames, &total_currency_name_count, ¤cySymbols, &total_currency_symbol_count, ec); |
| if (U_FAILURE(ec)) { |
| return; |
| } |
| umtx_lock(&gCurrencyCacheMutex); |
| // check again. |
| int8_t found = -1; |
| for (int8_t i = 0; i < CURRENCY_NAME_CACHE_NUM; ++i) { |
| if (currCache[i]!= NULL && |
| uprv_strcmp(locale, currCache[i]->locale) == 0) { |
| found = i; |
| break; |
| } |
| } |
| if (found == -1) { |
| // insert new entry to |
| // currentCacheEntryIndex % CURRENCY_NAME_CACHE_NUM |
| // and remove the existing entry |
| // currentCacheEntryIndex % CURRENCY_NAME_CACHE_NUM |
| // from cache. |
| cacheEntry = currCache[currentCacheEntryIndex]; |
| if (cacheEntry) { |
| --(cacheEntry->refCount); |
| // delete if the ref count is zero |
| if (cacheEntry->refCount == 0) { |
| deleteCacheEntry(cacheEntry); |
| } |
| } |
| cacheEntry = (CurrencyNameCacheEntry*)uprv_malloc(sizeof(CurrencyNameCacheEntry)); |
| currCache[currentCacheEntryIndex] = cacheEntry; |
| uprv_strcpy(cacheEntry->locale, locale); |
| cacheEntry->currencyNames = currencyNames; |
| cacheEntry->totalCurrencyNameCount = total_currency_name_count; |
| cacheEntry->currencySymbols = currencySymbols; |
| cacheEntry->totalCurrencySymbolCount = total_currency_symbol_count; |
| cacheEntry->refCount = 2; // one for cache, one for reference |
| currentCacheEntryIndex = (currentCacheEntryIndex + 1) % CURRENCY_NAME_CACHE_NUM; |
| ucln_i18n_registerCleanup(UCLN_I18N_CURRENCY, currency_cache_cleanup); |
| |
| } else { |
| deleteCurrencyNames(currencyNames, total_currency_name_count); |
| deleteCurrencyNames(currencySymbols, total_currency_symbol_count); |
| cacheEntry = currCache[found]; |
| currencyNames = cacheEntry->currencyNames; |
| total_currency_name_count = cacheEntry->totalCurrencyNameCount; |
| currencySymbols = cacheEntry->currencySymbols; |
| total_currency_symbol_count = cacheEntry->totalCurrencySymbolCount; |
| ++(cacheEntry->refCount); |
| } |
| umtx_unlock(&gCurrencyCacheMutex); |
| } |
| |
| int32_t start = pos.getIndex(); |
| |
| UChar inputText[MAX_CURRENCY_NAME_LEN]; |
| UChar upperText[MAX_CURRENCY_NAME_LEN]; |
| int32_t textLen = MIN(MAX_CURRENCY_NAME_LEN, text.length() - start); |
| text.extract(start, textLen, inputText); |
| UErrorCode ec1 = U_ZERO_ERROR; |
| textLen = u_strToUpper(upperText, MAX_CURRENCY_NAME_LEN, inputText, textLen, locale, &ec1); |
| |
| int32_t max = 0; |
| int32_t matchIndex = -1; |
| // case in-sensitive comparision against currency names |
| searchCurrencyName(currencyNames, total_currency_name_count, |
| upperText, textLen, &max, &matchIndex); |
| |
| #ifdef UCURR_DEBUG |
| printf("search in names, max = %d, matchIndex = %d\n", max, matchIndex); |
| #endif |
| |
| int32_t maxInSymbol = 0; |
| int32_t matchIndexInSymbol = -1; |
| if (type != UCURR_LONG_NAME) { // not name only |
| // case sensitive comparison against currency symbols and ISO code. |
| searchCurrencyName(currencySymbols, total_currency_symbol_count, |
| inputText, textLen, |
| &maxInSymbol, &matchIndexInSymbol); |
| } |
| |
| #ifdef UCURR_DEBUG |
| printf("search in symbols, maxInSymbol = %d, matchIndexInSymbol = %d\n", maxInSymbol, matchIndexInSymbol); |
| if(matchIndexInSymbol != -1) { |
| printf("== ISO=%s\n", currencySymbols[matchIndexInSymbol].IsoCode); |
| } |
| #endif |
| |
| if (max >= maxInSymbol && matchIndex != -1) { |
| u_charsToUChars(currencyNames[matchIndex].IsoCode, result, 4); |
| pos.setIndex(start + max); |
| } else if (maxInSymbol >= max && matchIndexInSymbol != -1) { |
| u_charsToUChars(currencySymbols[matchIndexInSymbol].IsoCode, result, 4); |
| pos.setIndex(start + maxInSymbol); |
| } |
| |
| // decrease reference count |
| umtx_lock(&gCurrencyCacheMutex); |
| --(cacheEntry->refCount); |
| if (cacheEntry->refCount == 0) { // remove |
| deleteCacheEntry(cacheEntry); |
| } |
| umtx_unlock(&gCurrencyCacheMutex); |
| } |
| |
| |
| /** |
| * Internal method. Given a currency ISO code and a locale, return |
| * the "static" currency name. This is usually the same as the |
| * UCURR_SYMBOL_NAME, but if the latter is a choice format, then the |
| * format is applied to the number 2.0 (to yield the more common |
| * plural) to return a static name. |
| * |
| * This is used for backward compatibility with old currency logic in |
| * DecimalFormat and DecimalFormatSymbols. |
| */ |
| U_CFUNC void |
| uprv_getStaticCurrencyName(const UChar* iso, const char* loc, |
| icu::UnicodeString& result, UErrorCode& ec) |
| { |
| U_NAMESPACE_USE |
| |
| UBool isChoiceFormat; |
| int32_t len; |
| const UChar* currname = ucurr_getName(iso, loc, UCURR_SYMBOL_NAME, |
| &isChoiceFormat, &len, &ec); |
| if (U_SUCCESS(ec)) { |
| // If this is a ChoiceFormat currency, then format an |
| // arbitrary value; pick something != 1; more common. |
| result.truncate(0); |
| if (isChoiceFormat) { |
| ChoiceFormat f(UnicodeString(TRUE, currname, len), ec); |
| if (U_SUCCESS(ec)) { |
| f.format(2.0, result); |
| } else { |
| result.setTo(iso, -1); |
| } |
| } else { |
| result.setTo(currname, -1); |
| } |
| } |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| ucurr_getDefaultFractionDigits(const UChar* currency, UErrorCode* ec) { |
| return ucurr_getDefaultFractionDigitsForUsage(currency,UCURR_USAGE_STANDARD,ec); |
| } |
| |
| U_DRAFT int32_t U_EXPORT2 |
| ucurr_getDefaultFractionDigitsForUsage(const UChar* currency, const UCurrencyUsage usage, UErrorCode* ec) { |
| int32_t fracDigits = 0; |
| if (U_SUCCESS(*ec)) { |
| switch (usage) { |
| case UCURR_USAGE_STANDARD: |
| fracDigits = (_findMetaData(currency, *ec))[0]; |
| break; |
| case UCURR_USAGE_CASH: |
| fracDigits = (_findMetaData(currency, *ec))[2]; |
| break; |
| default: |
| *ec = U_UNSUPPORTED_ERROR; |
| } |
| } |
| return fracDigits; |
| } |
| |
| U_CAPI double U_EXPORT2 |
| ucurr_getRoundingIncrement(const UChar* currency, UErrorCode* ec) { |
| return ucurr_getRoundingIncrementForUsage(currency, UCURR_USAGE_STANDARD, ec); |
| } |
| |
| U_DRAFT double U_EXPORT2 |
| ucurr_getRoundingIncrementForUsage(const UChar* currency, const UCurrencyUsage usage, UErrorCode* ec) { |
| double result = 0.0; |
| |
| const int32_t *data = _findMetaData(currency, *ec); |
| if (U_SUCCESS(*ec)) { |
| int32_t fracDigits; |
| int32_t increment; |
| switch (usage) { |
| case UCURR_USAGE_STANDARD: |
| fracDigits = data[0]; |
| increment = data[1]; |
| break; |
| case UCURR_USAGE_CASH: |
| fracDigits = data[2]; |
| increment = data[3]; |
| break; |
| default: |
| *ec = U_UNSUPPORTED_ERROR; |
| return result; |
| } |
| |
| // If the meta data is invalid, return 0.0 |
| if (fracDigits < 0 || fracDigits > MAX_POW10) { |
| *ec = U_INVALID_FORMAT_ERROR; |
| } else { |
| // A rounding value of 0 or 1 indicates no rounding. |
| if (increment >= 2) { |
| // Return (increment) / 10^(fracDigits). The only actual rounding data, |
| // as of this writing, is CHF { 2, 5 }. |
| result = double(increment) / POW10[fracDigits]; |
| } |
| } |
| } |
| |
| return result; |
| } |
| |
| U_CDECL_BEGIN |
| |
| typedef struct UCurrencyContext { |
| uint32_t currType; /* UCurrCurrencyType */ |
| uint32_t listIdx; |
| } UCurrencyContext; |
| |
| /* |
| Please keep this list in alphabetical order. |
| You can look at the CLDR supplemental data or ISO-4217 for the meaning of some |
| of these items. |
| ISO-4217: http://www.iso.org/iso/en/prods-services/popstds/currencycodeslist.html |
| */ |
| static const struct CurrencyList { |
| const char *currency; |
| uint32_t currType; |
| } gCurrencyList[] = { |
| {"ADP", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"AED", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"AFA", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"AFN", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"ALK", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"ALL", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"AMD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"ANG", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"AOA", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"AOK", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"AON", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"AOR", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"ARA", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"ARL", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"ARM", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"ARP", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"ARS", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"ATS", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"AUD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"AWG", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"AZM", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"AZN", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"BAD", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"BAM", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"BAN", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"BBD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"BDT", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"BEC", UCURR_UNCOMMON|UCURR_DEPRECATED}, |
| {"BEF", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"BEL", UCURR_UNCOMMON|UCURR_DEPRECATED}, |
| {"BGL", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"BGM", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"BGN", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"BGO", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"BHD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"BIF", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"BMD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"BND", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"BOB", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"BOL", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"BOP", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"BOV", UCURR_UNCOMMON|UCURR_NON_DEPRECATED}, |
| {"BRB", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"BRC", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"BRE", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"BRL", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"BRN", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"BRR", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"BRZ", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"BSD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"BTN", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"BUK", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"BWP", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"BYB", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"BYR", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"BZD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"CAD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"CDF", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"CHE", UCURR_UNCOMMON|UCURR_NON_DEPRECATED}, |
| {"CHF", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"CHW", UCURR_UNCOMMON|UCURR_NON_DEPRECATED}, |
| {"CLE", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"CLF", UCURR_UNCOMMON|UCURR_NON_DEPRECATED}, |
| {"CLP", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"CNX", UCURR_UNCOMMON|UCURR_DEPRECATED}, |
| {"CNY", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"COP", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"COU", UCURR_UNCOMMON|UCURR_NON_DEPRECATED}, |
| {"CRC", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"CSD", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"CSK", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"CUC", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"CUP", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"CVE", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"CYP", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"CZK", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"DDM", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"DEM", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"DJF", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"DKK", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"DOP", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"DZD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"ECS", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"ECV", UCURR_UNCOMMON|UCURR_DEPRECATED}, |
| {"EEK", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"EGP", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"EQE", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"ERN", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"ESA", UCURR_UNCOMMON|UCURR_DEPRECATED}, |
| {"ESB", UCURR_UNCOMMON|UCURR_DEPRECATED}, |
| {"ESP", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"ETB", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"EUR", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"FIM", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"FJD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"FKP", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"FRF", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"GBP", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"GEK", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"GEL", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"GHC", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"GHS", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"GIP", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"GMD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"GNF", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"GNS", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"GQE", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"GRD", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"GTQ", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"GWE", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"GWP", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"GYD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"HKD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"HNL", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"HRD", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"HRK", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"HTG", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"HUF", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"IDR", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"IEP", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"ILP", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"ILR", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"ILS", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"INR", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"IQD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"IRR", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"ISJ", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"ISK", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"ITL", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"JMD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"JOD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"JPY", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"KES", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"KGS", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"KHR", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"KMF", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"KPW", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"KRH", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"KRO", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"KRW", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"KWD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"KYD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"KZT", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"LAK", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"LBP", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"LKR", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"LRD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"LSL", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"LSM", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"LTL", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"LTT", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"LUC", UCURR_UNCOMMON|UCURR_DEPRECATED}, |
| {"LUF", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"LUL", UCURR_UNCOMMON|UCURR_DEPRECATED}, |
| {"LVL", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"LVR", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"LYD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"MAD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"MAF", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"MCF", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"MDC", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"MDL", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"MGA", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"MGF", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"MKD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"MKN", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"MLF", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"MMK", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"MNT", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"MOP", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"MRO", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"MTL", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"MTP", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"MUR", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"MVP", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"MVR", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"MWK", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"MXN", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"MXP", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"MXV", UCURR_UNCOMMON|UCURR_NON_DEPRECATED}, |
| {"MYR", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"MZE", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"MZM", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"MZN", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"NAD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"NGN", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"NIC", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"NIO", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"NLG", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"NOK", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"NPR", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"NZD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"OMR", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"PAB", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"PEI", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"PEN", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"PES", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"PGK", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"PHP", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"PKR", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"PLN", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"PLZ", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"PTE", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"PYG", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"QAR", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"RHD", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"ROL", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"RON", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"RSD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"RUB", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"RUR", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"RWF", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"SAR", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"SBD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"SCR", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"SDD", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"SDG", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"SDP", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"SEK", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"SGD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"SHP", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"SIT", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"SKK", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"SLL", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"SOS", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"SRD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"SRG", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"SSP", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"STD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"SUR", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"SVC", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"SYP", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"SZL", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"THB", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"TJR", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"TJS", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"TMM", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"TMT", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"TND", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"TOP", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"TPE", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"TRL", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"TRY", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"TTD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"TWD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"TZS", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"UAH", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"UAK", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"UGS", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"UGX", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"USD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"USN", UCURR_UNCOMMON|UCURR_NON_DEPRECATED}, |
| {"USS", UCURR_UNCOMMON|UCURR_NON_DEPRECATED}, |
| {"UYI", UCURR_UNCOMMON|UCURR_NON_DEPRECATED}, |
| {"UYP", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"UYU", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"UZS", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"VEB", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"VEF", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"VND", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"VNN", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"VUV", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"WST", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"XAF", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"XAG", UCURR_UNCOMMON|UCURR_NON_DEPRECATED}, |
| {"XAU", UCURR_UNCOMMON|UCURR_NON_DEPRECATED}, |
| {"XBA", UCURR_UNCOMMON|UCURR_NON_DEPRECATED}, |
| {"XBB", UCURR_UNCOMMON|UCURR_NON_DEPRECATED}, |
| {"XBC", UCURR_UNCOMMON|UCURR_NON_DEPRECATED}, |
| {"XBD", UCURR_UNCOMMON|UCURR_NON_DEPRECATED}, |
| {"XCD", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"XDR", UCURR_UNCOMMON|UCURR_NON_DEPRECATED}, |
| {"XEU", UCURR_UNCOMMON|UCURR_DEPRECATED}, |
| {"XFO", UCURR_UNCOMMON|UCURR_NON_DEPRECATED}, |
| {"XFU", UCURR_UNCOMMON|UCURR_NON_DEPRECATED}, |
| {"XOF", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"XPD", UCURR_UNCOMMON|UCURR_NON_DEPRECATED}, |
| {"XPF", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"XPT", UCURR_UNCOMMON|UCURR_NON_DEPRECATED}, |
| {"XRE", UCURR_UNCOMMON|UCURR_NON_DEPRECATED}, |
| {"XSU", UCURR_UNCOMMON|UCURR_NON_DEPRECATED}, |
| {"XTS", UCURR_UNCOMMON|UCURR_NON_DEPRECATED}, |
| {"XUA", UCURR_UNCOMMON|UCURR_NON_DEPRECATED}, |
| {"XXX", UCURR_UNCOMMON|UCURR_NON_DEPRECATED}, |
| {"YDD", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"YER", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"YUD", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"YUM", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"YUN", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"YUR", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"ZAL", UCURR_UNCOMMON|UCURR_NON_DEPRECATED}, |
| {"ZAR", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"ZMK", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"ZMW", UCURR_COMMON|UCURR_NON_DEPRECATED}, |
| {"ZRN", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"ZRZ", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"ZWL", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"ZWR", UCURR_COMMON|UCURR_DEPRECATED}, |
| {"ZWD", UCURR_COMMON|UCURR_DEPRECATED}, |
| { NULL, 0 } // Leave here to denote the end of the list. |
| }; |
| |
| #define UCURR_MATCHES_BITMASK(variable, typeToMatch) \ |
| ((typeToMatch) == UCURR_ALL || ((variable) & (typeToMatch)) == (typeToMatch)) |
| |
| static int32_t U_CALLCONV |
| ucurr_countCurrencyList(UEnumeration *enumerator, UErrorCode * /*pErrorCode*/) { |
| UCurrencyContext *myContext = (UCurrencyContext *)(enumerator->context); |
| uint32_t currType = myContext->currType; |
| int32_t count = 0; |
| |
| /* Count the number of items matching the type we are looking for. */ |
| for (int32_t idx = 0; gCurrencyList[idx].currency != NULL; idx++) { |
| if (UCURR_MATCHES_BITMASK(gCurrencyList[idx].currType, currType)) { |
| count++; |
| } |
| } |
| return count; |
| } |
| |
| static const char* U_CALLCONV |
| ucurr_nextCurrencyList(UEnumeration *enumerator, |
| int32_t* resultLength, |
| UErrorCode * /*pErrorCode*/) |
| { |
| UCurrencyContext *myContext = (UCurrencyContext *)(enumerator->context); |
| |
| /* Find the next in the list that matches the type we are looking for. */ |
| while (myContext->listIdx < (sizeof(gCurrencyList)/sizeof(gCurrencyList[0]))-1) { |
| const struct CurrencyList *currItem = &gCurrencyList[myContext->listIdx++]; |
| if (UCURR_MATCHES_BITMASK(currItem->currType, myContext->currType)) |
| { |
| if (resultLength) { |
| *resultLength = 3; /* Currency codes are only 3 chars long */ |
| } |
| return currItem->currency; |
| } |
| } |
| /* We enumerated too far. */ |
| if (resultLength) { |
| *resultLength = 0; |
| } |
| return NULL; |
| } |
| |
| static void U_CALLCONV |
| ucurr_resetCurrencyList(UEnumeration *enumerator, UErrorCode * /*pErrorCode*/) { |
| ((UCurrencyContext *)(enumerator->context))->listIdx = 0; |
| } |
| |
| static void U_CALLCONV |
| ucurr_closeCurrencyList(UEnumeration *enumerator) { |
| uprv_free(enumerator->context); |
| uprv_free(enumerator); |
| } |
| |
| static void U_CALLCONV |
| ucurr_createCurrencyList(UHashtable *isoCodes, UErrorCode* status){ |
| UErrorCode localStatus = U_ZERO_ERROR; |
| |
| // Look up the CurrencyMap element in the root bundle. |
| UResourceBundle *rb = ures_openDirect(U_ICUDATA_CURR, CURRENCY_DATA, &localStatus); |
| UResourceBundle *currencyMapArray = ures_getByKey(rb, CURRENCY_MAP, rb, &localStatus); |
| |
| if (U_SUCCESS(localStatus)) { |
| // process each entry in currency map |
| for (int32_t i=0; i<ures_getSize(currencyMapArray); i++) { |
| // get the currency resource |
| UResourceBundle *currencyArray = ures_getByIndex(currencyMapArray, i, NULL, &localStatus); |
| // process each currency |
| if (U_SUCCESS(localStatus)) { |
| for (int32_t j=0; j<ures_getSize(currencyArray); j++) { |
| // get the currency resource |
| UResourceBundle *currencyRes = ures_getByIndex(currencyArray, j, NULL, &localStatus); |
| IsoCodeEntry *entry = (IsoCodeEntry*)uprv_malloc(sizeof(IsoCodeEntry)); |
| if (entry == NULL) { |
| *status = U_MEMORY_ALLOCATION_ERROR; |
| return; |
| } |
| |
| // get the ISO code |
| int32_t isoLength = 0; |
| UResourceBundle *idRes = ures_getByKey(currencyRes, "id", NULL, &localStatus); |
| if (idRes == NULL) { |
| continue; |
| } |
| const UChar *isoCode = ures_getString(idRes, &isoLength, &localStatus); |
| |
| // get from date |
| UDate fromDate = U_DATE_MIN; |
| UResourceBundle *fromRes = ures_getByKey(currencyRes, "from", NULL, &localStatus); |
| |
| if (U_SUCCESS(localStatus)) { |
| int32_t fromLength = 0; |
| const int32_t *fromArray = ures_getIntVector(fromRes, &fromLength, &localStatus); |
| int64_t currDate64 = (int64_t)fromArray[0] << 32; |
| currDate64 |= ((int64_t)fromArray[1] & (int64_t)INT64_C(0x00000000FFFFFFFF)); |
| fromDate = (UDate)currDate64; |
| } |
| ures_close(fromRes); |
| |
| // get to date |
| UDate toDate = U_DATE_MAX; |
| localStatus = U_ZERO_ERROR; |
| UResourceBundle *toRes = ures_getByKey(currencyRes, "to", NULL, &localStatus); |
| |
| if (U_SUCCESS(localStatus)) { |
| int32_t toLength = 0; |
| const int32_t *toArray = ures_getIntVector(toRes, &toLength, &localStatus); |
| int64_t currDate64 = (int64_t)toArray[0] << 32; |
| currDate64 |= ((int64_t)toArray[1] & (int64_t)INT64_C(0x00000000FFFFFFFF)); |
| toDate = (UDate)currDate64; |
| } |
| ures_close(toRes); |
| |
| ures_close(idRes); |
| ures_close(currencyRes); |
| |
| entry->isoCode = isoCode; |
| entry->from = fromDate; |
| entry->to = toDate; |
| |
| localStatus = U_ZERO_ERROR; |
| uhash_put(isoCodes, (UChar *)isoCode, entry, &localStatus); |
| } |
| } else { |
| *status = localStatus; |
| } |
| ures_close(currencyArray); |
| } |
| } else { |
| *status = localStatus; |
| } |
| |
| ures_close(currencyMapArray); |
| } |
| |
| static const UEnumeration gEnumCurrencyList = { |
| NULL, |
| NULL, |
| ucurr_closeCurrencyList, |
| ucurr_countCurrencyList, |
| uenum_unextDefault, |
| ucurr_nextCurrencyList, |
| ucurr_resetCurrencyList |
| }; |
| U_CDECL_END |
| |
| |
| static void U_CALLCONV initIsoCodes(UErrorCode &status) { |
| U_ASSERT(gIsoCodes == NULL); |
| ucln_i18n_registerCleanup(UCLN_I18N_CURRENCY, currency_cleanup); |
| |
| UHashtable *isoCodes = uhash_open(uhash_hashUChars, uhash_compareUChars, NULL, &status); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| uhash_setValueDeleter(isoCodes, deleteIsoCodeEntry); |
| |
| ucurr_createCurrencyList(isoCodes, &status); |
| if (U_FAILURE(status)) { |
| uhash_close(isoCodes); |
| return; |
| } |
| gIsoCodes = isoCodes; // Note: gIsoCodes is const. Once set up here it is never altered, |
| // and read only access is safe without synchronization. |
| } |
| |
| static void populateCurrSymbolsEquiv(icu::Hashtable *hash, UErrorCode &status) { |
| if (U_FAILURE(status)) { |
| return; |
| } |
| int32_t length = sizeof(EQUIV_CURRENCY_SYMBOLS) / sizeof(EQUIV_CURRENCY_SYMBOLS[0]); |
| for (int32_t i = 0; i < length; ++i) { |
| icu::UnicodeString lhs(EQUIV_CURRENCY_SYMBOLS[i][0], -1, US_INV); |
| icu::UnicodeString rhs(EQUIV_CURRENCY_SYMBOLS[i][1], -1, US_INV); |
| makeEquivalent(lhs.unescape(), rhs.unescape(), hash, status); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| } |
| } |
| |
| static void U_CALLCONV initCurrSymbolsEquiv() { |
| U_ASSERT(gCurrSymbolsEquiv == NULL); |
| UErrorCode status = U_ZERO_ERROR; |
| ucln_i18n_registerCleanup(UCLN_I18N_CURRENCY, currency_cleanup); |
| icu::Hashtable *temp = new icu::Hashtable(status); |
| if (temp == NULL) { |
| return; |
| } |
| if (U_FAILURE(status)) { |
| delete temp; |
| return; |
| } |
| temp->setValueDeleter(deleteUnicode); |
| populateCurrSymbolsEquiv(temp, status); |
| if (U_FAILURE(status)) { |
| delete temp; |
| return; |
| } |
| gCurrSymbolsEquiv = temp; |
| } |
| |
| U_CAPI UBool U_EXPORT2 |
| ucurr_isAvailable(const UChar* isoCode, UDate from, UDate to, UErrorCode* eErrorCode) { |
| umtx_initOnce(gIsoCodesInitOnce, &initIsoCodes, *eErrorCode); |
| if (U_FAILURE(*eErrorCode)) { |
| return FALSE; |
| } |
| |
| IsoCodeEntry* result = (IsoCodeEntry *) uhash_get(gIsoCodes, isoCode); |
| if (result == NULL) { |
| return FALSE; |
| } else if (from > to) { |
| *eErrorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| return FALSE; |
| } else if ((from > result->to) || (to < result->from)) { |
| return FALSE; |
| } |
| return TRUE; |
| } |
| |
| static const icu::Hashtable* getCurrSymbolsEquiv() { |
| umtx_initOnce(gCurrSymbolsEquivInitOnce, &initCurrSymbolsEquiv); |
| return gCurrSymbolsEquiv; |
| } |
| |
| U_CAPI UEnumeration * U_EXPORT2 |
| ucurr_openISOCurrencies(uint32_t currType, UErrorCode *pErrorCode) { |
| UEnumeration *myEnum = NULL; |
| UCurrencyContext *myContext; |
| |
| myEnum = (UEnumeration*)uprv_malloc(sizeof(UEnumeration)); |
| if (myEnum == NULL) { |
| *pErrorCode = U_MEMORY_ALLOCATION_ERROR; |
| return NULL; |
| } |
| uprv_memcpy(myEnum, &gEnumCurrencyList, sizeof(UEnumeration)); |
| myContext = (UCurrencyContext*)uprv_malloc(sizeof(UCurrencyContext)); |
| if (myContext == NULL) { |
| *pErrorCode = U_MEMORY_ALLOCATION_ERROR; |
| uprv_free(myEnum); |
| return NULL; |
| } |
| myContext->currType = currType; |
| myContext->listIdx = 0; |
| myEnum->context = myContext; |
| return myEnum; |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| ucurr_countCurrencies(const char* locale, |
| UDate date, |
| UErrorCode* ec) |
| { |
| int32_t currCount = 0; |
| |
| if (ec != NULL && U_SUCCESS(*ec)) |
| { |
| // local variables |
| UErrorCode localStatus = U_ZERO_ERROR; |
| char id[ULOC_FULLNAME_CAPACITY]; |
| uloc_getKeywordValue(locale, "currency", id, ULOC_FULLNAME_CAPACITY, &localStatus); |
| // get country or country_variant in `id' |
| /*uint32_t variantType =*/ idForLocale(locale, id, sizeof(id), ec); |
| |
| if (U_FAILURE(*ec)) |
| { |
| return 0; |
| } |
| |
| // Remove variants, which is only needed for registration. |
| char *idDelim = strchr(id, VAR_DELIM); |
| if (idDelim) |
| { |
| idDelim[0] = 0; |
| } |
| |
| // Look up the CurrencyMap element in the root bundle. |
| UResourceBundle *rb = ures_openDirect(U_ICUDATA_CURR, CURRENCY_DATA, &localStatus); |
| UResourceBundle *cm = ures_getByKey(rb, CURRENCY_MAP, rb, &localStatus); |
| |
| // Using the id derived from the local, get the currency data |
| UResourceBundle *countryArray = ures_getByKey(rb, id, cm, &localStatus); |
| |
| // process each currency to see which one is valid for the given date |
| if (U_SUCCESS(localStatus)) |
| { |
| for (int32_t i=0; i<ures_getSize(countryArray); i++) |
| { |
| // get the currency resource |
| UResourceBundle *currencyRes = ures_getByIndex(countryArray, i, NULL, &localStatus); |
| |
| // get the from date |
| int32_t fromLength = 0; |
| UResourceBundle *fromRes = ures_getByKey(currencyRes, "from", NULL, &localStatus); |
| const int32_t *fromArray = ures_getIntVector(fromRes, &fromLength, &localStatus); |
| |
| int64_t currDate64 = (int64_t)fromArray[0] << 32; |
| currDate64 |= ((int64_t)fromArray[1] & (int64_t)INT64_C(0x00000000FFFFFFFF)); |
| UDate fromDate = (UDate)currDate64; |
| |
| if (ures_getSize(currencyRes)> 2) |
| { |
| int32_t toLength = 0; |
| UResourceBundle *toRes = ures_getByKey(currencyRes, "to", NULL, &localStatus); |
| const int32_t *toArray = ures_getIntVector(toRes, &toLength, &localStatus); |
| |
| currDate64 = (int64_t)toArray[0] << 32; |
| currDate64 |= ((int64_t)toArray[1] & (int64_t)INT64_C(0x00000000FFFFFFFF)); |
| UDate toDate = (UDate)currDate64; |
| |
| if ((fromDate <= date) && (date < toDate)) |
| { |
| currCount++; |
| } |
| |
| ures_close(toRes); |
| } |
| else |
| { |
| if (fromDate <= date) |
| { |
| currCount++; |
| } |
| } |
| |
| // close open resources |
| ures_close(currencyRes); |
| ures_close(fromRes); |
| |
| } // end For loop |
| } // end if (U_SUCCESS(localStatus)) |
| |
| ures_close(countryArray); |
| |
| // Check for errors |
| if (*ec == U_ZERO_ERROR || localStatus != U_ZERO_ERROR) |
| { |
| // There is nothing to fallback to. |
| // Report the failure/warning if possible. |
| *ec = localStatus; |
| } |
| |
| if (U_SUCCESS(*ec)) |
| { |
| // no errors |
| return currCount; |
| } |
| |
| } |
| |
| // If we got here, either error code is invalid or |
| // some argument passed is no good. |
| return 0; |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| ucurr_forLocaleAndDate(const char* locale, |
| UDate date, |
| int32_t index, |
| UChar* buff, |
| int32_t buffCapacity, |
| UErrorCode* ec) |
| { |
| int32_t resLen = 0; |
| int32_t currIndex = 0; |
| const UChar* s = NULL; |
| |
| if (ec != NULL && U_SUCCESS(*ec)) |
| { |
| // check the arguments passed |
| if ((buff && buffCapacity) || !buffCapacity ) |
| { |
| // local variables |
| UErrorCode localStatus = U_ZERO_ERROR; |
| char id[ULOC_FULLNAME_CAPACITY]; |
| resLen = uloc_getKeywordValue(locale, "currency", id, ULOC_FULLNAME_CAPACITY, &localStatus); |
| |
| // get country or country_variant in `id' |
| /*uint32_t variantType =*/ idForLocale(locale, id, sizeof(id), ec); |
| if (U_FAILURE(*ec)) |
| { |
| return 0; |
| } |
| |
| // Remove variants, which is only needed for registration. |
| char *idDelim = strchr(id, VAR_DELIM); |
| if (idDelim) |
| { |
| idDelim[0] = 0; |
| } |
| |
| // Look up the CurrencyMap element in the root bundle. |
| UResourceBundle *rb = ures_openDirect(U_ICUDATA_CURR, CURRENCY_DATA, &localStatus); |
| UResourceBundle *cm = ures_getByKey(rb, CURRENCY_MAP, rb, &localStatus); |
| |
| // Using the id derived from the local, get the currency data |
| UResourceBundle *countryArray = ures_getByKey(rb, id, cm, &localStatus); |
| |
| // process each currency to see which one is valid for the given date |
| bool matchFound = false; |
| if (U_SUCCESS(localStatus)) |
| { |
| if ((index <= 0) || (index> ures_getSize(countryArray))) |
| { |
| // requested index is out of bounds |
| ures_close(countryArray); |
| return 0; |
| } |
| |
| for (int32_t i=0; i<ures_getSize(countryArray); i++) |
| { |
| // get the currency resource |
| UResourceBundle *currencyRes = ures_getByIndex(countryArray, i, NULL, &localStatus); |
| s = ures_getStringByKey(currencyRes, "id", &resLen, &localStatus); |
| |
| // get the from date |
| int32_t fromLength = 0; |
| UResourceBundle *fromRes = ures_getByKey(currencyRes, "from", NULL, &localStatus); |
| const int32_t *fromArray = ures_getIntVector(fromRes, &fromLength, &localStatus); |
| |
| int64_t currDate64 = (int64_t)fromArray[0] << 32; |
| currDate64 |= ((int64_t)fromArray[1] & (int64_t)INT64_C(0x00000000FFFFFFFF)); |
| UDate fromDate = (UDate)currDate64; |
| |
| if (ures_getSize(currencyRes)> 2) |
| { |
| int32_t toLength = 0; |
| UResourceBundle *toRes = ures_getByKey(currencyRes, "to", NULL, &localStatus); |
| const int32_t *toArray = ures_getIntVector(toRes, &toLength, &localStatus); |
| |
| currDate64 = (int64_t)toArray[0] << 32; |
| currDate64 |= ((int64_t)toArray[1] & (int64_t)INT64_C(0x00000000FFFFFFFF)); |
| UDate toDate = (UDate)currDate64; |
| |
| if ((fromDate <= date) && (date < toDate)) |
| { |
| currIndex++; |
| if (currIndex == index) |
| { |
| matchFound = true; |
| } |
| } |
| |
| ures_close(toRes); |
| } |
| else |
| { |
| if (fromDate <= date) |
| { |
| currIndex++; |
| if (currIndex == index) |
| { |
| matchFound = true; |
| } |
| } |
| } |
| |
| // close open resources |
| ures_close(currencyRes); |
| ures_close(fromRes); |
| |
| // check for loop exit |
| if (matchFound) |
| { |
| break; |
| } |
| |
| } // end For loop |
| } |
| |
| ures_close(countryArray); |
| |
| // Check for errors |
| if (*ec == U_ZERO_ERROR || localStatus != U_ZERO_ERROR) |
| { |
| // There is nothing to fallback to. |
| // Report the failure/warning if possible. |
| *ec = localStatus; |
| } |
| |
| if (U_SUCCESS(*ec)) |
| { |
| // no errors |
| if((buffCapacity> resLen) && matchFound) |
| { |
| // write out the currency value |
| u_strcpy(buff, s); |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| |
| // return null terminated currency string |
| return u_terminateUChars(buff, buffCapacity, resLen, ec); |
| } |
| else |
| { |
| // illegal argument encountered |
| *ec = U_ILLEGAL_ARGUMENT_ERROR; |
| } |
| |
| } |
| |
| // If we got here, either error code is invalid or |
| // some argument passed is no good. |
| return resLen; |
| } |
| |
| static const UEnumeration defaultKeywordValues = { |
| NULL, |
| NULL, |
| ulist_close_keyword_values_iterator, |
| ulist_count_keyword_values, |
| uenum_unextDefault, |
| ulist_next_keyword_value, |
| ulist_reset_keyword_values_iterator |
| }; |
| |
| U_CAPI UEnumeration *U_EXPORT2 ucurr_getKeywordValuesForLocale(const char *key, const char *locale, UBool commonlyUsed, UErrorCode* status) { |
| // Resolve region |
| char prefRegion[ULOC_FULLNAME_CAPACITY] = ""; |
| int32_t prefRegionLength = 0; |
| prefRegionLength = uloc_getCountry(locale, prefRegion, sizeof(prefRegion), status); |
| if (prefRegionLength == 0) { |
| char loc[ULOC_FULLNAME_CAPACITY] = ""; |
| uloc_addLikelySubtags(locale, loc, sizeof(loc), status); |
| |
| /*prefRegionLength = */ uloc_getCountry(loc, prefRegion, sizeof(prefRegion), status); |
| } |
| |
| // Read value from supplementalData |
| UList *values = ulist_createEmptyList(status); |
| UList *otherValues = ulist_createEmptyList(status); |
| UEnumeration *en = (UEnumeration *)uprv_malloc(sizeof(UEnumeration)); |
| if (U_FAILURE(*status) || en == NULL) { |
| if (en == NULL) { |
| *status = U_MEMORY_ALLOCATION_ERROR; |
| } else { |
| uprv_free(en); |
| } |
| ulist_deleteList(values); |
| ulist_deleteList(otherValues); |
| return NULL; |
| } |
| memcpy(en, &defaultKeywordValues, sizeof(UEnumeration)); |
| en->context = values; |
| |
| UResourceBundle *bundle = ures_openDirect(U_ICUDATA_CURR, "supplementalData", status); |
| ures_getByKey(bundle, "CurrencyMap", bundle, status); |
| UResourceBundle bundlekey, regbndl, curbndl, to; |
| ures_initStackObject(&bundlekey); |
| ures_initStackObject(®bndl); |
| ures_initStackObject(&curbndl); |
| ures_initStackObject(&to); |
| |
| while (U_SUCCESS(*status) && ures_hasNext(bundle)) { |
| ures_getNextResource(bundle, &bundlekey, status); |
| if (U_FAILURE(*status)) { |
| break; |
| } |
| const char *region = ures_getKey(&bundlekey); |
| UBool isPrefRegion = uprv_strcmp(region, prefRegion) == 0 ? TRUE : FALSE; |
| if (!isPrefRegion && commonlyUsed) { |
| // With commonlyUsed=true, we do not put |
| // currencies for other regions in the |
| // result list. |
| continue; |
| } |
| ures_getByKey(bundle, region, ®bndl, status); |
| if (U_FAILURE(*status)) { |
| break; |
| } |
| while (U_SUCCESS(*status) && ures_hasNext(®bndl)) { |
| ures_getNextResource(®bndl, &curbndl, status); |
| if (ures_getType(&curbndl) != URES_TABLE) { |
| // Currently, an empty ARRAY is mixed in. |
| continue; |
| } |
| char *curID = (char *)uprv_malloc(sizeof(char) * ULOC_KEYWORDS_CAPACITY); |
| int32_t curIDLength = ULOC_KEYWORDS_CAPACITY; |
| if (curID == NULL) { |
| *status = U_MEMORY_ALLOCATION_ERROR; |
| break; |
| } |
| |
| #if U_CHARSET_FAMILY==U_ASCII_FAMILY |
| ures_getUTF8StringByKey(&curbndl, "id", curID, &curIDLength, TRUE, status); |
| /* optimize - use the utf-8 string */ |
| #else |
| { |
| const UChar* defString = ures_getStringByKey(&curbndl, "id", &curIDLength, status); |
| if(U_SUCCESS(*status)) { |
| if(curIDLength+1 > ULOC_KEYWORDS_CAPACITY) { |
| *status = U_BUFFER_OVERFLOW_ERROR; |
| } else { |
| u_UCharsToChars(defString, curID, curIDLength+1); |
| } |
| } |
| } |
| #endif |
| |
| if (U_FAILURE(*status)) { |
| break; |
| } |
| UBool hasTo = FALSE; |
| ures_getByKey(&curbndl, "to", &to, status); |
| if (U_FAILURE(*status)) { |
| // Do nothing here... |
| *status = U_ZERO_ERROR; |
| } else { |
| hasTo = TRUE; |
| } |
| if (isPrefRegion && !hasTo && !ulist_containsString(values, curID, (int32_t)uprv_strlen(curID))) { |
| // Currently active currency for the target country |
| ulist_addItemEndList(values, curID, TRUE, status); |
| } else if (!ulist_containsString(otherValues, curID, (int32_t)uprv_strlen(curID)) && !commonlyUsed) { |
| ulist_addItemEndList(otherValues, curID, TRUE, status); |
| } else { |
| uprv_free(curID); |
| } |
| } |
| |
| } |
| if (U_SUCCESS(*status)) { |
| if (commonlyUsed) { |
| if (ulist_getListSize(values) == 0) { |
| // This could happen if no valid region is supplied in the input |
| // locale. In this case, we use the CLDR's default. |
| uenum_close(en); |
| en = ucurr_getKeywordValuesForLocale(key, "und", TRUE, status); |
| } |
| } else { |
| // Consolidate the list |
| char *value = NULL; |
| ulist_resetList(otherValues); |
| while ((value = (char *)ulist_getNext(otherValues)) != NULL) { |
| if (!ulist_containsString(values, value, (int32_t)uprv_strlen(value))) { |
| char *tmpValue = (char *)uprv_malloc(sizeof(char) * ULOC_KEYWORDS_CAPACITY); |
| uprv_memcpy(tmpValue, value, uprv_strlen(value) + 1); |
| ulist_addItemEndList(values, tmpValue, TRUE, status); |
| if (U_FAILURE(*status)) { |
| break; |
| } |
| } |
| } |
| } |
| |
| ulist_resetList((UList *)(en->context)); |
| } else { |
| ulist_deleteList(values); |
| uprv_free(en); |
| values = NULL; |
| en = NULL; |
| } |
| ures_close(&to); |
| ures_close(&curbndl); |
| ures_close(®bndl); |
| ures_close(&bundlekey); |
| ures_close(bundle); |
| |
| ulist_deleteList(otherValues); |
| |
| return en; |
| } |
| |
| |
| U_CAPI int32_t U_EXPORT2 |
| ucurr_getNumericCode(const UChar* currency) { |
| int32_t code = 0; |
| if (currency && u_strlen(currency) == ISO_CURRENCY_CODE_LENGTH) { |
| UErrorCode status = U_ZERO_ERROR; |
| |
| UResourceBundle *bundle = ures_openDirect(0, "currencyNumericCodes", &status); |
| ures_getByKey(bundle, "codeMap", bundle, &status); |
| if (U_SUCCESS(status)) { |
| char alphaCode[ISO_CURRENCY_CODE_LENGTH+1]; |
| myUCharsToChars(alphaCode, currency); |
| T_CString_toUpperCase(alphaCode); |
| ures_getByKey(bundle, alphaCode, bundle, &status); |
| int tmpCode = ures_getInt(bundle, &status); |
| if (U_SUCCESS(status)) { |
| code = tmpCode; |
| } |
| } |
| ures_close(bundle); |
| } |
| return code; |
| } |
| #endif /* #if !UCONFIG_NO_FORMATTING */ |
| |
| //eof |
