ICU 56 update step 1

source/i18n/numfmt.cpp

 /*
 *******************************************************************************
-* Copyright (C) 1997-2014, International Business Machines Corporation and
+* Copyright (C) 1997-2015, International Business Machines Corporation and
 * others. All Rights Reserved.
 *******************************************************************************
 *
 * File NUMFMT.CPP
 *
 * Modification History:
 *
 *   Date        Name        Description
 *   02/19/97    aliu        Converted from java.
 *   03/18/97    clhuang     Implemented with C++ APIs.
@@ skipping 99 matching lines @@
     gLastResortScientificPat,  // UNUM_SCIENTIFIC
     NULL,  // UNUM_SPELLOUT
     NULL,  // UNUM_ORDINAL
     NULL,  // UNUM_DURATION
     NULL,  // UNUM_NUMBERING_SYSTEM
     NULL,  // UNUM_PATTERN_RULEBASED
     gLastResortIsoCurrencyPat,  // UNUM_CURRENCY_ISO
     gLastResortPluralCurrencyPat,  // UNUM_CURRENCY_PLURAL
     gLastResortAccountingCurrencyPat, // UNUM_CURRENCY_ACCOUNTING
     gLastResortCurrencyPat,  // UNUM_CASH_CURRENCY 
+    NULL,  // UNUM_DECIMAL_COMPACT_SHORT
+    NULL,  // UNUM_DECIMAL_COMPACT_LONG
+    gLastResortCurrencyPat,  // UNUM_CURRENCY_STANDARD
 };
 
 // Keys used for accessing resource bundles
 
 static const char *gNumberElements = "NumberElements";
 static const char *gLatn = "latn";
 static const char *gPatterns = "patterns";
 static const char *gFormatKeys[UNUM_FORMAT_STYLE_COUNT] = {
     NULL,  // UNUM_PATTERN_DECIMAL
     "decimalFormat",  // UNUM_DECIMAL
     "currencyFormat",  // UNUM_CURRENCY
     "percentFormat",  // UNUM_PERCENT
     "scientificFormat",  // UNUM_SCIENTIFIC
     NULL,  // UNUM_SPELLOUT
     NULL,  // UNUM_ORDINAL
     NULL,  // UNUM_DURATION
     NULL,  // UNUM_NUMBERING_SYSTEM
     NULL,  // UNUM_PATTERN_RULEBASED
     // For UNUM_CURRENCY_ISO and UNUM_CURRENCY_PLURAL,
     // the pattern is the same as the pattern of UNUM_CURRENCY
     // except for replacing the single currency sign with
     // double currency sign or triple currency sign.
     "currencyFormat",  // UNUM_CURRENCY_ISO
     "currencyFormat",  // UNUM_CURRENCY_PLURAL
     "accountingFormat",  // UNUM_CURRENCY_ACCOUNTING
-    "currencyFormat"  // UNUM_CASH_CURRENCY
+    "currencyFormat",  // UNUM_CASH_CURRENCY
+    NULL,  // UNUM_DECIMAL_COMPACT_SHORT
+    NULL,  // UNUM_DECIMAL_COMPACT_LONG
+    "currencyFormat",  // UNUM_CURRENCY_STANDARD
 };
 
 // Static hashtable cache of NumberingSystem objects used by NumberFormat
 static UHashtable * NumberingSystem_cache = NULL;
 static UMutex nscacheMutex = U_MUTEX_INITIALIZER;
 static icu::UInitOnce gNSCacheInitOnce = U_INITONCE_INITIALIZER;
 
 #if !UCONFIG_NO_SERVICE
 static icu::ICULocaleService* gService = NULL;
 static icu::UInitOnce gServiceInitOnce = U_INITONCE_INITIALIZER;
@@ skipping 565 matching lines @@
                                             ParsePosition& pos) const {
     // Default implementation only -- subclasses should override
     Formattable parseResult;
     int32_t start = pos.getIndex();
     parse(text, parseResult, pos);
     if (pos.getIndex() != start) {
         UChar curr[4];
         UErrorCode ec = U_ZERO_ERROR;
         getEffectiveCurrency(curr, ec);
         if (U_SUCCESS(ec)) {
-            LocalPointer<CurrencyAmount> currAmt(new CurrencyAmount(parseResult, curr, ec));
+            LocalPointer<CurrencyAmount> currAmt(new CurrencyAmount(parseResult, curr, ec), ec);
             if (U_FAILURE(ec)) {
                 pos.setIndex(start); // indicate failure
             } else {
                 return currAmt.orphan();
             }
         }
     }
     return NULL;
 }
 
@@ skipping 268 matching lines @@
 {
   ICULocaleService *service = getNumberFormatService();
   if (service) {
       return service->getAvailableLocales();
   }
   return NULL; // no way to return error condition
 }
 #endif /* UCONFIG_NO_SERVICE */
 // -------------------------------------
 
+enum { kKeyValueLenMax = 32 };
+
 NumberFormat*
 NumberFormat::internalCreateInstance(const Locale& loc, UNumberFormatStyle kind, UErrorCode& status) {
+    if (kind == UNUM_CURRENCY) {
+        char cfKeyValue[kKeyValueLenMax] = {0};
+        UErrorCode kvStatus = U_ZERO_ERROR;
+        int32_t kLen = loc.getKeywordValue("cf", cfKeyValue, kKeyValueLenMax, kvStatus);
+        if (U_SUCCESS(kvStatus) && kLen > 0 && uprv_strcmp(cfKeyValue,"account")==0) {
+            kind = UNUM_CURRENCY_ACCOUNTING;
+        }
+    }
 #if !UCONFIG_NO_SERVICE
     if (haveService()) {
         return (NumberFormat*)gService->get(loc, kind, status);
     }
 #endif
     return makeInstance(loc, kind, status);
 }
 
 NumberFormat* U_EXPORT2
 NumberFormat::createInstance(const Locale& loc, UNumberFormatStyle kind, UErrorCode& status) {
@@ skipping 280 matching lines @@
             switch (style) {
             case UNUM_DECIMAL:
                 curr = FALSE;
                 // fall-through
 
             case UNUM_CURRENCY:
             case UNUM_CURRENCY_ISO: // do not support plural formatting here
             case UNUM_CURRENCY_PLURAL:
             case UNUM_CURRENCY_ACCOUNTING:
             case UNUM_CASH_CURRENCY:
+            case UNUM_CURRENCY_STANDARD:
                 f = new Win32NumberFormat(desiredLocale, curr, status);
 
                 if (U_SUCCESS(status)) {
                     return f;
                 }
 
                 delete f;
                 break;
             default:
                 break;
@@ skipping 33 matching lines @@
     }
 
     LocalPointer<DecimalFormatSymbols> symbolsToAdopt;
     UnicodeString pattern;
     LocalUResourceBundlePointer ownedResource(ures_open(NULL, desiredLocale.getName(), &status));
     if (U_FAILURE(status)) {
         return NULL;
     }
     else {
         // Loads the decimal symbols of the desired locale.
-        symbolsToAdopt.adoptInstead(new DecimalFormatSymbols(desiredLocale, status));
-        if (symbolsToAdopt.isNull()) {
-            status = U_MEMORY_ALLOCATION_ERROR;
+        symbolsToAdopt.adoptInsteadAndCheckErrorCode(new DecimalFormatSymbols(desiredLocale, status), status);
+        if (U_FAILURE(status)) {
             return NULL;
         }
 
         UResourceBundle *resource = ownedResource.orphan();
         UResourceBundle *numElements = ures_getByKeyWithFallback(resource, gNumberElements, NULL, &status);
         resource = ures_getByKeyWithFallback(numElements, ns->getName(), resource, &status);
         resource = ures_getByKeyWithFallback(resource, gPatterns, resource, &status);
         ownedResource.adoptInstead(resource);
 
         int32_t patLen = 0;
         const UChar *patResStr = ures_getStringByKeyWithFallback(resource, gFormatKeys[style], &patLen, &status);
 
         // Didn't find a pattern specific to the numbering system, so fall back to "latn"
         if ( status == U_MISSING_RESOURCE_ERROR && uprv_strcmp(gLatn,ns->getName())) {  
             status = U_ZERO_ERROR;
             resource = ures_getByKeyWithFallback(numElements, gLatn, resource, &status);
             resource = ures_getByKeyWithFallback(resource, gPatterns, resource, &status);
             patResStr = ures_getStringByKeyWithFallback(resource, gFormatKeys[style], &patLen, &status);
         }
 
         ures_close(numElements);
 
         // Creates the specified decimal format style of the desired locale.
         pattern.setTo(TRUE, patResStr, patLen);
     }
     if (U_FAILURE(status)) {
         return NULL;
     }
     if(style==UNUM_CURRENCY || style == UNUM_CURRENCY_ISO || style == UNUM_CURRENCY_ACCOUNTING 
-        || style == UNUM_CASH_CURRENCY){
+        || style == UNUM_CASH_CURRENCY || style == UNUM_CURRENCY_STANDARD){
         const UChar* currPattern = symbolsToAdopt->getCurrencyPattern();
         if(currPattern!=NULL){
             pattern.setTo(currPattern, u_strlen(currPattern));
         }
     }
 
 
     NumberFormat *f;
     if (ns->isAlgorithmic()) {
         UnicodeString nsDesc;
@@ skipping 67 matching lines @@
         return NULL;
     }
     return f;
 }
 
 U_NAMESPACE_END
 
 #endif /* #if !UCONFIG_NO_FORMATTING */
 
 //eof