自学教程：C++ ures_open函数代码示例

U_CAPI void U_EXPORT2ulocdata_getPaperSize(const char* localeID, int32_t *height, int32_t *width, UErrorCode *status){    UResourceBundle* bundle=NULL;    UResourceBundle* paperSizeBundle = NULL;    const int32_t* paperSize=NULL;    int32_t len = 0;    if(status == NULL || U_FAILURE(*status)){        return;    }    bundle = ures_open(NULL, localeID, status);    paperSizeBundle = ures_getByKey(bundle, PAPER_SIZE, NULL, status);    paperSize = ures_getIntVector(paperSizeBundle, &len,  status);    if(U_SUCCESS(*status)){        if(len < 2){            *status = U_INTERNAL_PROGRAM_ERROR;        }else{            *height = paperSize[0];            *width  = paperSize[1];        }    }    ures_close(bundle);    ures_close(paperSizeBundle);}

U_CAPI ULocaleData* U_EXPORT2ulocdata_open(const char *localeID, UErrorCode *status){   ULocaleData *uld;   if (U_FAILURE(*status)) {       return NULL;   }   uld = (ULocaleData *)uprv_malloc(sizeof(ULocaleData));   if (uld == NULL) {      *status = U_MEMORY_ALLOCATION_ERROR;      return(NULL);   }   uld->noSubstitute = FALSE;   uld->bundle = ures_open(NULL, localeID, status);   if (U_FAILURE(*status)) {      uprv_free(uld);      return NULL;   }   return uld;}

static jstring ICU_getCurrencySymbolNative(JNIEnv* env, jclass, jstring locale, jstring currencyCode) {    ScopedUtfChars localeName(env, locale);    UErrorCode status = U_ZERO_ERROR;    ScopedResourceBundle currLoc(ures_open(U_ICUDATA_CURR, localeName.c_str(), &status));    if (U_FAILURE(status)) {        return NULL;    }    ScopedResourceBundle currencies(ures_getByKey(currLoc.get(), "Currencies", NULL, &status));    if (U_FAILURE(status)) {        return NULL;    }    ScopedUtfChars currency(env, currencyCode);    ScopedResourceBundle currencyElems(ures_getByKey(currencies.get(), currency.c_str(), NULL, &status));    if (U_FAILURE(status)) {        return NULL;    }    int currSymbL;    const jchar* currSymbU = ures_getStringByIndex(currencyElems.get(), 0, &currSymbL, &status);    if (U_FAILURE(status)) {        return NULL;    }    return (currSymbL == 0) ? NULL : env->NewString(currSymbU, currSymbL);}

void CalendarData::initData(const char *locale, const char *type, UErrorCode& status) {  fOtherFillin = ures_open(U_CALENDAR_DATA, locale, &status);  fFillin = ures_getByKey(fOtherFillin, U_CALENDAR_KEY, fFillin, &status);  if((type != NULL) &&      (*type != '/0') &&      (uprv_strcmp(type, U_GREGORIAN_KEY)))  {    fBundle = ures_getByKeyWithFallback(fFillin, type, NULL, &status);    fFallback = ures_getByKeyWithFallback(fFillin, U_GREGORIAN_KEY, NULL, &status);#if defined (U_DEBUG_CALDATA)    fprintf(stderr, "%p: CalendarData(%s, %s, %s) -> main(%p, %s)=%s, fallback(%p, %s)=%s/n",             this, locale, type, u_errorName(status), fBundle, type, fBundle?ures_getLocale(fBundle, &status):"",             fFallback, U_GREGORIAN_KEY, fFallback?ures_getLocale(fFallback, &status):"");#endif  } else {    fBundle = ures_getByKeyWithFallback(fFillin, U_GREGORIAN_KEY, NULL, &status);#if defined (U_DEBUG_CALDATA)    fprintf(stderr, "%p: CalendarData(%s, %s, %s) -> main(%p, %s)=%s, fallback = NULL/n",            this, locale, type, u_errorName(status), fBundle, U_GREGORIAN_KEY, fBundle?ures_getLocale(fBundle, &status):"" );#endif  }}

static ListFormatInternal* loadListFormatInternal(        const Locale& locale, const char * style, UErrorCode& errorCode) {    UResourceBundle* rb = ures_open(NULL, locale.getName(), &errorCode);    if (U_FAILURE(errorCode)) {        ures_close(rb);        return NULL;    }    rb = ures_getByKeyWithFallback(rb, "listPattern", rb, &errorCode);    rb = ures_getByKeyWithFallback(rb, style, rb, &errorCode);    if (U_FAILURE(errorCode)) {        ures_close(rb);        return NULL;    }    UnicodeString two, start, middle, end;    getStringByKey(rb, "2", two, errorCode);    getStringByKey(rb, "start", start, errorCode);    getStringByKey(rb, "middle", middle, errorCode);    getStringByKey(rb, "end", end, errorCode);    ures_close(rb);    if (U_FAILURE(errorCode)) {        return NULL;    }    ListFormatInternal* result = new ListFormatInternal(two, start, middle, end, errorCode);    if (result == NULL) {        errorCode = U_MEMORY_ALLOCATION_ERROR;        return NULL;    }    if (U_FAILURE(errorCode)) {        delete result;        return NULL;    }    return result;}

voidResourceBundleTest::TestExemplar(){    int32_t locCount = uloc_countAvailable();    int32_t locIndex=0;    int num=0;    UErrorCode status = U_ZERO_ERROR;    for(;locIndex<locCount;locIndex++){        const char* locale = uloc_getAvailable(locIndex);        UResourceBundle *resb =ures_open(NULL,locale,&status);        if(U_SUCCESS(status) && status!=U_USING_FALLBACK_WARNING && status!=U_USING_DEFAULT_WARNING){            int32_t len=0;            const UChar* strSet = ures_getStringByKey(resb,"ExemplarCharacters",&len,&status);            UnicodeSet set(strSet,status);            if(U_FAILURE(status)){                errln("Could not construct UnicodeSet from pattern for ExemplarCharacters in locale : %s. Error: %s",locale,u_errorName(status));                status=U_ZERO_ERROR;            }            num++;        }        ures_close(resb);    }    logln("Number of installed locales with exemplar characters that could be tested: %d",num);}

static bool getYesterdayTodayAndTomorrow(JNIEnv* env, jobject localeData, const char* locale_name) {  UErrorCode status = U_ZERO_ERROR;  ScopedResourceBundle root(ures_open(NULL, locale_name, &status));  if (U_FAILURE(status)) {    return false;  }  ScopedResourceBundle fields(ures_getByKey(root.get(), "fields", NULL, &status));  if (U_FAILURE(status)) {    return false;  }  ScopedResourceBundle day(ures_getByKey(fields.get(), "day", NULL, &status));  if (U_FAILURE(status)) {    return false;  }  ScopedResourceBundle relative(ures_getByKey(day.get(), "relative", NULL, &status));  if (U_FAILURE(status)) {    return false;  }  // bn_BD only has a "-2" entry.  if (relative.hasKey("-1") && relative.hasKey("0") && relative.hasKey("1")) {    setStringField(env, localeData, "yesterday", relative.get(), "-1");    setStringField(env, localeData, "today", relative.get(), "0");    setStringField(env, localeData, "tomorrow", relative.get(), "1");    return true;  }  return false;}

NumberingSystem* U_EXPORT2NumberingSystem::createInstance(const Locale & inLocale, UErrorCode& status) {    char buffer[ULOC_KEYWORDS_CAPACITY];    int32_t count = inLocale.getKeywordValue("numbers",buffer, sizeof(buffer),status);    if ( count > 0 ) { // @numbers keyword was specified in the locale        buffer[count] = '/0'; // Make sure it is null terminated.        return NumberingSystem::createInstanceByName(buffer,status);    } else { // Find the default numbering system for this locale.        LocalUResourceBundlePointer resource(ures_open(NULL, inLocale.getName(), &status));        if (U_FAILURE(status)) {            status = U_USING_FALLBACK_WARNING;            NumberingSystem *ns = new NumberingSystem();            return ns;        }         const UChar *defaultNSName =            ures_getStringByKeyWithFallback(resource.getAlias(), gDefaultNumberingSystem, &count, &status);        if (U_FAILURE(status)) {               return NULL;        }        if ( count > 0 && count < ULOC_KEYWORDS_CAPACITY ) { // Default numbering system found           u_UCharsToChars(defaultNSName,buffer,count);            buffer[count] = '/0'; // Make sure it is null terminated.           return NumberingSystem::createInstanceByName(buffer,status);        } else {            status = U_USING_FALLBACK_WARNING;            NumberingSystem *ns = new NumberingSystem();            return ns;        }            }}

U_CAPI const UChar* U_EXPORT2ucurr_forLocale(const char* locale, UErrorCode* ec) {    if (ec != NULL && U_SUCCESS(*ec)) {        char id[ULOC_FULLNAME_CAPACITY];        idForLocale(locale, id, sizeof(id), ec);        if (U_FAILURE(*ec)) {            return NULL;        }                const UChar* result = CReg::get(id);        if (result) {            return result;        }                // Look up the CurrencyMap element in the root bundle.        UResourceBundle* rb = ures_open(NULL, "", ec);        UResourceBundle* cm = ures_getByKey(rb, CURRENCY_MAP, NULL, ec);        int32_t len;        const UChar* s = ures_getStringByKey(cm, id, &len, ec);        ures_close(cm);        ures_close(rb);                if (U_SUCCESS(*ec)) {            return s;        }    }    return NULL;}

static bool getYesterdayTodayAndTomorrow(JNIEnv* env, jobject localeData, const Locale& locale, const char* locale_name) {  UErrorCode status = U_ZERO_ERROR;  ScopedResourceBundle root(ures_open(NULL, locale_name, &status));  ScopedResourceBundle fields(ures_getByKey(root.get(), "fields", NULL, &status));  ScopedResourceBundle day(ures_getByKey(fields.get(), "day", NULL, &status));  ScopedResourceBundle relative(ures_getByKey(day.get(), "relative", NULL, &status));  if (U_FAILURE(status)) {    return false;  }  UnicodeString yesterday(ures_getUnicodeStringByKey(relative.get(), "-1", &status));  UnicodeString today(ures_getUnicodeStringByKey(relative.get(), "0", &status));  UnicodeString tomorrow(ures_getUnicodeStringByKey(relative.get(), "1", &status));  if (U_FAILURE(status)) {    ALOGE("Error getting yesterday/today/tomorrow for %s: %s", locale_name, u_errorName(status));    return false;  }  // We title-case the strings so they have consistent capitalization (http://b/14493853).  UniquePtr<BreakIterator> brk(BreakIterator::createSentenceInstance(locale, status));  if (U_FAILURE(status)) {    ALOGE("Error getting yesterday/today/tomorrow break iterator for %s: %s", locale_name, u_errorName(status));    return false;  }  yesterday.toTitle(brk.get(), locale, U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT);  today.toTitle(brk.get(), locale, U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT);  tomorrow.toTitle(brk.get(), locale, U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT);  setStringField(env, localeData, "yesterday", yesterday);  setStringField(env, localeData, "today", today);  setStringField(env, localeData, "tomorrow", tomorrow);  return true;}

  virtual UObject* create(const ICUServiceKey& key, const ICUService* /*service*/, UErrorCode& status) const  {  LocaleKey &lkey = (LocaleKey&)key;  Locale loc;  lkey.currentLocale(loc);#ifdef U_DEBUG_CALSVC  fprintf(stderr, "DefaultCalendar factory %p: looking up %s/n",           this, (const char*)loc.getName());#endif  UErrorCode resStatus = U_ZERO_ERROR;  UResourceBundle *rb = ures_open(NULL, (const char*)loc.getName(), &resStatus);#ifdef U_DEBUG_CALSVC  fprintf(stderr, "... ures_open -> %s/n", u_errorName(resStatus));#endif  if(U_FAILURE(resStatus) ||      (resStatus == U_USING_DEFAULT_WARNING) || (resStatus==U_USING_FALLBACK_WARNING)) { //Don't want to handle fallback data.    ures_close(rb);    status = resStatus; // propagate err back to caller#ifdef U_DEBUG_CALSVC    fprintf(stderr, "... exitting (NULL)/n");#endif    return NULL;  }  int32_t len = 0;  UnicodeString myString = ures_getUnicodeStringByKey(rb, Calendar::kDefaultCalendar, &status);#ifdef U_DEBUG_CALSVC  UErrorCode debugStatus = U_ZERO_ERROR;  const UChar *defCal = ures_getStringByKey(rb, Calendar::kDefaultCalendar, &len,  &debugStatus);  fprintf(stderr, "... get string(%d) -> %s/n", len, u_errorName(debugStatus));#endif  ures_close(rb);     if(U_FAILURE(status)) {    return NULL;  } #ifdef U_DEBUG_CALSVC   {     char defCalStr[200];     if(len > 199) {       len = 199;     }     u_UCharsToChars(defCal, defCalStr, len);     defCalStr[len]=0;     fprintf(stderr, "DefaultCalendarFactory: looked up %s, got DefaultCalendar= %s/n",  (const char*)loc.getName(), defCalStr);   }#endif   return myString.clone(); }

U_CFUNC UResourceBundle *u_wmsg_setPath(const char *path, UErrorCode *err){  if(U_FAILURE(*err))  {    return 0;  }  if(gBundle != NULL)  {    *err = U_ILLEGAL_ARGUMENT_ERROR;    return 0;  }  else  {    UResourceBundle *b = NULL;    b = ures_open(path, NULL, err);    if(U_FAILURE(*err))    {         return 0;    }    gBundle = b;    U_STRING_INIT(gNoFormatting, " (UCONFIG_NO_FORMATTING see uconfig.h)", 38);  }    return gBundle;}

static jstring ICU_getCurrencySymbol(JNIEnv* env, jclass, jstring locale, jstring currencyCode) {    // We can't use ucurr_getName because it doesn't distinguish between using data root from    // the root locale and parroting back the input because it's never heard of the currency code.    ScopedUtfChars localeName(env, locale);    UErrorCode status = U_ZERO_ERROR;    ScopedResourceBundle currLoc(ures_open(U_ICUDATA_CURR, localeName.c_str(), &status));    if (U_FAILURE(status)) {        return NULL;    }    ScopedResourceBundle currencies(ures_getByKey(currLoc.get(), "Currencies", NULL, &status));    if (U_FAILURE(status)) {        return NULL;    }    ScopedUtfChars currency(env, currencyCode);    ScopedResourceBundle currencyElems(ures_getByKey(currencies.get(), currency.c_str(), NULL, &status));    if (U_FAILURE(status)) {        return NULL;    }    int32_t charCount;    const jchar* chars = ures_getStringByIndex(currencyElems.get(), 0, &charCount, &status);    if (U_FAILURE(status)) {        return NULL;    }    return (charCount == 0) ? NULL : env->NewString(chars, charCount);}

static jstring getCurrencySymbolNative(JNIEnv* env, jclass clazz,         jstring locale, jstring currencyCode) {    // LOGI("ENTER getCurrencySymbolNative");    const char* locName = env->GetStringUTFChars(locale, NULL);    UErrorCode status = U_ZERO_ERROR;    ScopedResourceBundle root(ures_open(NULL, locName, &status));    env->ReleaseStringUTFChars(locale, locName);    if (U_FAILURE(status)) {        return NULL;    }    ScopedResourceBundle currencies(ures_getByKey(root.get(), "Currencies", NULL, &status));    if (U_FAILURE(status)) {        return NULL;    }    const char* currName = env->GetStringUTFChars(currencyCode, NULL);    ScopedResourceBundle currencyElems(ures_getByKey(currencies.get(), currName, NULL, &status));    env->ReleaseStringUTFChars(currencyCode, currName);    if (U_FAILURE(status)) {        return NULL;    }    int currSymbL;    const jchar* currSymbU = ures_getStringByIndex(currencyElems.get(), 0, &currSymbL, &status);    if (U_FAILURE(status)) {        return NULL;    }    return (currSymbL == 0) ? NULL : env->NewString(currSymbU, currSymbL);}

static bool getDateTimePatterns(JNIEnv* env, jobject localeData, const char* locale_name) {  UErrorCode status = U_ZERO_ERROR;  ScopedResourceBundle root(ures_open(NULL, locale_name, &status));  if (U_FAILURE(status)) {    return false;  }  ScopedResourceBundle calendar(ures_getByKey(root.get(), "calendar", NULL, &status));  if (U_FAILURE(status)) {    return false;  }  ScopedResourceBundle gregorian(ures_getByKey(calendar.get(), "gregorian", NULL, &status));  if (U_FAILURE(status)) {    return false;  }  ScopedResourceBundle dateTimePatterns(ures_getByKey(gregorian.get(), "DateTimePatterns", NULL, &status));  if (U_FAILURE(status)) {    return false;  }  setStringField(env, localeData, "fullTimeFormat", dateTimePatterns.get(), 0);  setStringField(env, localeData, "longTimeFormat", dateTimePatterns.get(), 1);  setStringField(env, localeData, "mediumTimeFormat", dateTimePatterns.get(), 2);  setStringField(env, localeData, "shortTimeFormat", dateTimePatterns.get(), 3);  setStringField(env, localeData, "fullDateFormat", dateTimePatterns.get(), 4);  setStringField(env, localeData, "longDateFormat", dateTimePatterns.get(), 5);  setStringField(env, localeData, "mediumDateFormat", dateTimePatterns.get(), 6);  setStringField(env, localeData, "shortDateFormat", dateTimePatterns.get(), 7);  return true;}

NumberingSystem* U_EXPORT2NumberingSystem::createInstance(const Locale & inLocale, UErrorCode& status) {    if (U_FAILURE(status)) {        return NULL;    }    UBool nsResolved = TRUE;    UBool usingFallback = FALSE;    char buffer[ULOC_KEYWORDS_CAPACITY];    int32_t count = inLocale.getKeywordValue("numbers",buffer, sizeof(buffer),status);    if ( count > 0 ) { // @numbers keyword was specified in the locale        buffer[count] = '/0'; // Make sure it is null terminated.        if ( !uprv_strcmp(buffer,gDefault) || !uprv_strcmp(buffer,gNative) ||             !uprv_strcmp(buffer,gTraditional) || !uprv_strcmp(buffer,gFinance)) {            nsResolved = FALSE;        }    } else {        uprv_strcpy(buffer,gDefault);        nsResolved = FALSE;    }    if (!nsResolved) { // Resolve the numbering system ( default, native, traditional or finance ) into a "real" numbering system        UErrorCode localStatus = U_ZERO_ERROR;        UResourceBundle *resource = ures_open(NULL, inLocale.getName(), &localStatus);        UResourceBundle *numberElementsRes = ures_getByKey(resource,gNumberElements,NULL,&localStatus);        while (!nsResolved) {            localStatus = U_ZERO_ERROR;            count = 0;            const UChar *nsName = ures_getStringByKeyWithFallback(numberElementsRes, buffer, &count, &localStatus);            if ( count > 0 && count < ULOC_KEYWORDS_CAPACITY ) { // numbering system found                u_UCharsToChars(nsName,buffer,count);                buffer[count] = '/0'; // Make sure it is null terminated.                nsResolved = TRUE;            }            if (!nsResolved) { // Fallback behavior per TR35 - traditional falls back to native, finance and native fall back to default                if (!uprv_strcmp(buffer,gNative) || !uprv_strcmp(buffer,gFinance)) {                    uprv_strcpy(buffer,gDefault);                } else if (!uprv_strcmp(buffer,gTraditional)) {                    uprv_strcpy(buffer,gNative);                } else { // If we get here we couldn't find even the default numbering system                    usingFallback = TRUE;                    nsResolved = TRUE;                }            }        }        ures_close(numberElementsRes);        ures_close(resource);    }    if (usingFallback) {        status = U_USING_FALLBACK_WARNING;        NumberingSystem *ns = new NumberingSystem();        return ns;    } else {        return NumberingSystem::createInstanceByName(buffer,status);    } }

/* {{{ ResourceBundle_ctor */static int resourcebundle_ctor(INTERNAL_FUNCTION_PARAMETERS, zend_bool is_constructor){	const char *bundlename;	size_t		bundlename_len = 0;	const char *locale;	size_t		locale_len = 0;	zend_bool	fallback = 1;	int         zpp_flags = is_constructor ? ZEND_PARSE_PARAMS_THROW : 0;	zval                  *object = return_value;	ResourceBundle_object *rb = Z_INTL_RESOURCEBUNDLE_P( object );	intl_error_reset( NULL );	if( zend_parse_parameters_ex( zpp_flags, ZEND_NUM_ARGS(), "s!s!|b",		&locale, &locale_len, &bundlename, &bundlename_len, &fallback ) == FAILURE )	{		intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,			"resourcebundle_ctor: unable to parse input parameters", 0 );		return FAILURE;	}	INTL_CHECK_LOCALE_LEN_OR_FAILURE(locale_len);	if (locale == NULL) {		locale = intl_locale_get_default();	}	if (bundlename_len >= MAXPATHLEN) {		intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,	"Bundle name too long", 0 );		zval_ptr_dtor(return_value);		ZVAL_NULL(return_value);		return FAILURE;	}	if (fallback) {		rb->me = ures_open(bundlename, locale, &INTL_DATA_ERROR_CODE(rb));	} else {		rb->me = ures_openDirect(bundlename, locale, &INTL_DATA_ERROR_CODE(rb));	}	INTL_CTOR_CHECK_STATUS(rb, "resourcebundle_ctor: Cannot load libICU resource bundle");	if (!fallback && (INTL_DATA_ERROR_CODE(rb) == U_USING_FALLBACK_WARNING ||			INTL_DATA_ERROR_CODE(rb) == U_USING_DEFAULT_WARNING)) {		char *pbuf;		intl_errors_set_code(NULL, INTL_DATA_ERROR_CODE(rb));		spprintf(&pbuf, 0, "resourcebundle_ctor: Cannot load libICU resource "				"'%s' without fallback from %s to %s",				bundlename ? bundlename : "(default data)", locale,				ures_getLocaleByType(					rb->me, ULOC_ACTUAL_LOCALE, &INTL_DATA_ERROR_CODE(rb)));		intl_errors_set_custom_msg(INTL_DATA_ERROR_P(rb), pbuf, 1);		efree(pbuf);		return FAILURE;	}	return SUCCESS;}

// initCDFLocaleData initializes result with data from CLDR.// inLocale is the locale, the CLDR data is stored in result.// We load the UNUM_SHORT  and UNUM_LONG data looking first in local numbering// system and not including root locale in fallback. Next we try in the latn// numbering system where we fallback all the way to root. If we don't find// UNUM_SHORT data in these three places, we report an error. If we find// UNUM_SHORT data before finding UNUM_LONG data we make UNUM_LONG data fall// back to UNUM_SHORT data.static void initCDFLocaleData(const Locale& inLocale, CDFLocaleData* result, UErrorCode& status) {  LocalPointer<NumberingSystem> ns(NumberingSystem::createInstance(inLocale, status));  if (U_FAILURE(status)) {    return;  }  const char* numberingSystemName = ns->getName();  UResourceBundle* rb = ures_open(NULL, inLocale.getName(), &status);  rb = ures_getByKeyWithFallback(rb, gNumberElementsTag, rb, &status);  if (U_FAILURE(status)) {    ures_close(rb);    return;  }  UResourceBundle* shortDataFillIn = NULL;  UResourceBundle* longDataFillIn = NULL;  UResourceBundle* shortData = NULL;  UResourceBundle* longData = NULL;  if (uprv_strcmp(numberingSystemName, gLatnTag) != 0) {    LocalUResourceBundlePointer localResource(        tryGetByKeyWithFallback(rb, numberingSystemName, NULL, NOT_ROOT, status));    shortData = tryGetDecimalFallback(        localResource.getAlias(), gPatternsShort, &shortDataFillIn, NOT_ROOT, status);    longData = tryGetDecimalFallback(        localResource.getAlias(), gPatternsLong, &longDataFillIn, NOT_ROOT, status);  }  if (U_FAILURE(status)) {    ures_close(shortDataFillIn);    ures_close(longDataFillIn);    ures_close(rb);    return;  }  // If we haven't found UNUM_SHORT look in latn numbering system. We must  // succeed at finding UNUM_SHORT here.  if (shortData == NULL) {    LocalUResourceBundlePointer latnResource(tryGetByKeyWithFallback(rb, gLatnTag, NULL, MUST, status));    shortData = tryGetDecimalFallback(latnResource.getAlias(), gPatternsShort, &shortDataFillIn, MUST, status);    if (longData == NULL) {      longData = tryGetDecimalFallback(latnResource.getAlias(), gPatternsLong, &longDataFillIn, ANY, status);      if (longData != NULL && isRoot(longData, status) && !isRoot(shortData, status)) {        longData = NULL;      }    }  }  initCDFLocaleStyleData(shortData, &result->shortData, status);  ures_close(shortDataFillIn);  if (U_FAILURE(status)) {    ures_close(longDataFillIn);    ures_close(rb);  }  if (longData == NULL) {    result->longData.setToBogus();  } else {    initCDFLocaleStyleData(longData, &result->longData, status);  }  ures_close(longDataFillIn);  ures_close(rb);}

RuleBasedNumberFormat::RuleBasedNumberFormat(URBNFRuleSetTag tag, const Locale& alocale, UErrorCode& status)  : ruleSets(NULL)  , ruleSetDescriptions(NULL)  , numRuleSets(0)  , defaultRuleSet(NULL)  , locale(alocale)  , collator(NULL)  , decimalFormatSymbols(NULL)  , lenient(FALSE)  , lenientParseRules(NULL)  , localizations(NULL){    if (U_FAILURE(status)) {        return;    }    const char* rules_tag = "RBNFRules";    const char* fmt_tag = "";    switch (tag) {    case URBNF_SPELLOUT: fmt_tag = "SpelloutRules"; break;    case URBNF_ORDINAL: fmt_tag = "OrdinalRules"; break;    case URBNF_DURATION: fmt_tag = "DurationRules"; break;    case URBNF_NUMBERING_SYSTEM: fmt_tag = "NumberingSystemRules"; break;    default: status = U_ILLEGAL_ARGUMENT_ERROR; return;    }    // TODO: read localization info from resource    LocalizationInfo* locinfo = NULL;    UResourceBundle* nfrb = ures_open(U_ICUDATA_RBNF, locale.getName(), &status);    if (U_SUCCESS(status)) {        setLocaleIDs(ures_getLocaleByType(nfrb, ULOC_VALID_LOCALE, &status),                     ures_getLocaleByType(nfrb, ULOC_ACTUAL_LOCALE, &status));        UResourceBundle* rbnfRules = ures_getByKeyWithFallback(nfrb, rules_tag, NULL, &status);        if (U_FAILURE(status)) {            ures_close(nfrb);        }        UResourceBundle* ruleSets = ures_getByKeyWithFallback(rbnfRules, fmt_tag, NULL, &status);        if (U_FAILURE(status)) {            ures_close(rbnfRules);            ures_close(nfrb);            return;        }        UnicodeString desc;        while (ures_hasNext(ruleSets)) {           desc.append(ures_getNextUnicodeString(ruleSets,NULL,&status));        }        UParseError perror;        init (desc, locinfo, perror, status);        ures_close(ruleSets);        ures_close(rbnfRules);    }    ures_close(nfrb);}

static void load(const Locale& inLocale, CDFLocaleData* result, UErrorCode& status) {  LocalPointer<NumberingSystem> ns(NumberingSystem::createInstance(inLocale, status));  if (U_FAILURE(status)) {    return;  }  const char* nsName = ns->getName();  LocalUResourceBundlePointer resource(ures_open(NULL, inLocale.getName(), &status));  if (U_FAILURE(status)) {    return;  }  CmptDecDataSink sink(*result);  sink.isFallback = FALSE;  // First load the number elements data if nsName is not Latin.  if (uprv_strcmp(nsName, gLatnTag) != 0) {    sink.isLatin = FALSE;    CharString path;    path.append(gNumberElementsTag, status)        .append('/', status)        .append(nsName, status);    ures_getAllItemsWithFallback(resource.getAlias(), path.data(), sink, status);    if (status == U_MISSING_RESOURCE_ERROR) {      // Silently ignore and use Latin      status = U_ZERO_ERROR;    } else if  (U_FAILURE(status)) {      return;    }    sink.isFallback = TRUE;  }  // Now load Latin.  sink.isLatin = TRUE;  ures_getAllItemsWithFallback(resource.getAlias(), gLatnPath, sink, status);  if (U_FAILURE(status)) return;  // If longData is empty, default it to be equal to shortData  if (result->longData.isEmpty()) {    result->longData.setToBogus();  }  // Check for "other" variants in each of the three data classes, and resolve missing elements.  if (!result->longData.isBogus()) {    checkForOtherVariants(&result->longData, status);    if (U_FAILURE(status)) return;    fillInMissing(&result->longData);  }  checkForOtherVariants(&result->shortData, status);  if (U_FAILURE(status)) return;  fillInMissing(&result->shortData);  // TODO: Enable this statement when currency support is added  // checkForOtherVariants(&result->shortCurrencyData, status);  // if (U_FAILURE(status)) return;  // fillInMissing(&result->shortCurrencyData);}

U_CAPI void U_EXPORT2ucol_prepareShortStringOpen( const char *definition,                          UBool,                          UParseError *parseError,                          UErrorCode *status){    if(U_FAILURE(*status)) return;    UParseError internalParseError;    if(!parseError) {        parseError = &internalParseError;    }    parseError->line = 0;    parseError->offset = 0;    parseError->preContext[0] = 0;    parseError->postContext[0] = 0;    // first we want to pick stuff out of short string.    // we'll end up with an UCA version, locale and a bunch of    // settings    // analyse the string in order to get everything we need.    CollatorSpec s;    ucol_sit_initCollatorSpecs(&s);    ucol_sit_readSpecs(&s, definition, parseError, status);    ucol_sit_calculateWholeLocale(&s);    char buffer[internalBufferSize];    uprv_memset(buffer, 0, internalBufferSize);    uloc_canonicalize(s.locale, buffer, internalBufferSize, status);    UResourceBundle *b = ures_open(U_ICUDATA_COLL, buffer, status);    /* we try to find stuff from keyword */    UResourceBundle *collations = ures_getByKey(b, "collations", NULL, status);    UResourceBundle *collElem = NULL;    char keyBuffer[256];    // if there is a keyword, we pick it up and try to get elements    if(!uloc_getKeywordValue(buffer, "collation", keyBuffer, 256, status)) {      // no keyword. we try to find the default setting, which will give us the keyword value      UResourceBundle *defaultColl = ures_getByKeyWithFallback(collations, "default", NULL, status);      if(U_SUCCESS(*status)) {        int32_t defaultKeyLen = 0;        const UChar *defaultKey = ures_getString(defaultColl, &defaultKeyLen, status);        u_UCharsToChars(defaultKey, keyBuffer, defaultKeyLen);        keyBuffer[defaultKeyLen] = 0;      } else {        *status = U_INTERNAL_PROGRAM_ERROR;        return;      }      ures_close(defaultColl);    }    collElem = ures_getByKeyWithFallback(collations, keyBuffer, collElem, status);    ures_close(collElem);    ures_close(collations);    ures_close(b);}

LocaleAliasTest::LocaleAliasTest(){    UErrorCode status = U_ZERO_ERROR;    resIndex = ures_open(NULL,"res_index", &status);    if(U_FAILURE(status)){        errln("Could not open res_index.res. Exiting. Error: %s/n", u_errorName(status));        resIndex=NULL;    }    defLocale = Locale::getDefault();    Locale::setDefault(Locale::getUS(), status); }

void TestAliasConflict(void) {    UErrorCode status = U_ZERO_ERROR;    UResourceBundle *he = NULL;    UResourceBundle *iw = NULL;    const UChar *result = NULL;    int32_t resultLen;    he = ures_open(NULL, "he", &status);    iw = ures_open(NULL, "iw", &status);    if(U_FAILURE(status)) {        log_err_status(status, "Failed to get resource with %s/n", myErrorName(status));    }    ures_close(iw);    result = ures_getStringByKey(he, "ExemplarCharacters", &resultLen, &status);    if(U_FAILURE(status) || result == NULL) {        log_err_status(status, "Failed to get resource with %s/n", myErrorName(status));    }    ures_close(he);}

DictionaryMatcher *ICULanguageBreakFactory::loadDictionaryMatcherFor(UScriptCode script, int32_t /* brkType */) {    UErrorCode status = U_ZERO_ERROR;    // open root from brkitr tree.    UResourceBundle *b = ures_open(U_ICUDATA_BRKITR, "", &status);    b = ures_getByKeyWithFallback(b, "dictionaries", b, &status);    int32_t dictnlength = 0;    const UChar *dictfname =        ures_getStringByKeyWithFallback(b, uscript_getShortName(script), &dictnlength, &status);    if (U_FAILURE(status)) {        ures_close(b);        return NULL;    }    CharString dictnbuf;    CharString ext;    const UChar *extStart = u_memrchr(dictfname, 0x002e, dictnlength);  // last dot    if (extStart != NULL) {        int32_t len = (int32_t)(extStart - dictfname);        ext.appendInvariantChars(UnicodeString(FALSE, extStart + 1, dictnlength - len - 1), status);        dictnlength = len;    }    dictnbuf.appendInvariantChars(UnicodeString(FALSE, dictfname, dictnlength), status);    ures_close(b);    UDataMemory *file = udata_open(U_ICUDATA_BRKITR, ext.data(), dictnbuf.data(), &status);    if (U_SUCCESS(status)) {        // build trie        const uint8_t *data = (const uint8_t *)udata_getMemory(file);        const int32_t *indexes = (const int32_t *)data;        const int32_t offset = indexes[DictionaryData::IX_STRING_TRIE_OFFSET];        const int32_t trieType = indexes[DictionaryData::IX_TRIE_TYPE] & DictionaryData::TRIE_TYPE_MASK;        DictionaryMatcher *m = NULL;        if (trieType == DictionaryData::TRIE_TYPE_BYTES) {            const int32_t transform = indexes[DictionaryData::IX_TRANSFORM];            const char *characters = (const char *)(data + offset);            m = new BytesDictionaryMatcher(characters, transform, file);        }        else if (trieType == DictionaryData::TRIE_TYPE_UCHARS) {            const UChar *characters = (const UChar *)(data + offset);            m = new UCharsDictionaryMatcher(characters, file);        }        if (m == NULL) {            // no matcher exists to take ownership - either we are an invalid            // type or memory allocation failed            udata_close(file);        }        return m;    } else if (dictfname != NULL) {        // we don't have a dictionary matcher.        // returning NULL here will cause us to fail to find a dictionary break engine, as expected        status = U_ZERO_ERROR;        return NULL;    }    return NULL;}

static int32_t_getStringOrCopyKey(const char *path, const char *locale,                    const char *tableKey,                     const char* subTableKey,                    const char *itemKey,                    const char *substitute,                    UChar *dest, int32_t destCapacity,                    UErrorCode *pErrorCode) {    const UChar *s = NULL;    int32_t length = 0;    if(itemKey==NULL) {        /* top-level item: normal resource bundle access */        UResourceBundle *rb;        rb=ures_open(path, locale, pErrorCode);        if(U_SUCCESS(*pErrorCode)) {            s=ures_getStringByKey(rb, tableKey, &length, pErrorCode);            /* see comment about closing rb near "return item;" in _res_getTableStringWithFallback() */            ures_close(rb);        }    } else {        /* Language code should not be a number. If it is, set the error code. */        if (!uprv_strncmp(tableKey, "Languages", 9) && uprv_strtol(itemKey, NULL, 10)) {            *pErrorCode = U_MISSING_RESOURCE_ERROR;        } else {            /* second-level item, use special fallback */            s=uloc_getTableStringWithFallback(path, locale,                                               tableKey,                                                subTableKey,                                               itemKey,                                               &length,                                               pErrorCode);        }    }    if(U_SUCCESS(*pErrorCode)) {        int32_t copyLength=uprv_min(length, destCapacity);        if(copyLength>0 && s != NULL) {            u_memcpy(dest, s, copyLength);        }    } else {        /* no string from a resource bundle: convert the substitute */        length=(int32_t)uprv_strlen(substitute);        u_charsToUChars(substitute, dest, uprv_min(length, destCapacity));        *pErrorCode=U_USING_DEFAULT_WARNING;    }    return u_terminateUChars(dest, destCapacity, length, pErrorCode);}

U_CAPI UResourceBundle * U_EXPORT2ures_openU(const UChar *myPath,            const char *localeID,            UErrorCode *status){    char pathBuffer[1024];    int32_t length;    char *path = pathBuffer;    if(status==NULL || U_FAILURE(*status)) {        return NULL;    }    if(myPath==NULL) {        path = NULL;    }    else {        length=u_strlen(myPath);        if(length>=sizeof(pathBuffer)) {            *status=U_ILLEGAL_ARGUMENT_ERROR;            return NULL;        } else if(uprv_isInvariantUString(myPath, length)) {            /*             * the invariant converter is sufficient for package and tree names             * and is more efficient             */            u_UCharsToChars(myPath, path, length+1); /* length+1 to include the NUL */        } else {#if !UCONFIG_NO_CONVERSION            /* use the default converter to support variant-character paths */            UConverter *cnv=u_getDefaultConverter(status);            length=ucnv_fromUChars(cnv, path, (int32_t)sizeof(pathBuffer), myPath, length, status);            u_releaseDefaultConverter(cnv);            if(U_FAILURE(*status)) {                return NULL;            }            if(length>=sizeof(pathBuffer)) {                /* not NUL-terminated - path too long */                *status=U_ILLEGAL_ARGUMENT_ERROR;                return NULL;            }#else            /* the default converter is not available */            *status=U_UNSUPPORTED_ERROR;            return NULL;#endif        }    }    return ures_open(path, localeID, status);}

static void TestFallback(){    UErrorCode status = U_ZERO_ERROR;    UResourceBundle *fr_FR = NULL;    UResourceBundle *subResource = NULL;    const UChar *junk; /* ignored */    int32_t resultLen;    log_verbose("Opening fr_FR..");    fr_FR = ures_open(NULL, "fr_FR", &status);    if(U_FAILURE(status))    {        log_err_status(status, "Couldn't open fr_FR - %s/n", u_errorName(status));        return;    }    status = U_ZERO_ERROR;    /* clear it out..  just do some calls to get the gears turning */    junk = ures_getStringByKey(fr_FR, "LocaleID", &resultLen, &status);    (void)junk;    /* Suppress set but not used warning. */    status = U_ZERO_ERROR;    junk = ures_getStringByKey(fr_FR, "LocaleString", &resultLen, &status);    status = U_ZERO_ERROR;    junk = ures_getStringByKey(fr_FR, "LocaleID", &resultLen, &status);    status = U_ZERO_ERROR;    /* OK first one. This should be a Default value. */    subResource = ures_getByKey(fr_FR, "layout", NULL, &status);    if(status != U_USING_DEFAULT_WARNING)    {        log_data_err("Expected U_USING_DEFAULT_ERROR when trying to get layout from fr_FR, got %s/n",            u_errorName(status));    }    ures_close(subResource);    status = U_ZERO_ERROR;    /* and this is a Fallback, to fr */    junk = ures_getStringByKey(fr_FR, "ExemplarCharacters", &resultLen, &status);    if(status != U_USING_FALLBACK_WARNING)    {        log_data_err("Expected U_USING_FALLBACK_ERROR when trying to get ExemplarCharacters from fr_FR, got %s/n",             u_errorName(status));    }    status = U_ZERO_ERROR;    ures_close(fr_FR);}

template<> U_I18N_APIconst MeasureFormatCacheData *LocaleCacheKey<MeasureFormatCacheData>::createObject(        const void * /*unused*/, UErrorCode &status) const {    const char *localeId = fLoc.getName();    LocalUResourceBundlePointer unitsBundle(ures_open(U_ICUDATA_UNIT, localeId, &status));    static UNumberFormatStyle currencyStyles[] = {            UNUM_CURRENCY_PLURAL, UNUM_CURRENCY_ISO, UNUM_CURRENCY};    LocalPointer<MeasureFormatCacheData> result(new MeasureFormatCacheData(), status);    if (U_FAILURE(status)) {        return NULL;    }    if (!loadMeasureUnitData(            unitsBundle.getAlias(),            *result,            status)) {        return NULL;    }    result->adoptNumericDateFormatters(loadNumericDateFormatters(            unitsBundle.getAlias(), status));    if (U_FAILURE(status)) {        return NULL;    }    for (int32_t i = 0; i < WIDTH_INDEX_COUNT; ++i) {        // NumberFormat::createInstance can erase warning codes from status, so pass it        // a separate status instance        UErrorCode localStatus = U_ZERO_ERROR;        result->adoptCurrencyFormat(i, NumberFormat::createInstance(                localeId, currencyStyles[i], localStatus));        if (localStatus != U_ZERO_ERROR) {            status = localStatus;        }        if (U_FAILURE(status)) {            return NULL;        }    }    NumberFormat *inf = NumberFormat::createInstance(            localeId, UNUM_DECIMAL, status);    if (U_FAILURE(status)) {        return NULL;    }    inf->setMaximumFractionDigits(0);    DecimalFormat *decfmt = dynamic_cast<DecimalFormat *>(inf);    if (decfmt != NULL) {        decfmt->setRoundingMode(DecimalFormat::kRoundDown);    }    result->adoptIntegerFormat(inf);    result->addRef();    return result.orphan();}

voidCalendar::setWeekCountData(const Locale& desiredLocale, UErrorCode& status){    // Read the week count data from the resource bundle.  This should    // have the form:    //    //   DateTimeElements:intvector {    //      1,    // first day of week    //      1     // min days in week    //   }    //   Both have a range of 1..7    if (U_FAILURE(status)) return;    fFirstDayOfWeek = UCAL_SUNDAY;    fMinimalDaysInFirstWeek = 1;    UResourceBundle *resource = ures_open(NULL, desiredLocale.getName(), &status);    // If the resource data doesn't seem to be present at all, then use last-resort    // hard-coded data.    if (U_FAILURE(status))    {        status = U_USING_FALLBACK_WARNING;        ures_close(resource);        return;    }    //dateTimeElements = resource.getStringArray(kDateTimeElements, count, status);    UResourceBundle *dateTimeElements = ures_getByKey(resource, kDateTimeElements, NULL, &status);    if (U_SUCCESS(status)) {        int32_t arrLen;        const int32_t *dateTimeElementsArr = ures_getIntVector(dateTimeElements, &arrLen, &status);        if(U_SUCCESS(status) && arrLen == 2            && 1 <= dateTimeElementsArr[0] && dateTimeElementsArr[0] <= 7            && 1 <= dateTimeElementsArr[1] && dateTimeElementsArr[1] <= 7)        {            fFirstDayOfWeek = (UCalendarDaysOfWeek)dateTimeElementsArr[0];            fMinimalDaysInFirstWeek = (uint8_t)dateTimeElementsArr[1];        }        else {            status = U_INVALID_FORMAT_ERROR;        }    }    ures_close(dateTimeElements);    ures_close(resource);}

void ResourceBundle::constructForLocale(const UnicodeString& path,                                   const Locale& locale,                                   UErrorCode& error){    if (path.isEmpty()) {        fResource = ures_open(NULL, locale.getName(), &error);    }    else {        UnicodeString nullTerminatedPath(path);        nullTerminatedPath.append((UChar)0);        fResource = ures_openU(nullTerminatedPath.getBuffer(), locale.getName(), &error);    }}