NumberingSystem* U_EXPORT2 NumberingSystem::createInstanceByName(const char *name, UErrorCode& status) { UResourceBundle *numberingSystemsInfo = NULL; UResourceBundle *nsTop, *nsCurrent; int32_t radix = 10; int32_t algorithmic = 0; numberingSystemsInfo = ures_openDirect(NULL,gNumberingSystems, &status); nsCurrent = ures_getByKey(numberingSystemsInfo,gNumberingSystems,NULL,&status); nsTop = ures_getByKey(nsCurrent,name,NULL,&status); UnicodeString nsd = ures_getUnicodeStringByKey(nsTop,gDesc,&status); ures_getByKey(nsTop,gRadix,nsCurrent,&status); radix = ures_getInt(nsCurrent,&status); ures_getByKey(nsTop,gAlgorithmic,nsCurrent,&status); algorithmic = ures_getInt(nsCurrent,&status); UBool isAlgorithmic = ( algorithmic == 1 ); ures_close(nsCurrent); ures_close(nsTop); ures_close(numberingSystemsInfo); if (U_FAILURE(status)) { status = U_UNSUPPORTED_ERROR; return NULL; } NumberingSystem* ns = NumberingSystem::createInstance(radix,isAlgorithmic,nsd,status); ns->setName(name); return ns; }
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; }
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; }
/* {{{ ResourceBundle_extract_value */ void resourcebundle_extract_value( zval *return_value, ResourceBundle_object *source ) { UResType restype; const UChar* ufield; const uint8_t* bfield; const int32_t* vfield; int32_t ilen; int i; zend_long lfield; ResourceBundle_object* newrb; restype = ures_getType( source->child ); switch (restype) { case URES_STRING: ufield = ures_getString( source->child, &ilen, &INTL_DATA_ERROR_CODE(source) ); INTL_METHOD_CHECK_STATUS(source, "Failed to retrieve string value"); INTL_METHOD_RETVAL_UTF8(source, (UChar *)ufield, ilen, 0); break; case URES_BINARY: bfield = ures_getBinary( source->child, &ilen, &INTL_DATA_ERROR_CODE(source) ); INTL_METHOD_CHECK_STATUS(source, "Failed to retrieve binary value"); ZVAL_STRINGL( return_value, (char *) bfield, ilen ); break; case URES_INT: lfield = ures_getInt( source->child, &INTL_DATA_ERROR_CODE(source) ); INTL_METHOD_CHECK_STATUS(source, "Failed to retrieve integer value"); ZVAL_LONG( return_value, lfield ); break; case URES_INT_VECTOR: vfield = ures_getIntVector( source->child, &ilen, &INTL_DATA_ERROR_CODE(source) ); INTL_METHOD_CHECK_STATUS(source, "Failed to retrieve vector value"); array_init( return_value ); for (i=0; i<ilen; i++) { add_next_index_long( return_value, vfield[i] ); } break; case URES_ARRAY: case URES_TABLE: object_init_ex( return_value, ResourceBundle_ce_ptr ); newrb = Z_INTL_RESOURCEBUNDLE_P(return_value); newrb->me = source->child; source->child = NULL; intl_errors_reset(INTL_DATA_ERROR_P(source)); break; default: intl_errors_set(INTL_DATA_ERROR_P(source), U_ILLEGAL_ARGUMENT_ERROR, "Unknown resource type", 0); RETURN_FALSE; break; } }
U_CAPI UMeasurementSystem U_EXPORT2 ulocdata_getMeasurementSystem(const char *localeID, UErrorCode *status){ UResourceBundle* measurement=NULL; UMeasurementSystem system = UMS_LIMIT; if(status == NULL || U_FAILURE(*status)){ return system; } measurement = measurementTypeBundleForLocale(localeID, MEASUREMENT_SYSTEM, status); system = (UMeasurementSystem) ures_getInt(measurement, status); ures_close(measurement); return system; }
U_CAPI UMeasurementSystem U_EXPORT2 ulocdata_getMeasurementSystem(const char *localeID, UErrorCode *status){ UResourceBundle* bundle=NULL; UResourceBundle* measurement=NULL; UMeasurementSystem system = UMS_LIMIT; if(status == NULL || U_FAILURE(*status)){ return system; } bundle = measurementDataBundleForLocale(localeID, status); measurement = ures_getByKeyWithFallback(bundle, MEASUREMENT_SYSTEM, NULL, status); system = (UMeasurementSystem) ures_getInt(measurement, status); ures_close(bundle); ures_close(measurement); return system; }
UnicodeString& TimeZone::dereferOlsonLink(const UnicodeString& linkTo, UnicodeString& linkFrom) { UErrorCode ec = U_ZERO_ERROR; linkFrom.remove(); UResourceBundle *top = ures_openDirect(0, kZONEINFO, &ec); UResourceBundle *res = getZoneByName(top, linkTo, NULL, ec); if (U_SUCCESS(ec)) { if (ures_getSize(res) == 1) { int32_t deref = ures_getInt(res, &ec); UResourceBundle *nres = ures_getByKey(top, kNAMES, NULL, &ec); // dereference Names section int32_t len; const UChar* tmp = ures_getStringByIndex(nres, deref, &len, &ec); if (U_SUCCESS(ec)) { linkFrom.setTo(tmp, len); } ures_close(nres); } else { linkFrom.setTo(linkTo); } } ures_close(res); ures_close(top); return linkFrom; }
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; } }
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 printOutBundle(UFILE *out, UResourceBundle *resource, int32_t indent, UErrorCode *status) { int32_t i = 0; const char *key = ures_getKey(resource); switch(ures_getType(resource)) { case URES_STRING : { int32_t len=0; const UChar*thestr = ures_getString(resource, &len, status); UChar *string = quotedString(thestr); /* TODO: String truncation */ /* if(trunc && len > truncsize) { printIndent(out, indent); u_fprintf(out, "// WARNING: this string, size %d is truncated to %d\n", len, truncsize/2); len = truncsize/2; } */ printIndent(out, indent); if(key != NULL) { u_fprintf(out, "%s { \"%S\" } ", key, string); } else { u_fprintf(out, "\"%S\",", string); } if(VERBOSE) { u_fprintf(out, " // STRING"); } u_fprintf(out, "\n"); free(string); } break; case URES_INT : printIndent(out, indent); if(key != NULL) { u_fprintf(out, "%s", key); } u_fprintf(out, ":int { %li } ", ures_getInt(resource, status)); if(VERBOSE) { u_fprintf(out, " // INT"); } u_fprintf(out, "\n"); break; case URES_BINARY : { int32_t len = 0; const int8_t *data = (const int8_t *)ures_getBinary(resource, &len, status); if(trunc && len > truncsize) { printIndent(out, indent); u_fprintf(out, "// WARNING: this resource, size %li is truncated to %li\n", len, truncsize/2); len = truncsize/2; } if(U_SUCCESS(*status)) { printIndent(out, indent); if(key != NULL) { u_fprintf(out, "%s", key); } u_fprintf(out, ":binary { "); for(i = 0; i<len; i++) { printHex(out, data++); } u_fprintf(out, " }"); if(VERBOSE) { u_fprintf(out, " // BINARY"); } u_fprintf(out, "\n"); } else { reportError(status); } } break; case URES_INT_VECTOR : { int32_t len = 0; const int32_t *data = ures_getIntVector(resource, &len, status); if(U_SUCCESS(*status)) { printIndent(out, indent); if(key != NULL) { u_fprintf(out, "%s", key); } u_fprintf(out, ":intvector { "); for(i = 0; i<len-1; i++) { u_fprintf(out, "%d, ", data[i]); } if(len > 0) { u_fprintf(out, "%d ", data[len-1]); } u_fprintf(out, "}"); if(VERBOSE) { u_fprintf(out, " // INTVECTOR"); } u_fprintf(out, "\n"); } else { reportError(status); } } break; case URES_TABLE : case URES_ARRAY : { UResourceBundle *t = NULL; ures_resetIterator(resource); printIndent(out, indent); if(key != NULL) { u_fprintf(out, "%s ", key); } u_fprintf(out, "{"); if(VERBOSE) { if(ures_getType(resource) == URES_TABLE) { u_fprintf(out, " // TABLE"); } else { u_fprintf(out, " // ARRAY"); } } u_fprintf(out, "\n"); while(ures_hasNext(resource)) { t = ures_getNextResource(resource, t, status); printOutBundle(out, t, indent+indentsize, status); } printIndent(out, indent); u_fprintf(out, "}\n"); ures_close(t); } break; default: break; } }
int32_t ResourceBundle::getInt(UErrorCode& status) const { return ures_getInt(fResource, &status); }
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 }
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; }