static UResourceBundle* openOlsonResource(const UnicodeString& id,
UResourceBundle& res,
UErrorCode& ec)
{
#if U_DEBUG_TZ
char buf[128];
id.extract(0, sizeof(buf)-1, buf, sizeof(buf), "");
#endif
UResourceBundle *top = ures_openDirect(0, kZONEINFO, &ec);
U_DEBUG_TZ_MSG(("pre: res sz=%d\n", ures_getSize(&res)));
/* &res = */ getZoneByName(top, id, &res, ec);
// Dereference if this is an alias. Docs say result should be 1
// but it is 0 in 2.8 (?).
U_DEBUG_TZ_MSG(("Loading zone '%s' (%s, size %d) - %s\n", buf, ures_getKey((UResourceBundle*)&res), ures_getSize(&res), u_errorName(ec)));
if (ures_getSize(&res) <= 1 && getOlsonMeta(top)) {
int32_t deref = ures_getInt(&res, &ec) + 0;
U_DEBUG_TZ_MSG(("getInt: %s - type is %d\n", u_errorName(ec), ures_getType(&res)));
UResourceBundle *ares = ures_getByKey(top, kZONES, NULL, &ec); // dereference Zones section
ures_getByIndex(ares, deref, &res, &ec);
ures_close(ares);
U_DEBUG_TZ_MSG(("alias to #%d (%s) - %s\n", deref, "??", u_errorName(ec)));
} else {
U_DEBUG_TZ_MSG(("not an alias - size %d\n", ures_getSize(&res)));
}
U_DEBUG_TZ_MSG(("%s - final status is %s\n", buf, u_errorName(ec)));
return top;
}
const UChar*
TimeZone::dereferOlsonLink(const UnicodeString& id) {
const UChar *result = NULL;
UErrorCode ec = U_ZERO_ERROR;
UResourceBundle *rb = ures_openDirect(NULL, kZONEINFO, &ec);
// resolve zone index by name
UResourceBundle *names = ures_getByKey(rb, kNAMES, NULL, &ec);
int32_t idx = findInStringArray(names, id, ec);
result = ures_getStringByIndex(names, idx, NULL, &ec);
// open the zone bundle by index
ures_getByKey(rb, kZONES, rb, &ec);
ures_getByIndex(rb, idx, rb, &ec);
if (U_SUCCESS(ec)) {
if (ures_getType(rb) == URES_INT) {
// this is a link - dereference the link
int32_t deref = ures_getInt(rb, &ec);
const UChar* tmp = ures_getStringByIndex(names, deref, NULL, &ec);
if (U_SUCCESS(ec)) {
result = tmp;
}
}
}
ures_close(names);
ures_close(rb);
return result;
}
TestData* RBTestDataModule::createTestData(int32_t index, UErrorCode &status) const
{
TestData *result = NULL;
UErrorCode intStatus = U_ZERO_ERROR;
if(fDataTestValid == TRUE) {
// Both of these resources get adopted by a TestData object.
UResourceBundle *DataFillIn = ures_getByIndex(fTestData, index, NULL, &status);
UResourceBundle *headers = ures_getByKey(fInfoRB, "Headers", NULL, &intStatus);
if(U_SUCCESS(status)) {
result = new RBTestData(DataFillIn, headers, status);
if(U_SUCCESS(status)) {
return result;
} else {
delete result;
}
} else {
ures_close(DataFillIn);
ures_close(headers);
}
} else {
status = U_MISSING_RESOURCE_ERROR;
}
return NULL;
}
int32_t U_EXPORT2
TimeZone::countEquivalentIDs(const UnicodeString& id) {
int32_t result = 0;
UErrorCode ec = U_ZERO_ERROR;
UResourceBundle res;
ures_initStackObject(&res);
U_DEBUG_TZ_MSG(("countEquivalentIDs..\n"));
UResourceBundle *top = openOlsonResource(id, res, ec);
if (U_SUCCESS(ec)) {
int32_t size = ures_getSize(&res);
U_DEBUG_TZ_MSG(("cEI: success (size %d, key %s)..\n", size, ures_getKey(&res)));
if (size == 4 || size == 6) {
UResourceBundle r;
ures_initStackObject(&r);
ures_getByIndex(&res, size-1, &r, &ec);
//result = ures_getSize(&r); // doesn't work
ures_getIntVector(&r, &result, &ec);
U_DEBUG_TZ_MSG(("ceI: result %d, err %s\n", result, u_errorName(ec)));
ures_close(&r);
}
} else {
U_DEBUG_TZ_MSG(("cEI: fail, %s\n", u_errorName(ec)));
}
ures_close(&res);
ures_close(top);
return result;
}
static UResourceBundle* getZoneByName(const UResourceBundle* top, const UnicodeString& id, UResourceBundle *oldbundle, UErrorCode& status) {
// load the Rules object
UResourceBundle *tmp = ures_getByKey(top, kNAMES, NULL, &status);
// search for the string
int32_t idx = findInStringArray(tmp, id, status);
if((idx == -1) && U_SUCCESS(status)) {
// not found
status = U_MISSING_RESOURCE_ERROR;
//ures_close(oldbundle);
//oldbundle = NULL;
} else {
U_DEBUG_TZ_MSG(("gzbn: oldbundle= size %d, type %d, %s\n", ures_getSize(tmp), ures_getType(tmp), u_errorName(status)));
tmp = ures_getByKey(top, kZONES, tmp, &status); // get Zones object from top
U_DEBUG_TZ_MSG(("gzbn: loaded ZONES, size %d, type %d, path %s %s\n", ures_getSize(tmp), ures_getType(tmp), ures_getPath(tmp), u_errorName(status)));
oldbundle = ures_getByIndex(tmp, idx, oldbundle, &status); // get nth Zone object
U_DEBUG_TZ_MSG(("gzbn: loaded z#%d, size %d, type %d, path %s, %s\n", idx, ures_getSize(oldbundle), ures_getType(oldbundle), ures_getPath(oldbundle), u_errorName(status)));
}
ures_close(tmp);
if(U_FAILURE(status)) {
//ures_close(oldbundle);
return NULL;
} else {
return oldbundle;
}
}
void RBDataMap::init(UResourceBundle *data, UErrorCode &status) {
int32_t i = 0;
fData->removeAll();
UResourceBundle *t = NULL;
for(i = 0; i < ures_getSize(data); i++) {
t = ures_getByIndex(data, i, t, &status);
fData->put(UnicodeString(ures_getKey(t), -1, US_INV), new ResourceBundle(t, status), status);
}
ures_close(t);
}
ResourceBundle ResourceBundle::get(int32_t indexR, UErrorCode& status) const {
UResourceBundle r;
ures_initStackObject(&r);
ures_getByIndex(fResource, indexR, &r, &status);
ResourceBundle res(&r, status);
if (U_SUCCESS(status)) {
ures_close(&r);
}
return res;
}
/* {{{ resourcebundle_array_fetch */
static void resourcebundle_array_fetch(zval *object, zval *offset, zval *return_value, int fallback)
{
int32_t meindex = 0;
char * mekey = NULL;
zend_bool is_numeric = 0;
char *pbuf;
ResourceBundle_object *rb;
intl_error_reset( NULL );
RESOURCEBUNDLE_METHOD_FETCH_OBJECT;
if(Z_TYPE_P(offset) == IS_LONG) {
is_numeric = 1;
meindex = (int32_t)Z_LVAL_P(offset);
rb->child = ures_getByIndex( rb->me, meindex, rb->child, &INTL_DATA_ERROR_CODE(rb) );
} else if(Z_TYPE_P(offset) == IS_STRING) {
mekey = Z_STRVAL_P(offset);
rb->child = ures_getByKey(rb->me, mekey, rb->child, &INTL_DATA_ERROR_CODE(rb) );
} else {
intl_errors_set(INTL_DATA_ERROR_P(rb), U_ILLEGAL_ARGUMENT_ERROR,
"resourcebundle_get: index should be integer or string", 0);
RETURN_NULL();
}
intl_error_set_code( NULL, INTL_DATA_ERROR_CODE(rb) );
if (U_FAILURE(INTL_DATA_ERROR_CODE(rb))) {
if (is_numeric) {
spprintf( &pbuf, 0, "Cannot load resource element %d", meindex );
} else {
spprintf( &pbuf, 0, "Cannot load resource element '%s'", mekey );
}
intl_errors_set_custom_msg( INTL_DATA_ERROR_P(rb), pbuf, 1 );
efree(pbuf);
RETURN_NULL();
}
if (!fallback && (INTL_DATA_ERROR_CODE(rb) == U_USING_FALLBACK_WARNING || INTL_DATA_ERROR_CODE(rb) == U_USING_DEFAULT_WARNING)) {
UErrorCode icuerror;
const char * locale = ures_getLocaleByType( rb->me, ULOC_ACTUAL_LOCALE, &icuerror );
if (is_numeric) {
spprintf( &pbuf, 0, "Cannot load element %d without fallback from to %s", meindex, locale );
} else {
spprintf( &pbuf, 0, "Cannot load element '%s' without fallback from to %s", mekey, locale );
}
intl_errors_set_custom_msg( INTL_DATA_ERROR_P(rb), pbuf, 1 );
efree(pbuf);
RETURN_NULL();
}
resourcebundle_extract_value( return_value, rb );
}
static jstring getCurrencyCodeNative(JNIEnv* env, jclass clazz, jstring key) {
UErrorCode status = U_ZERO_ERROR;
ScopedResourceBundle supplData(ures_openDirect(NULL, "supplementalData", &status));
if (U_FAILURE(status)) {
return NULL;
}
ScopedResourceBundle currencyMap(ures_getByKey(supplData.get(), "CurrencyMap", NULL, &status));
if (U_FAILURE(status)) {
return NULL;
}
const char* keyChars = env->GetStringUTFChars(key, NULL);
ScopedResourceBundle currency(ures_getByKey(currencyMap.get(), keyChars, NULL, &status));
env->ReleaseStringUTFChars(key, keyChars);
if (U_FAILURE(status)) {
return NULL;
}
ScopedResourceBundle currencyElem(ures_getByIndex(currency.get(), 0, NULL, &status));
if (U_FAILURE(status)) {
return env->NewStringUTF("None");
}
// check if there is a 'to' date. If there is, the currency isn't used anymore.
ScopedResourceBundle currencyTo(ures_getByKey(currencyElem.get(), "to", NULL, &status));
if (!U_FAILURE(status)) {
// return and let the caller throw an exception
return NULL;
}
// We need to reset 'status'. It works like errno in that ICU doesn't set it
// to U_ZERO_ERROR on success: it only touches it on error, and the test
// above means it now holds a failure code.
status = U_ZERO_ERROR;
ScopedResourceBundle currencyId(ures_getByKey(currencyElem.get(), "id", NULL, &status));
if (U_FAILURE(status)) {
// No id defined for this country
return env->NewStringUTF("None");
}
int length;
const jchar* id = ures_getString(currencyId.get(), &length, &status);
if (U_FAILURE(status) || length == 0) {
return env->NewStringUTF("None");
}
return env->NewString(id, length);
}
UBool RBTestData::nextCase(const DataMap *& nextCase, UErrorCode &status)
{
UErrorCode intStatus = U_ZERO_ERROR;
UResourceBundle *currCase = ures_getByIndex(fCases, fCurrentCase++, NULL, &intStatus);
if(U_SUCCESS(intStatus)) {
if(fCurrCase == NULL) {
fCurrCase = new RBDataMap(fHeaders, currCase, status);
} else {
((RBDataMap *)fCurrCase)->init(fHeaders, currCase, status);
}
ures_close(currCase);
nextCase = fCurrCase;
return TRUE;
} else {
nextCase = NULL;
return FALSE;
}
}
/* {{{ resourcebundle_iterator_read */
static void resourcebundle_iterator_read( ResourceBundle_iterator *iterator )
{
UErrorCode icuerror = U_ZERO_ERROR;
ResourceBundle_object *rb = iterator->subject;
rb->child = ures_getByIndex( rb->me, iterator->i, rb->child, &icuerror );
if (U_SUCCESS(icuerror)) {
/* ATTN: key extraction must be the first thing to do... rb->child might be reset in read! */
if (iterator->is_table) {
iterator->currentkey = estrdup( ures_getKey( rb->child ) );
}
resourcebundle_extract_value( &iterator->current, rb );
}
else {
// zend_throw_exception( spl_ce_OutOfRangeException, "Running past end of ResourceBundle", 0);
ZVAL_UNDEF(&iterator->current);
}
}
void RBDataMap::init(UResourceBundle *headers, UResourceBundle *data, UErrorCode &status)
{
int32_t i = 0;
fData->removeAll();
UResourceBundle *t = NULL;
const UChar *key = NULL;
int32_t keyLen = 0;
if(ures_getSize(headers) == ures_getSize(data)) {
for(i = 0; i < ures_getSize(data); i++) {
t = ures_getByIndex(data, i, t, &status);
key = ures_getStringByIndex(headers, i, &keyLen, &status);
fData->put(UnicodeString(key, keyLen), new ResourceBundle(t, status), status);
}
} else {
// error
status = U_INVALID_FORMAT_ERROR;
}
ures_close(t);
}
UBool RBTestData::nextSettings(const DataMap *& settings, UErrorCode &status)
{
UErrorCode intStatus = U_ZERO_ERROR;
UResourceBundle *data = ures_getByIndex(fSettings, fCurrentSettings++, NULL, &intStatus);
if(U_SUCCESS(intStatus)) {
// reset the cases iterator
fCurrentCase = 0;
if(fCurrSettings == NULL) {
fCurrSettings = new RBDataMap(data, status);
} else {
((RBDataMap *)fCurrSettings)->init(data, status);
}
ures_close(data);
settings = fCurrSettings;
return TRUE;
} else {
settings = NULL;
return FALSE;
}
}
// TODO: rewrite this with int32_t ucurr_forLocale(const char* locale, UChar* buff, int32_t buffCapacity, UErrorCode* ec)...
static jstring ICU_getCurrencyCode(JNIEnv* env, jclass, jstring javaCountryCode) {
UErrorCode status = U_ZERO_ERROR;
ScopedResourceBundle supplData(ures_openDirect(U_ICUDATA_CURR, "supplementalData", &status));
if (U_FAILURE(status)) {
return NULL;
}
ScopedResourceBundle currencyMap(ures_getByKey(supplData.get(), "CurrencyMap", NULL, &status));
if (U_FAILURE(status)) {
return NULL;
}
ScopedUtfChars countryCode(env, javaCountryCode);
ScopedResourceBundle currency(ures_getByKey(currencyMap.get(), countryCode.c_str(), NULL, &status));
if (U_FAILURE(status)) {
return NULL;
}
ScopedResourceBundle currencyElem(ures_getByIndex(currency.get(), 0, NULL, &status));
if (U_FAILURE(status)) {
return env->NewStringUTF("XXX");
}
// Check if there's a 'to' date. If there is, the currency isn't used anymore.
ScopedResourceBundle currencyTo(ures_getByKey(currencyElem.get(), "to", NULL, &status));
if (!U_FAILURE(status)) {
return NULL;
}
// Ignore the failure to find a 'to' date.
status = U_ZERO_ERROR;
ScopedResourceBundle currencyId(ures_getByKey(currencyElem.get(), "id", NULL, &status));
if (U_FAILURE(status)) {
// No id defined for this country
return env->NewStringUTF("XXX");
}
int32_t charCount;
const jchar* chars = ures_getString(currencyId.get(), &charCount, &status);
return (charCount == 0) ? env->NewStringUTF("XXX") : env->NewString(chars, charCount);
}
const UnicodeString U_EXPORT2
TimeZone::getEquivalentID(const UnicodeString& id, int32_t index) {
U_DEBUG_TZ_MSG(("gEI(%d)\n", index));
UnicodeString result;
UErrorCode ec = U_ZERO_ERROR;
UResourceBundle res;
ures_initStackObject(&res);
UResourceBundle *top = openOlsonResource(id, res, ec);
int32_t zone = -1;
if (U_SUCCESS(ec)) {
int32_t size = ures_getSize(&res);
if (size == 4 || size == 6) {
UResourceBundle r;
ures_initStackObject(&r);
ures_getByIndex(&res, size-1, &r, &ec);
const int32_t* v = ures_getIntVector(&r, &size, &ec);
if (index >= 0 && index < size && getOlsonMeta()) {
zone = v[index];
}
ures_close(&r);
}
}
ures_close(&res);
if (zone >= 0) {
UResourceBundle *ares = ures_getByKey(top, kNAMES, NULL, &ec); // dereference Zones section
if (U_SUCCESS(ec)) {
int32_t idLen = 0;
const UChar* id = ures_getStringByIndex(ares, zone, &idLen, &ec);
result.fastCopyFrom(UnicodeString(TRUE, id, idLen));
U_DEBUG_TZ_MSG(("gei(%d) -> %d, len%d, %s\n", index, zone, result.length(), u_errorName(ec)));
}
ures_close(ares);
}
ures_close(top);
#if defined(U_DEBUG_TZ)
if(result.length() ==0) {
U_DEBUG_TZ_MSG(("equiv [__, #%d] -> 0 (%s)\n", index, u_errorName(ec)));
}
#endif
return result;
}
// initCDFLocaleStyleData loads formatting data for a particular style.
// decimalFormatBundle is the "decimalFormat" resource bundle in CLDR.
// Loaded data stored in result.
static void initCDFLocaleStyleData(const UResourceBundle* decimalFormatBundle, CDFLocaleStyleData* result, UErrorCode& status) {
if (U_FAILURE(status)) {
return;
}
// Iterate through all the powers of 10.
int32_t size = ures_getSize(decimalFormatBundle);
UResourceBundle* power10 = NULL;
for (int32_t i = 0; i < size; ++i) {
power10 = ures_getByIndex(decimalFormatBundle, i, power10, &status);
if (U_FAILURE(status)) {
ures_close(power10);
return;
}
populatePower10(power10, result, status);
if (U_FAILURE(status)) {
ures_close(power10);
return;
}
}
ures_close(power10);
fillInMissing(result);
}
static jstring getCurrencyCodeNative(JNIEnv* env, jclass clazz,
jstring key) {
// LOGI("ENTER getCurrencyCodeNative");
UErrorCode status = U_ZERO_ERROR;
UResourceBundle *supplData = ures_openDirect(NULL, "supplementalData", &status);
if(U_FAILURE(status)) {
return NULL;
}
UResourceBundle *currencyMap = ures_getByKey(supplData, "CurrencyMap", NULL, &status);
if(U_FAILURE(status)) {
ures_close(supplData);
return NULL;
}
const char *keyChars = env->GetStringUTFChars(key, NULL);
UResourceBundle *currency = ures_getByKey(currencyMap, keyChars, NULL, &status);
env->ReleaseStringUTFChars(key, keyChars);
if(U_FAILURE(status)) {
ures_close(currencyMap);
ures_close(supplData);
return NULL;
}
UResourceBundle *currencyElem = ures_getByIndex(currency, 0, NULL, &status);
if(U_FAILURE(status)) {
ures_close(currency);
ures_close(currencyMap);
ures_close(supplData);
return NULL;
}
UResourceBundle *currencyId = ures_getByKey(currencyElem, "id", NULL, &status);
if(U_FAILURE(status)) {
ures_close(currencyElem);
ures_close(currency);
ures_close(currencyMap);
ures_close(supplData);
return NULL;
}
int length;
const jchar *id = ures_getString(currencyId, &length, &status);
if(U_FAILURE(status)) {
ures_close(currencyId);
ures_close(currencyElem);
ures_close(currency);
ures_close(currencyMap);
ures_close(supplData);
return NULL;
}
ures_close(currencyId);
ures_close(currencyElem);
ures_close(currency);
ures_close(currencyMap);
ures_close(supplData);
if(length == 0) {
return NULL;
}
return env->NewString(id, length);
}
void
DecimalFormatSymbols::initialize(const Locale& loc, UErrorCode& status, UBool useLastResortData)
{
static const char *gNumberElementKeys[kFormatSymbolCount] = {
"decimal",
"group",
"list",
"percentSign",
NULL, /* Native zero digit is deprecated from CLDR - get it from the numbering system */
NULL, /* Pattern digit character is deprecated from CLDR - use # by default always */
"minusSign",
"plusSign",
NULL, /* currency symbol - We don't really try to load this directly from CLDR until we know the currency */
NULL, /* intl currency symbol - We don't really try to load this directly from CLDR until we know the currency */
"currencyDecimal",
"exponential",
"perMille",
NULL, /* Escape padding character - not in CLDR */
"infinity",
"nan",
NULL, /* Significant digit symbol - not in CLDR */
"currencyGroup",
NULL, /* one digit - get it from the numbering system */
NULL, /* two digit - get it from the numbering system */
NULL, /* three digit - get it from the numbering system */
NULL, /* four digit - get it from the numbering system */
NULL, /* five digit - get it from the numbering system */
NULL, /* six digit - get it from the numbering system */
NULL, /* seven digit - get it from the numbering system */
NULL, /* eight digit - get it from the numbering system */
NULL, /* nine digit - get it from the numbering system */
"superscriptingExponent", /* Multiplication (x) symbol for exponents */
};
static const char *gLatn = "latn";
static const char *gSymbols = "symbols";
const char *nsName;
const UChar *sym = NULL;
int32_t len = 0;
*validLocale = *actualLocale = 0;
currPattern = NULL;
if (U_FAILURE(status))
return;
const char* locStr = loc.getName();
LocalUResourceBundlePointer resource(ures_open(NULL, locStr, &status));
LocalUResourceBundlePointer numberElementsRes(
ures_getByKeyWithFallback(resource.getAlias(), gNumberElements, NULL, &status));
if (U_FAILURE(status)) {
if ( useLastResortData ) {
status = U_USING_DEFAULT_WARNING;
initialize();
}
return;
}
// First initialize all the symbols to the fallbacks for anything we can't find
initialize();
//
// Next get the numbering system for this locale and set zero digit
// and the digit string based on the numbering system for the locale
//
LocalPointer<NumberingSystem> ns(NumberingSystem::createInstance(loc, status));
if (U_SUCCESS(status) && ns->getRadix() == 10 && !ns->isAlgorithmic()) {
nsName = ns->getName();
UnicodeString digitString(ns->getDescription());
int32_t digitIndex = 0;
UChar32 digit = digitString.char32At(0);
fSymbols[kZeroDigitSymbol].setTo(digit);
for (int32_t i = kOneDigitSymbol; i <= kNineDigitSymbol; ++i) {
digitIndex += U16_LENGTH(digit);
digit = digitString.char32At(digitIndex);
fSymbols[i].setTo(digit);
}
} else {
nsName = gLatn;
}
UBool isLatn = !uprv_strcmp(nsName,gLatn);
UErrorCode nlStatus = U_ZERO_ERROR;
LocalUResourceBundlePointer nonLatnSymbols;
if ( !isLatn ) {
nonLatnSymbols.adoptInstead(
ures_getByKeyWithFallback(numberElementsRes.getAlias(), nsName, NULL, &nlStatus));
ures_getByKeyWithFallback(nonLatnSymbols.getAlias(), gSymbols, nonLatnSymbols.getAlias(), &nlStatus);
}
LocalUResourceBundlePointer latnSymbols(
ures_getByKeyWithFallback(numberElementsRes.getAlias(), gLatn, NULL, &status));
ures_getByKeyWithFallback(latnSymbols.getAlias(), gSymbols, latnSymbols.getAlias(), &status);
UBool kMonetaryDecimalSet = FALSE;
UBool kMonetaryGroupingSet = FALSE;
for(int32_t i = 0; i<kFormatSymbolCount; i++) {
if ( gNumberElementKeys[i] != NULL ) {
UErrorCode localStatus = U_ZERO_ERROR;
if ( !isLatn ) {
sym = ures_getStringByKeyWithFallback(nonLatnSymbols.getAlias(),
gNumberElementKeys[i], &len, &localStatus);
// If we can't find the symbol in the numbering system specific resources,
// use the "latn" numbering system as the fallback.
if ( U_FAILURE(localStatus) ) {
localStatus = U_ZERO_ERROR;
sym = ures_getStringByKeyWithFallback(latnSymbols.getAlias(),
gNumberElementKeys[i], &len, &localStatus);
}
} else {
sym = ures_getStringByKeyWithFallback(latnSymbols.getAlias(),
gNumberElementKeys[i], &len, &localStatus);
}
if ( U_SUCCESS(localStatus) ) {
setSymbol((ENumberFormatSymbol)i, UnicodeString(TRUE, sym, len));
if ( i == kMonetarySeparatorSymbol ) {
kMonetaryDecimalSet = TRUE;
} else if ( i == kMonetaryGroupingSeparatorSymbol ) {
kMonetaryGroupingSet = TRUE;
}
}
}
}
// If monetary decimal or grouping were not explicitly set, then set them to be the
// same as their non-monetary counterparts.
if ( !kMonetaryDecimalSet ) {
setSymbol(kMonetarySeparatorSymbol,fSymbols[kDecimalSeparatorSymbol]);
}
if ( !kMonetaryGroupingSet ) {
setSymbol(kMonetaryGroupingSeparatorSymbol,fSymbols[kGroupingSeparatorSymbol]);
}
// Obtain currency data from the currency API. This is strictly
// for backward compatibility; we don't use DecimalFormatSymbols
// for currency data anymore.
UErrorCode internalStatus = U_ZERO_ERROR; // don't propagate failures out
UChar curriso[4];
UnicodeString tempStr;
ucurr_forLocale(locStr, curriso, 4, &internalStatus);
uprv_getStaticCurrencyName(curriso, locStr, tempStr, internalStatus);
if (U_SUCCESS(internalStatus)) {
fSymbols[kIntlCurrencySymbol].setTo(curriso, -1);
fSymbols[kCurrencySymbol] = tempStr;
}
/* else use the default values. */
U_LOCALE_BASED(locBased, *this);
locBased.setLocaleIDs(ures_getLocaleByType(numberElementsRes.getAlias(),
ULOC_VALID_LOCALE, &status),
ures_getLocaleByType(numberElementsRes.getAlias(),
ULOC_ACTUAL_LOCALE, &status));
//load the currency data
UChar ucc[4]={0}; //Currency Codes are always 3 chars long
int32_t uccLen = 4;
const char* locName = loc.getName();
UErrorCode localStatus = U_ZERO_ERROR;
uccLen = ucurr_forLocale(locName, ucc, uccLen, &localStatus);
if(U_SUCCESS(localStatus) && uccLen > 0) {
char cc[4]={0};
u_UCharsToChars(ucc, cc, uccLen);
/* An explicit currency was requested */
LocalUResourceBundlePointer currencyResource(ures_open(U_ICUDATA_CURR, locStr, &localStatus));
LocalUResourceBundlePointer currency(
ures_getByKeyWithFallback(currencyResource.getAlias(), "Currencies", NULL, &localStatus));
ures_getByKeyWithFallback(currency.getAlias(), cc, currency.getAlias(), &localStatus);
if(U_SUCCESS(localStatus) && ures_getSize(currency.getAlias())>2) { // the length is 3 if more data is present
ures_getByIndex(currency.getAlias(), 2, currency.getAlias(), &localStatus);
int32_t currPatternLen = 0;
currPattern =
ures_getStringByIndex(currency.getAlias(), (int32_t)0, &currPatternLen, &localStatus);
UnicodeString decimalSep =
ures_getUnicodeStringByIndex(currency.getAlias(), (int32_t)1, &localStatus);
UnicodeString groupingSep =
ures_getUnicodeStringByIndex(currency.getAlias(), (int32_t)2, &localStatus);
if(U_SUCCESS(localStatus)){
fSymbols[kMonetaryGroupingSeparatorSymbol] = groupingSep;
fSymbols[kMonetarySeparatorSymbol] = decimalSep;
//pattern.setTo(TRUE, currPattern, currPatternLen);
status = localStatus;
}
}
/* else An explicit currency was requested and is unknown or locale data is malformed. */
/* ucurr_* API will get the correct value later on. */
}
// else ignore the error if no currency
// Currency Spacing.
localStatus = U_ZERO_ERROR;
LocalUResourceBundlePointer currencyResource(ures_open(U_ICUDATA_CURR, locStr, &localStatus));
LocalUResourceBundlePointer currencySpcRes(
ures_getByKeyWithFallback(currencyResource.getAlias(),
gCurrencySpacingTag, NULL, &localStatus));
if (localStatus == U_USING_FALLBACK_WARNING || U_SUCCESS(localStatus)) {
const char* keywords[UNUM_CURRENCY_SPACING_COUNT] = {
gCurrencyMatchTag, gCurrencySudMatchTag, gCurrencyInsertBtnTag
};
localStatus = U_ZERO_ERROR;
LocalUResourceBundlePointer dataRes(
ures_getByKeyWithFallback(currencySpcRes.getAlias(),
gBeforeCurrencyTag, NULL, &localStatus));
if (localStatus == U_USING_FALLBACK_WARNING || U_SUCCESS(localStatus)) {
localStatus = U_ZERO_ERROR;
for (int32_t i = 0; i < UNUM_CURRENCY_SPACING_COUNT; i++) {
currencySpcBeforeSym[i] =
ures_getUnicodeStringByKey(dataRes.getAlias(), keywords[i], &localStatus);
}
}
dataRes.adoptInstead(
ures_getByKeyWithFallback(currencySpcRes.getAlias(),
gAfterCurrencyTag, NULL, &localStatus));
if (localStatus == U_USING_FALLBACK_WARNING || U_SUCCESS(localStatus)) {
localStatus = U_ZERO_ERROR;
for (int32_t i = 0; i < UNUM_CURRENCY_SPACING_COUNT; i++) {
currencySpcAfterSym[i] =
ures_getUnicodeStringByKey(dataRes.getAlias(), keywords[i], &localStatus);
}
}
}
}
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) {
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(NULL, 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;
}
void
StringCaseTest::TestTitleCasing() {
UErrorCode status = U_ZERO_ERROR;
UBreakIterator *iter;
char cLocaleID[100];
UnicodeString locale, input, result;
int32_t type;
TestDataModule *driver = TestDataModule::getTestDataModule("casing", *this, status);
if(U_SUCCESS(status)) {
TestData *casingTest = driver->createTestData("titlecasing", status);
const DataMap *myCase = NULL;
while(casingTest->nextCase(myCase, status)) {
locale = myCase->getString("Locale", status);
locale.extract(0, 0x7fffffff, cLocaleID, sizeof(cLocaleID), "");
type = myCase->getInt("Type", status);
input = myCase->getString("Input", status);
if(type<0) {
iter=0;
} else {
iter=ubrk_open((UBreakIteratorType)type, cLocaleID, NULL, 0, &status);
}
if(U_FAILURE(status)) {
errln("error: TestTitleCasing() ubrk_open(%d) failed for test case from casing.res: %s", type, u_errorName(status));
status = U_ZERO_ERROR;
} else {
result=input;
result.toTitle((BreakIterator *)iter, Locale(cLocaleID));
if(result!=myCase->getString("Output", status)) {
errln("error: TestTitleCasing() got a wrong result for test case from casing.res");
}
ubrk_close(iter);
}
}
delete casingTest;
}
delete driver;
// more tests for API coverage
status=U_ZERO_ERROR;
input=UNICODE_STRING_SIMPLE("sTrA\\u00dfE").unescape();
(result=input).toTitle(NULL);
if(result!=UNICODE_STRING_SIMPLE("Stra\\u00dfe").unescape()) {
errln("UnicodeString::toTitle(NULL) failed");
}
#if 0
char cLocaleID[100];
UnicodeString in, expect, result, localeID;
UResourceBundle *casing, *titlecasing, *test, *res;
UErrorCode errorCode;
int32_t testIndex, type;
errorCode=U_ZERO_ERROR;
loadTestData(errorCode);
casing=ures_openDirect("testdata", "casing", &errorCode);
if(U_FAILURE(errorCode)) {
errln("error: TestTitleCasing() is unable to open casing.res: %s", u_errorName(errorCode));
return;
}
// titlecasing tests
titlecasing=ures_getByKey(casing, "titlecasing", 0, &errorCode);
if(U_FAILURE(errorCode)) {
logln("TestTitleCasing() is unable to open get casing.res/titlecasing: %s", u_errorName(errorCode));
} else {
UBreakIterator *iter;
for(testIndex=0;; ++testIndex) {
// get test case
test=ures_getByIndex(titlecasing, testIndex, 0, &errorCode);
if(U_FAILURE(errorCode)) {
break; // done
}
// get test case data
in=ures_getUnicodeStringByIndex(test, 0, &errorCode);
expect=ures_getUnicodeStringByIndex(test, 1, &errorCode);
localeID=ures_getUnicodeStringByIndex(test, 2, &errorCode);
res=ures_getByIndex(test, 3, 0, &errorCode);
type=ures_getInt(res, &errorCode);
ures_close(res);
if(U_FAILURE(errorCode)) {
errln("error: TestTitleCasing() is unable to get data for test case %ld from casing.res: %s", testIndex, u_errorName(errorCode));
continue; // skip this test case
}
// run this test case
localeID.extract(0, 0x7fffffff, cLocaleID, sizeof(cLocaleID), "");
if(type<0) {
iter=0;
} else {
iter=ubrk_open((UBreakIteratorType)type, cLocaleID, in.getBuffer(), in.length(), &errorCode);
}
if(U_FAILURE(errorCode)) {
errln("error: TestTitleCasing() ubrk_open(%d) failed for test case %d from casing.res: %s", type, testIndex, u_errorName(errorCode));
} else {
result=in;
result.toTitle((BreakIterator *)iter, Locale(cLocaleID));
if(result!=expect) {
errln("error: TestTitleCasing() got a wrong result for test case %ld from casing.res", testIndex);
}
}
// clean up
ubrk_close(iter);
ures_close(test);
}
ures_close(titlecasing);
logln("TestTitleCasing() processed %ld test cases", testIndex);
}
ures_close(casing);
#endif
}
static void TestGetSize(void) {
const struct {
const char* key;
int32_t size;
} test[] = {
{ "zerotest", 1},
{ "one", 1},
{ "importtest", 1},
{ "integerarray", 1},
{ "emptyarray", 0},
{ "emptytable", 0},
{ "emptystring", 1}, /* empty string is still a string */
{ "emptyint", 1},
{ "emptybin", 1},
{ "testinclude", 1},
{ "collations", 1}, /* not 2 - there is hidden %%CollationBin */
};
UErrorCode status = U_ZERO_ERROR;
UResourceBundle *rb = NULL;
UResourceBundle *res = NULL;
UResourceBundle *helper = NULL;
const char* testdatapath = loadTestData(&status);
int32_t i = 0, j = 0;
int32_t size = 0;
if(U_FAILURE(status))
{
log_data_err("Could not load testdata.dat %s\n", u_errorName(status));
return;
}
rb = ures_open(testdatapath, "testtypes", &status);
if(U_FAILURE(status))
{
log_err("Could not testtypes resource bundle %s\n", u_errorName(status));
return;
}
for(i = 0; i < UPRV_LENGTHOF(test); i++) {
res = ures_getByKey(rb, test[i].key, res, &status);
if(U_FAILURE(status))
{
log_err("Couldn't find the key %s. Error: %s\n", test[i].key, u_errorName(status));
ures_close(rb);
return;
}
size = ures_getSize(res);
if(size != test[i].size) {
log_err("Expected size %i, got size %i for key %s\n", test[i].size, size, test[i].key);
for(j = 0; j < size; j++) {
helper = ures_getByIndex(res, j, helper, &status);
log_err("%s\n", ures_getKey(helper));
}
}
}
ures_close(helper);
ures_close(res);
ures_close(rb);
}
// populatePower10 grabs data for a particular power of 10 from CLDR.
// The loaded data is stored in result.
static void populatePower10(const UResourceBundle* power10Bundle, CDFLocaleStyleData* result, UErrorCode& status) {
if (U_FAILURE(status)) {
return;
}
char* endPtr = NULL;
double power10 = uprv_strtod(ures_getKey(power10Bundle), &endPtr);
if (*endPtr != 0) {
status = U_INTERNAL_PROGRAM_ERROR;
return;
}
int32_t log10Value = computeLog10(power10, FALSE);
// Silently ignore divisors that are too big.
if (log10Value == MAX_DIGITS) {
return;
}
int32_t size = ures_getSize(power10Bundle);
int32_t numZeros = 0;
UBool otherVariantDefined = FALSE;
UResourceBundle* variantBundle = NULL;
// Iterate over all the plural variants for the power of 10
for (int32_t i = 0; i < size; ++i) {
variantBundle = ures_getByIndex(power10Bundle, i, variantBundle, &status);
if (U_FAILURE(status)) {
ures_close(variantBundle);
return;
}
const char* variant = ures_getKey(variantBundle);
int32_t resLen;
const UChar* formatStrP = ures_getString(variantBundle, &resLen, &status);
if (U_FAILURE(status)) {
ures_close(variantBundle);
return;
}
UnicodeString formatStr(false, formatStrP, resLen);
if (uprv_strcmp(variant, gOther) == 0) {
otherVariantDefined = TRUE;
}
int32_t nz = populatePrefixSuffix(
variant, log10Value, formatStr, result->unitsByVariant, status);
if (U_FAILURE(status)) {
ures_close(variantBundle);
return;
}
if (nz != numZeros) {
// We expect all format strings to have the same number of 0's
// left of the decimal point.
if (numZeros != 0) {
status = U_INTERNAL_PROGRAM_ERROR;
ures_close(variantBundle);
return;
}
numZeros = nz;
}
}
ures_close(variantBundle);
// We expect to find an OTHER variant for each power of 10.
if (!otherVariantDefined) {
status = U_INTERNAL_PROGRAM_ERROR;
return;
}
double divisor = power10;
for (int32_t i = 1; i < numZeros; ++i) {
divisor /= 10.0;
}
result->divisors[log10Value] = divisor;
}
#include "resourcebundle/resourcebundle_class.h"
#include "resourcebundle/resourcebundle_iterator.h"
/*
* Although libicu offers iterator functions, they are not used here: libicu does iterate
* irrespective of array indices. Those cannot be recreated afterwards. Arrays as well as tables
* can however be accessed by numerical index, with table keys readable ex post.
*/
/* {{{ resourcebundle_iterator_read */
static void resourcebundle_iterator_read( ResourceBundle_iterator *iterator TSRMLS_DC )
{
UErrorCode icuerror = U_ZERO_ERROR;
ResourceBundle_object *rb = iterator->subject;
rb->child = ures_getByIndex( rb->me, iterator->i, rb->child, &icuerror );
if (U_SUCCESS(icuerror)) {
/* ATTN: key extraction must be the first thing to do... rb->child might be reset in read! */
if (iterator->is_table) {
iterator->currentkey = estrdup( ures_getKey( rb->child ) );
}
MAKE_STD_ZVAL( iterator->current );
resourcebundle_extract_value( iterator->current, rb TSRMLS_CC );
}
else {
// zend_throw_exception( spl_ce_OutOfRangeException, "Running past end of ResourceBundle", 0 TSRMLS_CC);
iterator->current = NULL;
}
}
/* }}} */
void
DecimalFormatSymbols::initialize(const Locale& loc, UErrorCode& status,
UBool useLastResortData)
{
*validLocale = *actualLocale = 0;
currPattern = NULL;
if (U_FAILURE(status))
return;
const char* locStr = loc.getName();
UResourceBundle *resource = ures_open((char *)0, locStr, &status);
UResourceBundle *numberElementsRes = ures_getByKey(resource, gNumberElements, NULL, &status);
if (U_FAILURE(status))
{
// Initializes with last resort data if necessary.
if (useLastResortData)
{
status = U_USING_FALLBACK_WARNING;
initialize();
}
}
else {
// Gets the number element array.
int32_t numberElementsLength = ures_getSize(numberElementsRes);
if (numberElementsLength > (int32_t)kFormatSymbolCount) {
/* Warning: Invalid format. Array too large. */
numberElementsLength = (int32_t)kFormatSymbolCount;
}
// If the array size is too small, something is wrong with the resource
// bundle, returns the failure error code.
if (numberElementsLength != 12 || U_FAILURE(status)) {
status = U_INVALID_FORMAT_ERROR;
}
else {
const UChar *numberElements[kFormatSymbolCount];
int32_t numberElementsStrLen[kFormatSymbolCount];
int32_t i = 0;
for(i = 0; i<numberElementsLength; i++) {
numberElements[i] = ures_getStringByIndex(numberElementsRes, i, &numberElementsStrLen[i], &status);
}
if (U_SUCCESS(status)) {
initialize(numberElements, numberElementsStrLen, numberElementsLength);
// Obtain currency data from the currency API. This is strictly
// for backward compatibility; we don't use DecimalFormatSymbols
// for currency data anymore.
UErrorCode internalStatus = U_ZERO_ERROR; // don't propagate failures out
UChar curriso[4];
UnicodeString tempStr;
ucurr_forLocale(locStr, curriso, 4, &internalStatus);
// Reuse numberElements[0] as a temporary buffer
uprv_getStaticCurrencyName(curriso, locStr, tempStr, internalStatus);
if (U_SUCCESS(internalStatus)) {
fSymbols[kIntlCurrencySymbol] = curriso;
fSymbols[kCurrencySymbol] = tempStr;
}
/* else use the default values. */
}
U_LOCALE_BASED(locBased, *this);
locBased.setLocaleIDs(ures_getLocaleByType(numberElementsRes,
ULOC_VALID_LOCALE, &status),
ures_getLocaleByType(numberElementsRes,
ULOC_ACTUAL_LOCALE, &status));
}
//load the currency data
UChar ucc[4]= {0}; //Currency Codes are always 3 chars long
int32_t uccLen = 4;
const char* locName = loc.getName();
uccLen = ucurr_forLocale(locName, ucc, uccLen, &status);
if(U_SUCCESS(status) && uccLen > 0) {
char cc[4]= {0};
u_UCharsToChars(ucc, cc, uccLen);
/* An explicit currency was requested */
UErrorCode localStatus = U_ZERO_ERROR;
UResourceBundle *currency = ures_getByKeyWithFallback(resource, "Currencies", NULL, &localStatus);
currency = ures_getByKeyWithFallback(currency, cc, currency, &localStatus);
if(U_SUCCESS(localStatus) && ures_getSize(currency)>2) { // the length is 3 if more data is present
currency = ures_getByIndex(currency, 2, currency, &localStatus);
int32_t currPatternLen = 0;
currPattern = ures_getStringByIndex(currency, (int32_t)0, &currPatternLen, &localStatus);
UnicodeString decimalSep = ures_getStringByIndex(currency, (int32_t)1, NULL, &localStatus);
UnicodeString groupingSep = ures_getStringByIndex(currency, (int32_t)2, NULL, &localStatus);
if(U_SUCCESS(localStatus)) {
fSymbols[kMonetaryGroupingSeparatorSymbol] = groupingSep;
fSymbols[kMonetarySeparatorSymbol] = decimalSep;
//pattern.setTo(TRUE, currPattern, currPatternLen);
status = localStatus;
}
}
ures_close(currency);
/* else An explicit currency was requested and is unknown or locale data is malformed. */
/* ucurr_* API will get the correct value later on. */
} else {
// ignore the error if no currency
status = U_ZERO_ERROR;
}
}
ures_close(resource);
ures_close(numberElementsRes);
}
void
DecimalFormatSymbols::initialize(const Locale& loc, UErrorCode& status, UBool useLastResortData)
{
if (U_FAILURE(status)) { return; }
*validLocale = *actualLocale = 0;
currPattern = NULL;
// First initialize all the symbols to the fallbacks for anything we can't find
initialize();
//
// Next get the numbering system for this locale and set zero digit
// and the digit string based on the numbering system for the locale
//
LocalPointer<NumberingSystem> ns(NumberingSystem::createInstance(loc, status));
const char *nsName;
if (U_SUCCESS(status) && ns->getRadix() == 10 && !ns->isAlgorithmic()) {
nsName = ns->getName();
UnicodeString digitString(ns->getDescription());
int32_t digitIndex = 0;
UChar32 digit = digitString.char32At(0);
fSymbols[kZeroDigitSymbol].setTo(digit);
for (int32_t i = kOneDigitSymbol; i <= kNineDigitSymbol; ++i) {
digitIndex += U16_LENGTH(digit);
digit = digitString.char32At(digitIndex);
fSymbols[i].setTo(digit);
}
} else {
nsName = gLatn;
}
// Open resource bundles
const char* locStr = loc.getName();
LocalUResourceBundlePointer resource(ures_open(NULL, locStr, &status));
LocalUResourceBundlePointer numberElementsRes(
ures_getByKeyWithFallback(resource.getAlias(), gNumberElements, NULL, &status));
if (U_FAILURE(status)) {
if ( useLastResortData ) {
status = U_USING_DEFAULT_WARNING;
initialize();
}
return;
}
// Set locale IDs
// TODO: Is there a way to do this without depending on the resource bundle instance?
U_LOCALE_BASED(locBased, *this);
locBased.setLocaleIDs(
ures_getLocaleByType(
numberElementsRes.getAlias(),
ULOC_VALID_LOCALE, &status),
ures_getLocaleByType(
numberElementsRes.getAlias(),
ULOC_ACTUAL_LOCALE, &status));
// Now load the rest of the data from the data sink.
// Start with loading this nsName if it is not Latin.
DecFmtSymDataSink sink(*this);
if (uprv_strcmp(nsName, gLatn) != 0) {
CharString path;
path.append(gNumberElements, status)
.append('/', status)
.append(nsName, status)
.append('/', status)
.append(gSymbols, status);
ures_getAllItemsWithFallback(resource.getAlias(), path.data(), sink, status);
// If no symbols exist for the given nsName and resource bundle, silently ignore
// and fall back to Latin.
if (status == U_MISSING_RESOURCE_ERROR) {
status = U_ZERO_ERROR;
} else if (U_FAILURE(status)) {
return;
}
}
// Continue with Latin if necessary.
if (!sink.seenAll()) {
ures_getAllItemsWithFallback(resource.getAlias(), gNumberElementsLatnSymbols, sink, status);
if (U_FAILURE(status)) { return; }
}
// Let the monetary number separators equal the default number separators if necessary.
sink.resolveMissingMonetarySeparators(fSymbols);
// Obtain currency data from the currency API. This is strictly
// for backward compatibility; we don't use DecimalFormatSymbols
// for currency data anymore.
UErrorCode internalStatus = U_ZERO_ERROR; // don't propagate failures out
UChar curriso[4];
UnicodeString tempStr;
ucurr_forLocale(locStr, curriso, 4, &internalStatus);
uprv_getStaticCurrencyName(curriso, locStr, tempStr, internalStatus);
if (U_SUCCESS(internalStatus)) {
fSymbols[kIntlCurrencySymbol].setTo(curriso, -1);
fSymbols[kCurrencySymbol] = tempStr;
}
/* else use the default values. */
//load the currency data
UChar ucc[4]={0}; //Currency Codes are always 3 chars long
int32_t uccLen = 4;
const char* locName = loc.getName();
UErrorCode localStatus = U_ZERO_ERROR;
uccLen = ucurr_forLocale(locName, ucc, uccLen, &localStatus);
if(U_SUCCESS(localStatus) && uccLen > 0) {
char cc[4]={0};
u_UCharsToChars(ucc, cc, uccLen);
/* An explicit currency was requested */
LocalUResourceBundlePointer currencyResource(ures_open(U_ICUDATA_CURR, locStr, &localStatus));
LocalUResourceBundlePointer currency(
ures_getByKeyWithFallback(currencyResource.getAlias(), "Currencies", NULL, &localStatus));
ures_getByKeyWithFallback(currency.getAlias(), cc, currency.getAlias(), &localStatus);
if(U_SUCCESS(localStatus) && ures_getSize(currency.getAlias())>2) { // the length is 3 if more data is present
ures_getByIndex(currency.getAlias(), 2, currency.getAlias(), &localStatus);
int32_t currPatternLen = 0;
currPattern =
ures_getStringByIndex(currency.getAlias(), (int32_t)0, &currPatternLen, &localStatus);
UnicodeString decimalSep =
ures_getUnicodeStringByIndex(currency.getAlias(), (int32_t)1, &localStatus);
UnicodeString groupingSep =
ures_getUnicodeStringByIndex(currency.getAlias(), (int32_t)2, &localStatus);
if(U_SUCCESS(localStatus)){
fSymbols[kMonetaryGroupingSeparatorSymbol] = groupingSep;
fSymbols[kMonetarySeparatorSymbol] = decimalSep;
//pattern.setTo(TRUE, currPattern, currPatternLen);
status = localStatus;
}
}
/* else An explicit currency was requested and is unknown or locale data is malformed. */
/* ucurr_* API will get the correct value later on. */
}
// else ignore the error if no currency
// Currency Spacing.
localStatus = U_ZERO_ERROR;
LocalUResourceBundlePointer currencyResource(ures_open(U_ICUDATA_CURR, locStr, &localStatus));
LocalUResourceBundlePointer currencySpcRes(
ures_getByKeyWithFallback(currencyResource.getAlias(),
gCurrencySpacingTag, NULL, &localStatus));
if (localStatus == U_USING_FALLBACK_WARNING || U_SUCCESS(localStatus)) {
const char* keywords[UNUM_CURRENCY_SPACING_COUNT] = {
gCurrencyMatchTag, gCurrencySudMatchTag, gCurrencyInsertBtnTag
};
localStatus = U_ZERO_ERROR;
LocalUResourceBundlePointer dataRes(
ures_getByKeyWithFallback(currencySpcRes.getAlias(),
gBeforeCurrencyTag, NULL, &localStatus));
if (localStatus == U_USING_FALLBACK_WARNING || U_SUCCESS(localStatus)) {
localStatus = U_ZERO_ERROR;
for (int32_t i = 0; i < UNUM_CURRENCY_SPACING_COUNT; i++) {
currencySpcBeforeSym[i] =
ures_getUnicodeStringByKey(dataRes.getAlias(), keywords[i], &localStatus);
}
}
dataRes.adoptInstead(
ures_getByKeyWithFallback(currencySpcRes.getAlias(),
gAfterCurrencyTag, NULL, &localStatus));
if (localStatus == U_USING_FALLBACK_WARNING || U_SUCCESS(localStatus)) {
localStatus = U_ZERO_ERROR;
for (int32_t i = 0; i < UNUM_CURRENCY_SPACING_COUNT; i++) {
currencySpcAfterSym[i] =
ures_getUnicodeStringByKey(dataRes.getAlias(), keywords[i], &localStatus);
}
}
}
}
void
TimeUnitFormat::readFromCurrentLocale(UTimeUnitFormatStyle style, const char* key,
const UVector& pluralCounts, UErrorCode& err) {
if (U_FAILURE(err)) {
return;
}
// fill timeUnitToCountToPatterns from resource file
// err is used to indicate wrong status except missing resource.
// status is an error code used in resource lookup.
// status does not affect "err".
UErrorCode status = U_ZERO_ERROR;
UResourceBundle *rb, *unitsRes;
rb = ures_open(U_ICUDATA_UNIT, getLocaleID(status), &status);
unitsRes = ures_getByKey(rb, key, NULL, &status);
unitsRes = ures_getByKey(unitsRes, "duration", unitsRes, &status);
if (U_FAILURE(status)) {
ures_close(unitsRes);
ures_close(rb);
return;
}
int32_t size = ures_getSize(unitsRes);
for ( int32_t index = 0; index < size; ++index) {
// resource of one time unit
UResourceBundle* oneTimeUnit = ures_getByIndex(unitsRes, index,
NULL, &status);
if (U_SUCCESS(status)) {
const char* timeUnitName = ures_getKey(oneTimeUnit);
if (timeUnitName == NULL) {
ures_close(oneTimeUnit);
continue;
}
UResourceBundle* countsToPatternRB = ures_getByKey(unitsRes,
timeUnitName,
NULL, &status);
if (countsToPatternRB == NULL || U_FAILURE(status)) {
ures_close(countsToPatternRB);
ures_close(oneTimeUnit);
continue;
}
TimeUnit::UTimeUnitFields timeUnitField = TimeUnit::UTIMEUNIT_FIELD_COUNT;
if ( uprv_strcmp(timeUnitName, gTimeUnitYear) == 0 ) {
timeUnitField = TimeUnit::UTIMEUNIT_YEAR;
} else if ( uprv_strcmp(timeUnitName, gTimeUnitMonth) == 0 ) {
timeUnitField = TimeUnit::UTIMEUNIT_MONTH;
} else if ( uprv_strcmp(timeUnitName, gTimeUnitDay) == 0 ) {
timeUnitField = TimeUnit::UTIMEUNIT_DAY;
} else if ( uprv_strcmp(timeUnitName, gTimeUnitHour) == 0 ) {
timeUnitField = TimeUnit::UTIMEUNIT_HOUR;
} else if ( uprv_strcmp(timeUnitName, gTimeUnitMinute) == 0 ) {
timeUnitField = TimeUnit::UTIMEUNIT_MINUTE;
} else if ( uprv_strcmp(timeUnitName, gTimeUnitSecond) == 0 ) {
timeUnitField = TimeUnit::UTIMEUNIT_SECOND;
} else if ( uprv_strcmp(timeUnitName, gTimeUnitWeek) == 0 ) {
timeUnitField = TimeUnit::UTIMEUNIT_WEEK;
} else {
ures_close(countsToPatternRB);
ures_close(oneTimeUnit);
continue;
}
Hashtable* countToPatterns = fTimeUnitToCountToPatterns[timeUnitField];
if (countToPatterns == NULL) {
countToPatterns = initHash(err);
if (U_FAILURE(err)) {
ures_close(countsToPatternRB);
ures_close(oneTimeUnit);
delete countToPatterns;
break;
}
}
int32_t count = ures_getSize(countsToPatternRB);
const char* pluralCount;
for ( int32_t pluralIndex = 0; pluralIndex < count; ++pluralIndex) {
// resource of count to pattern
UnicodeString pattern =
ures_getNextUnicodeString(countsToPatternRB, &pluralCount, &status);
if (U_FAILURE(status)) {
continue;
}
UnicodeString pluralCountUniStr(pluralCount, -1, US_INV);
if (!pluralCounts.contains(&pluralCountUniStr)) {
continue;
}
MessageFormat* messageFormat = new MessageFormat(pattern, getLocale(err), err);
if ( U_SUCCESS(err) ) {
MessageFormat** formatters = (MessageFormat**)countToPatterns->get(pluralCountUniStr);
if (formatters == NULL) {
formatters = (MessageFormat**)uprv_malloc(UTMUTFMT_FORMAT_STYLE_COUNT*sizeof(MessageFormat*));
formatters[UTMUTFMT_FULL_STYLE] = NULL;
formatters[UTMUTFMT_ABBREVIATED_STYLE] = NULL;
countToPatterns->put(pluralCountUniStr, formatters, err);
if (U_FAILURE(err)) {
uprv_free(formatters);
}
}
if (U_SUCCESS(err)) {
//delete formatters[style];
formatters[style] = messageFormat;
}
}
if (U_FAILURE(err)) {
ures_close(countsToPatternRB);
ures_close(oneTimeUnit);
ures_close(unitsRes);
ures_close(rb);
delete messageFormat;
delete countToPatterns;
return;
}
}
if (fTimeUnitToCountToPatterns[timeUnitField] == NULL) {
fTimeUnitToCountToPatterns[timeUnitField] = countToPatterns;
}
ures_close(countsToPatternRB);
}
ures_close(oneTimeUnit);
}
ures_close(unitsRes);
ures_close(rb);
}
static void
TestTable32(void) {
static const struct {
const char *key;
int32_t number;
} testcases[]={
{ "ooooooooooooooooo", 0 },
{ "oooooooooooooooo1", 1 },
{ "ooooooooooooooo1o", 2 },
{ "oo11ooo1ooo11111o", 25150 },
{ "oo11ooo1ooo111111", 25151 },
{ "o1111111111111111", 65535 },
{ "1oooooooooooooooo", 65536 },
{ "1ooooooo11o11ooo1", 65969 },
{ "1ooooooo11o11oo1o", 65970 },
{ "1ooooooo111oo1111", 65999 }
};
/* ### TODO UResourceBundle staticItem={ 0 }; - need to know the size */
UResourceBundle *res, *item;
const UChar *s;
const char *key;
UErrorCode errorCode;
int32_t i, j, number, parsedNumber, length, count;
errorCode=U_ZERO_ERROR;
res=ures_open(loadTestData(&errorCode), "testtable32", &errorCode);
if(U_FAILURE(errorCode)) {
log_data_err("unable to open testdata/testtable32.res - %s\n", u_errorName(errorCode));
return;
}
if(ures_getType(res)!=URES_TABLE) {
log_data_err("testdata/testtable32.res has type %d instead of URES_TABLE\n", ures_getType(res));
}
count=ures_getSize(res);
if(count!=66000) {
log_err("testdata/testtable32.res should have 66000 entries but has %d\n", count);
}
/* get the items by index */
item=NULL;
for(i=0; i<count; ++i) {
item=ures_getByIndex(res, i, item, &errorCode);
if(U_FAILURE(errorCode)) {
log_err("unable to get item %d of %d in testdata/testtable32.res - %s\n",
i, count, u_errorName(errorCode));
break;
}
key=ures_getKey(item);
parsedNumber=parseTable32Key(key);
switch(ures_getType(item)) {
case URES_STRING:
s=ures_getString(item, &length, &errorCode);
if(U_FAILURE(errorCode) || s==NULL) {
log_err("unable to access the string \"%s\" at %d in testdata/testtable32.res - %s\n",
key, i, u_errorName(errorCode));
number=-1;
} else {
j=0;
U16_NEXT(s, j, length, number);
}
break;
case URES_INT:
number=ures_getInt(item, &errorCode);
if(U_FAILURE(errorCode)) {
log_err("unable to access the integer \"%s\" at %d in testdata/testtable32.res - %s\n",
key, i, u_errorName(errorCode));
number=-1;
}
break;
default:
log_err("unexpected resource type %d for \"%s\" at %d in testdata/testtable32.res - %s\n",
ures_getType(item), key, i, u_errorName(errorCode));
number=-1;
break;
}
if(number>=0 && number!=parsedNumber) {
log_err("\"%s\" at %d in testdata/testtable32.res has a string/int value of %d, expected %d\n",
key, i, number, parsedNumber);
}
}
/* search for some items by key */
for(i=0; i<UPRV_LENGTHOF(testcases); ++i) {
item=ures_getByKey(res, testcases[i].key, item, &errorCode);
if(U_FAILURE(errorCode)) {
log_err("unable to find the key \"%s\" in testdata/testtable32.res - %s\n",
testcases[i].key, u_errorName(errorCode));
continue;
}
switch(ures_getType(item)) {
case URES_STRING:
s=ures_getString(item, &length, &errorCode);
if(U_FAILURE(errorCode) || s==NULL) {
log_err("unable to access the string \"%s\" in testdata/testtable32.res - %s\n",
testcases[i].key, u_errorName(errorCode));
number=-1;
} else {
j=0;
U16_NEXT(s, j, length, number);
}
break;
case URES_INT:
number=ures_getInt(item, &errorCode);
if(U_FAILURE(errorCode)) {
log_err("unable to access the integer \"%s\" in testdata/testtable32.res - %s\n",
testcases[i].key, u_errorName(errorCode));
number=-1;
}
break;
default:
log_err("unexpected resource type %d for \"%s\" in testdata/testtable32.res - %s\n",
ures_getType(item), testcases[i].key, u_errorName(errorCode));
number=-1;
break;
}
if(number>=0 && number!=testcases[i].number) {
log_err("\"%s\" in testdata/testtable32.res has a string/int value of %d, expected %d\n",
testcases[i].key, number, testcases[i].number);
}
key=ures_getKey(item);
if(0!=uprv_strcmp(key, testcases[i].key)) {
log_err("\"%s\" in testdata/testtable32.res claims to have the key \"%s\"\n",
testcases[i].key, key);
}
}
ures_close(item);
ures_close(res);
}
void
NewResourceBundleTest::TestOtherAPI(){
UErrorCode err = U_ZERO_ERROR;
const char* testdatapath=loadTestData(err);
UnicodeString tDataPathUS = UnicodeString(testdatapath, "");
if(U_FAILURE(err))
{
dataerrln("Could not load testdata.dat %s " + UnicodeString(u_errorName(err)));
return;
}
/* Make sure that users using te_IN for the default locale don't get test failures. */
Locale originalDefault;
if (Locale::getDefault() == Locale("te_IN")) {
Locale::setDefault(Locale("en_US"), err);
}
Locale *locale=new Locale("te_IN");
ResourceBundle test0(tDataPathUS, *locale, err);
if(U_FAILURE(err)){
errln("Construction failed");
return;
}
ResourceBundle test1(testdatapath, *locale, err);
if(U_FAILURE(err)){
errln("Construction failed");
return;
}
logln("Testing getLocale()\n");
if(strcmp(test1.getLocale().getName(), locale->getName()) !=0 ){
errln("FAIL: ResourceBundle::getLocale() failed\n");
}
delete locale;
logln("Testing ResourceBundle(UErrorCode)\n");
ResourceBundle defaultresource(err);
ResourceBundle explicitdefaultresource(NULL, Locale::getDefault(), err);
if(U_FAILURE(err)){
errcheckln(err, "Construction of default resourcebundle failed - %s", u_errorName(err));
return;
}
// You can't compare the default locale to the resolved locale in the
// resource bundle due to aliasing, keywords in the default locale
// or the chance that the machine running these tests is using a locale
// that isn't available in ICU.
if(strcmp(defaultresource.getLocale().getName(), explicitdefaultresource.getLocale().getName()) != 0){
errln("Construction of default resourcebundle didn't take the defaultlocale. Expected %s Got %s err=%s\n",
explicitdefaultresource.getLocale().getName(), defaultresource.getLocale().getName(), u_errorName(err));
}
ResourceBundle copyRes(defaultresource);
if(strcmp(copyRes.getName(), defaultresource.getName() ) !=0 ||
strcmp(test1.getName(), defaultresource.getName() ) ==0 ||
strcmp(copyRes.getLocale().getName(), defaultresource.getLocale().getName() ) !=0 ||
strcmp(test1.getLocale().getName(), defaultresource.getLocale().getName() ) ==0 )
{
errln("copy construction failed\n");
}
ResourceBundle defaultSub = defaultresource.get((int32_t)0, err);
ResourceBundle defSubCopy(defaultSub);
if(strcmp(defSubCopy.getName(), defaultSub.getName() ) !=0 ||
strcmp(defSubCopy.getLocale().getName(), defaultSub.getLocale().getName() ) !=0 ){
errln("copy construction for subresource failed\n");
}
ResourceBundle *p;
p = defaultresource.clone();
if(p == &defaultresource || !equalRB(*p, defaultresource)) {
errln("ResourceBundle.clone() failed");
}
delete p;
p = defaultSub.clone();
if(p == &defaultSub || !equalRB(*p, defaultSub)) {
errln("2nd ResourceBundle.clone() failed");
}
delete p;
UVersionInfo ver;
copyRes.getVersion(ver);
logln("Version returned: [%d.%d.%d.%d]\n", ver[0], ver[1], ver[2], ver[3]);
logln("Testing C like UnicodeString APIs\n");
UResourceBundle *testCAPI = NULL, *bundle = NULL, *rowbundle = NULL, *temp = NULL;
err = U_ZERO_ERROR;
const char* data[]={
"string_in_Root_te_te_IN", "1",
"array_in_Root_te_te_IN", "5",
"array_2d_in_Root_te_te_IN", "4",
};
testCAPI = ures_open(testdatapath, "te_IN", &err);
if(U_SUCCESS(err)) {
// Do the testing
// first iteration
uint32_t i;
int32_t count, row=0, col=0;
char buf[5];
UnicodeString expected;
UnicodeString element("TE_IN");
UnicodeString action;
for(i=0; i<UPRV_LENGTHOF(data); i=i+2){
action = "te_IN";
action +=".get(";
action += data[i];
action +=", err)";
err=U_ZERO_ERROR;
bundle = ures_getByKey(testCAPI, data[i], bundle, &err);
if(!U_FAILURE(err)){
const char* key = NULL;
action = "te_IN";
action +=".getKey()";
CONFIRM_EQ((UnicodeString)ures_getKey(bundle), (UnicodeString)data[i]);
count=0;
row=0;
while(ures_hasNext(bundle)){
action = data[i];
action +=".getNextString(err)";
row=count;
UnicodeString got=ures_getNextUnicodeString(bundle, &key, &err);
if(U_SUCCESS(err)){
expected=element;
if(ures_getSize(bundle) > 1){
CONFIRM_EQ(ures_getType(bundle), URES_ARRAY);
expected+=itoa(row, buf);
rowbundle=ures_getByIndex(bundle, row, rowbundle, &err);
if(!U_FAILURE(err) && ures_getSize(rowbundle)>1){
col=0;
while(ures_hasNext(rowbundle)){
expected=element;
got=ures_getNextUnicodeString(rowbundle, &key, &err);
temp = ures_getByIndex(rowbundle, col, temp, &err);
UnicodeString bla = ures_getUnicodeString(temp, &err);
UnicodeString bla2 = ures_getUnicodeStringByIndex(rowbundle, col, &err);
if(!U_FAILURE(err)){
expected+=itoa(row, buf);
expected+=itoa(col, buf);
col++;
CONFIRM_EQ(got, expected);
CONFIRM_EQ(bla, expected);
CONFIRM_EQ(bla2, expected);
}
}
CONFIRM_EQ(col, ures_getSize(rowbundle));
}
}
else{
CONFIRM_EQ(ures_getType(bundle), (int32_t)URES_STRING);
}
}
CONFIRM_EQ(got, expected);
count++;
}
}
}
// Check that ures_getUnicodeString() & variants return a bogus string if failure.
// Same relevant code path whether the failure code is passed in
// or comes from a lookup error.
UErrorCode failure = U_INTERNAL_PROGRAM_ERROR;
assertTrue("ures_getUnicodeString(failure).isBogus()",
ures_getUnicodeString(testCAPI, &failure).isBogus());
assertTrue("ures_getNextUnicodeString(failure).isBogus()",
ures_getNextUnicodeString(testCAPI, NULL, &failure).isBogus());
assertTrue("ures_getUnicodeStringByIndex(failure).isBogus()",
ures_getUnicodeStringByIndex(testCAPI, 999, &failure).isBogus());
assertTrue("ures_getUnicodeStringByKey(failure).isBogus()",
ures_getUnicodeStringByKey(testCAPI, "bogus key", &failure).isBogus());
ures_close(temp);
ures_close(rowbundle);
ures_close(bundle);
ures_close(testCAPI);
} else {
errln("failed to open a resource bundle\n");
}
/* Restore the default locale for the other tests. */
Locale::setDefault(originalDefault, err);
}
static void printOutBundle(FILE *out, UConverter *converter, UResourceBundle *resource, int32_t indent, const char *pname, UErrorCode *status)
{
static const UChar cr[] = { '\n' };
/* int32_t noOfElements = ures_getSize(resource);*/
int32_t i = 0;
const char *key = ures_getKey(resource);
switch(ures_getType(resource)) {
case RES_STRING :
{
int32_t len=0;
const UChar* thestr = ures_getString(resource, &len, status);
UChar *string = quotedString(thestr);
/* TODO: String truncation */
if(trunc && len > truncsize) {
char msg[128];
printIndent(out, converter, indent);
sprintf(msg, "// WARNING: this resource, size %li is truncated to %li\n",
(long)len, (long)(truncsize/2));
printCString(out, converter, msg, -1);
len = truncsize/2;
}
printIndent(out, converter, indent);
if(key != NULL) {
static const UChar openStr[] = { 0x0020, 0x007B, 0x0020, 0x0022 }; /* " { \"" */
static const UChar closeStr[] = { 0x0022, 0x0020, 0x007D }; /* "\" }" */
printCString(out, converter, key, (int32_t)uprv_strlen(key));
printString(out, converter, openStr, (int32_t)(sizeof(openStr)/sizeof(*openStr)));
printString(out, converter, string, len);
printString(out, converter, closeStr, (int32_t)(sizeof(closeStr) / sizeof(*closeStr)));
} else {
static const UChar openStr[] = { 0x0022 }; /* "\"" */
static const UChar closeStr[] = { 0x0022, 0x002C }; /* "\"," */
printString(out, converter, openStr, (int32_t)(sizeof(openStr) / sizeof(*openStr)));
printString(out, converter, string, (int32_t)(u_strlen(string)));
printString(out, converter, closeStr, (int32_t)(sizeof(closeStr) / sizeof(*closeStr)));
}
if(verbose) {
printCString(out, converter, "// STRING", -1);
}
printString(out, converter, cr, (int32_t)(sizeof(cr) / sizeof(*cr)));
uprv_free(string);
}
break;
case RES_INT :
{
static const UChar openStr[] = { 0x003A, 0x0069, 0x006E, 0x0074, 0x0020, 0x007B, 0x0020 }; /* ":int { " */
static const UChar closeStr[] = { 0x0020, 0x007D }; /* " }" */
UChar num[20];
printIndent(out, converter, indent);
if(key != NULL) {
printCString(out, converter, key, -1);
}
printString(out, converter, openStr, (int32_t)(sizeof(openStr) / sizeof(*openStr)));
uprv_itou(num, 20, ures_getInt(resource, status), 10, 0);
printString(out, converter, num, u_strlen(num));
printString(out, converter, closeStr, (int32_t)(sizeof(closeStr) / sizeof(*closeStr)));
if(verbose) {
printCString(out, converter, "// INT", -1);
}
printString(out, converter, cr, (int32_t)(sizeof(cr) / sizeof(*cr)));
break;
}
case RES_BINARY :
{
int32_t len = 0;
const int8_t *data = (const int8_t *)ures_getBinary(resource, &len, status);
if(trunc && len > truncsize) {
char msg[128];
printIndent(out, converter, indent);
sprintf(msg, "// WARNING: this resource, size %li is truncated to %li\n",
(long)len, (long)(truncsize/2));
printCString(out, converter, msg, -1);
len = truncsize;
}
if(U_SUCCESS(*status)) {
static const UChar openStr[] = { 0x003A, 0x0062, 0x0069, 0x006E, 0x0061, 0x0072, 0x0079, 0x0020, 0x007B, 0x0020 }; /* ":binary { " */
static const UChar closeStr[] = { 0x0020, 0x007D, 0x0020 }; /* " } " */
printIndent(out, converter, indent);
if(key != NULL) {
printCString(out, converter, key, -1);
}
printString(out, converter, openStr, (int32_t)(sizeof(openStr) / sizeof(*openStr)));
for(i = 0; i<len; i++) {
printHex(out, converter, *data++);
}
printString(out, converter, closeStr, (int32_t)(sizeof(closeStr) / sizeof(*closeStr)));
if(verbose) {
printCString(out, converter, " // BINARY", -1);
}
printString(out, converter, cr, (int32_t)(sizeof(cr) / sizeof(*cr)));
} else {
reportError(pname, status, "getting binary value");
}
}
break;
case RES_INT_VECTOR :
{
int32_t len = 0;
const int32_t *data = ures_getIntVector(resource, &len, status);
if(U_SUCCESS(*status)) {
static const UChar openStr[] = { 0x003A, 0x0069, 0x006E, 0x0074, 0x0076, 0x0065, 0x0063, 0x0074, 0x006F, 0x0072, 0x0020, 0x007B, 0x0020 }; /* ":intvector { " */
static const UChar closeStr[] = { 0x0020, 0x007D, 0x0020 }; /* " } " */
UChar num[20];
printIndent(out, converter, indent);
if(key != NULL) {
printCString(out, converter, key, -1);
}
printString(out, converter, openStr, (int32_t)(sizeof(openStr) / sizeof(*openStr)));
for(i = 0; i < len - 1; i++) {
int32_t numLen = uprv_itou(num, 20, data[i], 10, 0);
num[numLen++] = 0x002C; /* ',' */
num[numLen++] = 0x0020; /* ' ' */
num[numLen] = 0;
printString(out, converter, num, u_strlen(num));
}
if(len > 0) {
uprv_itou(num, 20, data[len - 1], 10, 0);
printString(out, converter, num, u_strlen(num));
}
printString(out, converter, closeStr, (int32_t)(sizeof(closeStr) / sizeof(*closeStr)));
if(verbose) {
printCString(out, converter, "// INTVECTOR", -1);
}
printString(out, converter, cr, (int32_t)(sizeof(cr) / sizeof(*cr)));
} else {
reportError(pname, status, "getting int vector");
}
}
break;
case RES_TABLE :
case RES_ARRAY :
{
static const UChar openStr[] = { 0x007B }; /* "{" */
static const UChar closeStr[] = { 0x007D, '\n' }; /* "}\n" */
UResourceBundle *t = NULL;
ures_resetIterator(resource);
printIndent(out, converter, indent);
if(key != NULL) {
printCString(out, converter, key, -1);
}
printString(out, converter, openStr, (int32_t)(sizeof(openStr) / sizeof(*openStr)));
if(verbose) {
if(ures_getType(resource) == RES_TABLE) {
printCString(out, converter, "// TABLE", -1);
} else {
printCString(out, converter, "// ARRAY", -1);
}
}
printString(out, converter, cr, (int32_t)(sizeof(cr) / sizeof(*cr)));
if(suppressAliases == FALSE) {
while(U_SUCCESS(*status) && ures_hasNext(resource)) {
t = ures_getNextResource(resource, t, status);
if(U_SUCCESS(*status)) {
printOutBundle(out, converter, t, indent+indentsize, pname, status);
} else {
reportError(pname, status, "While processing table");
*status = U_ZERO_ERROR;
}
}
} else { /* we have to use low level access to do this */
Resource r = RES_BOGUS;
for(i = 0; i < ures_getSize(resource); i++) {
/* need to know if it's an alias */
if(ures_getType(resource) == RES_TABLE) {
r = derb_getTableItem(resource->fResData.pRoot, resource->fRes, (int16_t)i);
key = derb_getTableKey(resource->fResData.pRoot, resource->fRes, (int16_t)i);
} else {
r = derb_getArrayItem(resource->fResData.pRoot, resource->fRes, i);
}
if(U_SUCCESS(*status)) {
if(RES_GET_TYPE(r) == RES_ALIAS) {
printOutAlias(out, converter, resource, r, key, indent+indentsize, pname, status);
} else {
t = ures_getByIndex(resource, i, t, status);
printOutBundle(out, converter, t, indent+indentsize, pname, status);
}
} else {
reportError(pname, status, "While processing table");
*status = U_ZERO_ERROR;
}
}
}
printIndent(out, converter, indent);
printString(out, converter, closeStr, (int32_t)(sizeof(closeStr) / sizeof(*closeStr)));
ures_close(t);
}
break;
default:
break;
}
}
U_CAPI int32_t U_EXPORT2
ualoc_getLanguagesForRegion(const char *regionID, double minimumFraction,
UALanguageEntry *entries, int32_t entriesCapacity,
UErrorCode *err)
{
if (U_FAILURE(*err)) {
return 0;
}
if ( regionID == NULL || minimumFraction < 0.0 || minimumFraction > 1.0 ||
((entries==NULL)? entriesCapacity!=0: entriesCapacity<0) ) {
*err = U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
UResourceBundle *rb = ures_openDirect(NULL, "supplementalData", err);
rb = ures_getByKey(rb, "territoryInfo", rb, err);
rb = ures_getByKey(rb, regionID, rb, err);
if (U_FAILURE(*err)) {
ures_close(rb);
return 0;
}
int32_t entryCount = 0;
UResourceBundle *langBund = NULL;
int32_t lbIdx, lbCount = ures_getSize(rb);
UALanguageEntry localLangEntries[kLocalLangEntriesMax];
UALanguageEntry * langEntries = localLangEntries;
int32_t langEntriesMax = kLocalLangEntriesMax;
for (lbIdx = 0; lbIdx < lbCount; lbIdx++) {
langBund = ures_getByIndex(rb, lbIdx, langBund, err);
if (U_FAILURE(*err)) {
break;
}
const char * langCode = ures_getKey(langBund);
if (uprv_strcmp(langCode,"territoryF") == 0) {
continue;
}
if (strnlen(langCode, UALANGDATA_CODELEN+1) > UALANGDATA_CODELEN) { // no uprv_strnlen
continue; // a code we cannot handle
}
UErrorCode localErr = U_ZERO_ERROR;
double userFraction = 0.0;
UResourceBundle *itemBund = ures_getByKey(langBund, "populationShareF", NULL, &localErr);
if (U_SUCCESS(localErr)) {
int32_t intF = ures_getInt(itemBund, &localErr);
if (U_SUCCESS(localErr)) {
userFraction = doubleFromIntF(intF);
}
ures_close(itemBund);
}
if (userFraction < minimumFraction) {
continue;
}
if (entries != NULL) {
localErr = U_ZERO_ERROR;
UALanguageStatus langStatus = UALANGSTATUS_UNSPECIFIED;
int32_t ulen;
const UChar * ustrLangStatus = ures_getStringByKey(langBund, "officialStatus", &ulen, &localErr);
if (U_SUCCESS(localErr)) {
int32_t cmp = u_strcmp(ustrLangStatus, ustrLangStatusOfficial);
if (cmp == 0) {
langStatus = UALANGSTATUS_OFFICIAL;
} else if (cmp < 0 && u_strcmp(ustrLangStatus, ustrLangStatusDefacto) == 0) {
langStatus = UALANGSTATUS_DEFACTO_OFFICIAL;
} else if (u_strcmp(ustrLangStatus, ustrLangStatusRegional) == 0) {
langStatus = UALANGSTATUS_REGIONAL_OFFICIAL;
}
}
// Now we have all of the info for our next entry
if (entryCount >= langEntriesMax) {
int32_t newMax = langEntriesMax * kLangEntriesFactor;
if (langEntries == localLangEntries) {
// first allocation, copy from local buf
langEntries = (UALanguageEntry*)uprv_malloc(newMax*sizeof(UALanguageEntry));
if (langEntries == NULL) {
*err = U_MEMORY_ALLOCATION_ERROR;
break;
}
uprv_memcpy(langEntries, localLangEntries, entryCount*sizeof(UALanguageEntry));
} else {
langEntries = (UALanguageEntry*)uprv_realloc(langEntries, newMax*sizeof(UALanguageEntry));
if (langEntries == NULL) {
*err = U_MEMORY_ALLOCATION_ERROR;
break;
}
}
langEntriesMax = newMax;
}
uprv_strcpy(langEntries[entryCount].languageCode, langCode);
langEntries[entryCount].userFraction = userFraction;
langEntries[entryCount].status = langStatus;
}
entryCount++;
}
ures_close(langBund);
ures_close(rb);
if (U_FAILURE(*err)) {
if (langEntries != localLangEntries) {
free(langEntries);
}
return 0;
}
if (entries != NULL) {
// sort langEntries, copy entries that fit to provided array
qsort(langEntries, entryCount, sizeof(UALanguageEntry), compareLangEntries);
if (entryCount > entriesCapacity) {
entryCount = entriesCapacity;
}
uprv_memcpy(entries, langEntries, entryCount*sizeof(UALanguageEntry));
if (langEntries != localLangEntries) {
free(langEntries);
}
}
return entryCount;
}