U_CAPI void U_EXPORT2
ulocdata_getPaperSize(const char* localeID, int32_t *height, int32_t *width, UErrorCode *status){
UResourceBundle* bundle=NULL;
UResourceBundle* paperSizeBundle = NULL;
const int32_t* paperSize=NULL;
int32_t len = 0;
if(status == NULL || U_FAILURE(*status)){
return;
}
bundle = ures_open(NULL, localeID, status);
paperSizeBundle = ures_getByKey(bundle, PAPER_SIZE, NULL, status);
paperSize = ures_getIntVector(paperSizeBundle, &len, status);
if(U_SUCCESS(*status)){
if(len < 2){
*status = U_INTERNAL_PROGRAM_ERROR;
}else{
*height = paperSize[0];
*width = paperSize[1];
}
}
ures_close(bundle);
ures_close(paperSizeBundle);
}
U_CAPI ULocaleData* U_EXPORT2
ulocdata_open(const char *localeID, UErrorCode *status)
{
ULocaleData *uld;
if (U_FAILURE(*status)) {
return NULL;
}
uld = (ULocaleData *)uprv_malloc(sizeof(ULocaleData));
if (uld == NULL) {
*status = U_MEMORY_ALLOCATION_ERROR;
return(NULL);
}
uld->noSubstitute = FALSE;
uld->bundle = ures_open(NULL, localeID, status);
if (U_FAILURE(*status)) {
uprv_free(uld);
return NULL;
}
return uld;
}
static jstring ICU_getCurrencySymbolNative(JNIEnv* env, jclass, jstring locale, jstring currencyCode) {
ScopedUtfChars localeName(env, locale);
UErrorCode status = U_ZERO_ERROR;
ScopedResourceBundle currLoc(ures_open(U_ICUDATA_CURR, localeName.c_str(), &status));
if (U_FAILURE(status)) {
return NULL;
}
ScopedResourceBundle currencies(ures_getByKey(currLoc.get(), "Currencies", NULL, &status));
if (U_FAILURE(status)) {
return NULL;
}
ScopedUtfChars currency(env, currencyCode);
ScopedResourceBundle currencyElems(ures_getByKey(currencies.get(), currency.c_str(), NULL, &status));
if (U_FAILURE(status)) {
return NULL;
}
int currSymbL;
const jchar* currSymbU = ures_getStringByIndex(currencyElems.get(), 0, &currSymbL, &status);
if (U_FAILURE(status)) {
return NULL;
}
return (currSymbL == 0) ? NULL : env->NewString(currSymbU, currSymbL);
}
void CalendarData::initData(const char *locale, const char *type, UErrorCode& status) {
fOtherFillin = ures_open(U_CALENDAR_DATA, locale, &status);
fFillin = ures_getByKey(fOtherFillin, U_CALENDAR_KEY, fFillin, &status);
if((type != NULL) &&
(*type != '\0') &&
(uprv_strcmp(type, U_GREGORIAN_KEY)))
{
fBundle = ures_getByKeyWithFallback(fFillin, type, NULL, &status);
fFallback = ures_getByKeyWithFallback(fFillin, U_GREGORIAN_KEY, NULL, &status);
#if defined (U_DEBUG_CALDATA)
fprintf(stderr, "%p: CalendarData(%s, %s, %s) -> main(%p, %s)=%s, fallback(%p, %s)=%s\n",
this, locale, type, u_errorName(status), fBundle, type, fBundle?ures_getLocale(fBundle, &status):"",
fFallback, U_GREGORIAN_KEY, fFallback?ures_getLocale(fFallback, &status):"");
#endif
} else {
fBundle = ures_getByKeyWithFallback(fFillin, U_GREGORIAN_KEY, NULL, &status);
#if defined (U_DEBUG_CALDATA)
fprintf(stderr, "%p: CalendarData(%s, %s, %s) -> main(%p, %s)=%s, fallback = NULL\n",
this, locale, type, u_errorName(status), fBundle, U_GREGORIAN_KEY, fBundle?ures_getLocale(fBundle, &status):"" );
#endif
}
}
static ListFormatInternal* loadListFormatInternal(
const Locale& locale, const char * style, UErrorCode& errorCode) {
UResourceBundle* rb = ures_open(NULL, locale.getName(), &errorCode);
if (U_FAILURE(errorCode)) {
ures_close(rb);
return NULL;
}
rb = ures_getByKeyWithFallback(rb, "listPattern", rb, &errorCode);
rb = ures_getByKeyWithFallback(rb, style, rb, &errorCode);
if (U_FAILURE(errorCode)) {
ures_close(rb);
return NULL;
}
UnicodeString two, start, middle, end;
getStringByKey(rb, "2", two, errorCode);
getStringByKey(rb, "start", start, errorCode);
getStringByKey(rb, "middle", middle, errorCode);
getStringByKey(rb, "end", end, errorCode);
ures_close(rb);
if (U_FAILURE(errorCode)) {
return NULL;
}
ListFormatInternal* result = new ListFormatInternal(two, start, middle, end, errorCode);
if (result == NULL) {
errorCode = U_MEMORY_ALLOCATION_ERROR;
return NULL;
}
if (U_FAILURE(errorCode)) {
delete result;
return NULL;
}
return result;
}
void
ResourceBundleTest::TestExemplar(){
int32_t locCount = uloc_countAvailable();
int32_t locIndex=0;
int num=0;
UErrorCode status = U_ZERO_ERROR;
for(;locIndex<locCount;locIndex++){
const char* locale = uloc_getAvailable(locIndex);
UResourceBundle *resb =ures_open(NULL,locale,&status);
if(U_SUCCESS(status) && status!=U_USING_FALLBACK_WARNING && status!=U_USING_DEFAULT_WARNING){
int32_t len=0;
const UChar* strSet = ures_getStringByKey(resb,"ExemplarCharacters",&len,&status);
UnicodeSet set(strSet,status);
if(U_FAILURE(status)){
errln("Could not construct UnicodeSet from pattern for ExemplarCharacters in locale : %s. Error: %s",locale,u_errorName(status));
status=U_ZERO_ERROR;
}
num++;
}
ures_close(resb);
}
logln("Number of installed locales with exemplar characters that could be tested: %d",num);
}
static bool getYesterdayTodayAndTomorrow(JNIEnv* env, jobject localeData, const char* locale_name) {
UErrorCode status = U_ZERO_ERROR;
ScopedResourceBundle root(ures_open(NULL, locale_name, &status));
if (U_FAILURE(status)) {
return false;
}
ScopedResourceBundle fields(ures_getByKey(root.get(), "fields", NULL, &status));
if (U_FAILURE(status)) {
return false;
}
ScopedResourceBundle day(ures_getByKey(fields.get(), "day", NULL, &status));
if (U_FAILURE(status)) {
return false;
}
ScopedResourceBundle relative(ures_getByKey(day.get(), "relative", NULL, &status));
if (U_FAILURE(status)) {
return false;
}
// bn_BD only has a "-2" entry.
if (relative.hasKey("-1") && relative.hasKey("0") && relative.hasKey("1")) {
setStringField(env, localeData, "yesterday", relative.get(), "-1");
setStringField(env, localeData, "today", relative.get(), "0");
setStringField(env, localeData, "tomorrow", relative.get(), "1");
return true;
}
return false;
}
NumberingSystem* U_EXPORT2
NumberingSystem::createInstance(const Locale & inLocale, UErrorCode& status) {
char buffer[ULOC_KEYWORDS_CAPACITY];
int32_t count = inLocale.getKeywordValue("numbers",buffer, sizeof(buffer),status);
if ( count > 0 ) { // @numbers keyword was specified in the locale
buffer[count] = '\0'; // Make sure it is null terminated.
return NumberingSystem::createInstanceByName(buffer,status);
} else { // Find the default numbering system for this locale.
LocalUResourceBundlePointer resource(ures_open(NULL, inLocale.getName(), &status));
if (U_FAILURE(status)) {
status = U_USING_FALLBACK_WARNING;
NumberingSystem *ns = new NumberingSystem();
return ns;
}
const UChar *defaultNSName =
ures_getStringByKeyWithFallback(resource.getAlias(), gDefaultNumberingSystem, &count, &status);
if (U_FAILURE(status)) {
return NULL;
}
if ( count > 0 && count < ULOC_KEYWORDS_CAPACITY ) { // Default numbering system found
u_UCharsToChars(defaultNSName,buffer,count);
buffer[count] = '\0'; // Make sure it is null terminated.
return NumberingSystem::createInstanceByName(buffer,status);
} else {
status = U_USING_FALLBACK_WARNING;
NumberingSystem *ns = new NumberingSystem();
return ns;
}
}
}
U_CAPI const UChar* U_EXPORT2
ucurr_forLocale(const char* locale, UErrorCode* ec) {
if (ec != NULL && U_SUCCESS(*ec)) {
char id[ULOC_FULLNAME_CAPACITY];
idForLocale(locale, id, sizeof(id), ec);
if (U_FAILURE(*ec)) {
return NULL;
}
const UChar* result = CReg::get(id);
if (result) {
return result;
}
// Look up the CurrencyMap element in the root bundle.
UResourceBundle* rb = ures_open(NULL, "", ec);
UResourceBundle* cm = ures_getByKey(rb, CURRENCY_MAP, NULL, ec);
int32_t len;
const UChar* s = ures_getStringByKey(cm, id, &len, ec);
ures_close(cm);
ures_close(rb);
if (U_SUCCESS(*ec)) {
return s;
}
}
return NULL;
}
static bool getYesterdayTodayAndTomorrow(JNIEnv* env, jobject localeData, const Locale& locale, const char* locale_name) {
UErrorCode status = U_ZERO_ERROR;
ScopedResourceBundle root(ures_open(NULL, locale_name, &status));
ScopedResourceBundle fields(ures_getByKey(root.get(), "fields", NULL, &status));
ScopedResourceBundle day(ures_getByKey(fields.get(), "day", NULL, &status));
ScopedResourceBundle relative(ures_getByKey(day.get(), "relative", NULL, &status));
if (U_FAILURE(status)) {
return false;
}
UnicodeString yesterday(ures_getUnicodeStringByKey(relative.get(), "-1", &status));
UnicodeString today(ures_getUnicodeStringByKey(relative.get(), "0", &status));
UnicodeString tomorrow(ures_getUnicodeStringByKey(relative.get(), "1", &status));
if (U_FAILURE(status)) {
ALOGE("Error getting yesterday/today/tomorrow for %s: %s", locale_name, u_errorName(status));
return false;
}
// We title-case the strings so they have consistent capitalization (http://b/14493853).
UniquePtr<BreakIterator> brk(BreakIterator::createSentenceInstance(locale, status));
if (U_FAILURE(status)) {
ALOGE("Error getting yesterday/today/tomorrow break iterator for %s: %s", locale_name, u_errorName(status));
return false;
}
yesterday.toTitle(brk.get(), locale, U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT);
today.toTitle(brk.get(), locale, U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT);
tomorrow.toTitle(brk.get(), locale, U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT);
setStringField(env, localeData, "yesterday", yesterday);
setStringField(env, localeData, "today", today);
setStringField(env, localeData, "tomorrow", tomorrow);
return true;
}
virtual UObject* create(const ICUServiceKey& key, const ICUService* /*service*/, UErrorCode& status) const {
LocaleKey &lkey = (LocaleKey&)key;
Locale loc;
lkey.currentLocale(loc);
#ifdef U_DEBUG_CALSVC
fprintf(stderr, "DefaultCalendar factory %p: looking up %s\n",
this, (const char*)loc.getName());
#endif
UErrorCode resStatus = U_ZERO_ERROR;
UResourceBundle *rb = ures_open(NULL, (const char*)loc.getName(), &resStatus);
#ifdef U_DEBUG_CALSVC
fprintf(stderr, "... ures_open -> %s\n", u_errorName(resStatus));
#endif
if(U_FAILURE(resStatus) ||
(resStatus == U_USING_DEFAULT_WARNING) || (resStatus==U_USING_FALLBACK_WARNING)) { //Don't want to handle fallback data.
ures_close(rb);
status = resStatus; // propagate err back to caller
#ifdef U_DEBUG_CALSVC
fprintf(stderr, "... exitting (NULL)\n");
#endif
return NULL;
}
int32_t len = 0;
UnicodeString myString = ures_getUnicodeStringByKey(rb, Calendar::kDefaultCalendar, &status);
#ifdef U_DEBUG_CALSVC
UErrorCode debugStatus = U_ZERO_ERROR;
const UChar *defCal = ures_getStringByKey(rb, Calendar::kDefaultCalendar, &len, &debugStatus);
fprintf(stderr, "... get string(%d) -> %s\n", len, u_errorName(debugStatus));
#endif
ures_close(rb);
if(U_FAILURE(status)) {
return NULL;
}
#ifdef U_DEBUG_CALSVC
{
char defCalStr[200];
if(len > 199) {
len = 199;
}
u_UCharsToChars(defCal, defCalStr, len);
defCalStr[len]=0;
fprintf(stderr, "DefaultCalendarFactory: looked up %s, got DefaultCalendar= %s\n", (const char*)loc.getName(), defCalStr);
}
#endif
return myString.clone();
}
U_CFUNC UResourceBundle *u_wmsg_setPath(const char *path, UErrorCode *err)
{
if(U_FAILURE(*err))
{
return 0;
}
if(gBundle != NULL)
{
*err = U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
else
{
UResourceBundle *b = NULL;
b = ures_open(path, NULL, err);
if(U_FAILURE(*err))
{
return 0;
}
gBundle = b;
U_STRING_INIT(gNoFormatting, " (UCONFIG_NO_FORMATTING see uconfig.h)", 38);
}
return gBundle;
}
static jstring ICU_getCurrencySymbol(JNIEnv* env, jclass, jstring locale, jstring currencyCode) {
// We can't use ucurr_getName because it doesn't distinguish between using data root from
// the root locale and parroting back the input because it's never heard of the currency code.
ScopedUtfChars localeName(env, locale);
UErrorCode status = U_ZERO_ERROR;
ScopedResourceBundle currLoc(ures_open(U_ICUDATA_CURR, localeName.c_str(), &status));
if (U_FAILURE(status)) {
return NULL;
}
ScopedResourceBundle currencies(ures_getByKey(currLoc.get(), "Currencies", NULL, &status));
if (U_FAILURE(status)) {
return NULL;
}
ScopedUtfChars currency(env, currencyCode);
ScopedResourceBundle currencyElems(ures_getByKey(currencies.get(), currency.c_str(), NULL, &status));
if (U_FAILURE(status)) {
return NULL;
}
int32_t charCount;
const jchar* chars = ures_getStringByIndex(currencyElems.get(), 0, &charCount, &status);
if (U_FAILURE(status)) {
return NULL;
}
return (charCount == 0) ? NULL : env->NewString(chars, charCount);
}
static jstring getCurrencySymbolNative(JNIEnv* env, jclass clazz,
jstring locale, jstring currencyCode) {
// LOGI("ENTER getCurrencySymbolNative");
const char* locName = env->GetStringUTFChars(locale, NULL);
UErrorCode status = U_ZERO_ERROR;
ScopedResourceBundle root(ures_open(NULL, locName, &status));
env->ReleaseStringUTFChars(locale, locName);
if (U_FAILURE(status)) {
return NULL;
}
ScopedResourceBundle currencies(ures_getByKey(root.get(), "Currencies", NULL, &status));
if (U_FAILURE(status)) {
return NULL;
}
const char* currName = env->GetStringUTFChars(currencyCode, NULL);
ScopedResourceBundle currencyElems(ures_getByKey(currencies.get(), currName, NULL, &status));
env->ReleaseStringUTFChars(currencyCode, currName);
if (U_FAILURE(status)) {
return NULL;
}
int currSymbL;
const jchar* currSymbU = ures_getStringByIndex(currencyElems.get(), 0, &currSymbL, &status);
if (U_FAILURE(status)) {
return NULL;
}
return (currSymbL == 0) ? NULL : env->NewString(currSymbU, currSymbL);
}
static bool getDateTimePatterns(JNIEnv* env, jobject localeData, const char* locale_name) {
UErrorCode status = U_ZERO_ERROR;
ScopedResourceBundle root(ures_open(NULL, locale_name, &status));
if (U_FAILURE(status)) {
return false;
}
ScopedResourceBundle calendar(ures_getByKey(root.get(), "calendar", NULL, &status));
if (U_FAILURE(status)) {
return false;
}
ScopedResourceBundle gregorian(ures_getByKey(calendar.get(), "gregorian", NULL, &status));
if (U_FAILURE(status)) {
return false;
}
ScopedResourceBundle dateTimePatterns(ures_getByKey(gregorian.get(), "DateTimePatterns", NULL, &status));
if (U_FAILURE(status)) {
return false;
}
setStringField(env, localeData, "fullTimeFormat", dateTimePatterns.get(), 0);
setStringField(env, localeData, "longTimeFormat", dateTimePatterns.get(), 1);
setStringField(env, localeData, "mediumTimeFormat", dateTimePatterns.get(), 2);
setStringField(env, localeData, "shortTimeFormat", dateTimePatterns.get(), 3);
setStringField(env, localeData, "fullDateFormat", dateTimePatterns.get(), 4);
setStringField(env, localeData, "longDateFormat", dateTimePatterns.get(), 5);
setStringField(env, localeData, "mediumDateFormat", dateTimePatterns.get(), 6);
setStringField(env, localeData, "shortDateFormat", dateTimePatterns.get(), 7);
return true;
}
NumberingSystem* U_EXPORT2
NumberingSystem::createInstance(const Locale & inLocale, UErrorCode& status) {
if (U_FAILURE(status)) {
return NULL;
}
UBool nsResolved = TRUE;
UBool usingFallback = FALSE;
char buffer[ULOC_KEYWORDS_CAPACITY];
int32_t count = inLocale.getKeywordValue("numbers",buffer, sizeof(buffer),status);
if ( count > 0 ) { // @numbers keyword was specified in the locale
buffer[count] = '\0'; // Make sure it is null terminated.
if ( !uprv_strcmp(buffer,gDefault) || !uprv_strcmp(buffer,gNative) ||
!uprv_strcmp(buffer,gTraditional) || !uprv_strcmp(buffer,gFinance)) {
nsResolved = FALSE;
}
} else {
uprv_strcpy(buffer,gDefault);
nsResolved = FALSE;
}
if (!nsResolved) { // Resolve the numbering system ( default, native, traditional or finance ) into a "real" numbering system
UErrorCode localStatus = U_ZERO_ERROR;
UResourceBundle *resource = ures_open(NULL, inLocale.getName(), &localStatus);
UResourceBundle *numberElementsRes = ures_getByKey(resource,gNumberElements,NULL,&localStatus);
while (!nsResolved) {
localStatus = U_ZERO_ERROR;
count = 0;
const UChar *nsName = ures_getStringByKeyWithFallback(numberElementsRes, buffer, &count, &localStatus);
if ( count > 0 && count < ULOC_KEYWORDS_CAPACITY ) { // numbering system found
u_UCharsToChars(nsName,buffer,count);
buffer[count] = '\0'; // Make sure it is null terminated.
nsResolved = TRUE;
}
if (!nsResolved) { // Fallback behavior per TR35 - traditional falls back to native, finance and native fall back to default
if (!uprv_strcmp(buffer,gNative) || !uprv_strcmp(buffer,gFinance)) {
uprv_strcpy(buffer,gDefault);
} else if (!uprv_strcmp(buffer,gTraditional)) {
uprv_strcpy(buffer,gNative);
} else { // If we get here we couldn't find even the default numbering system
usingFallback = TRUE;
nsResolved = TRUE;
}
}
}
ures_close(numberElementsRes);
ures_close(resource);
}
if (usingFallback) {
status = U_USING_FALLBACK_WARNING;
NumberingSystem *ns = new NumberingSystem();
return ns;
} else {
return NumberingSystem::createInstanceByName(buffer,status);
}
}
/* {{{ ResourceBundle_ctor */
static int resourcebundle_ctor(INTERNAL_FUNCTION_PARAMETERS, zend_bool is_constructor)
{
const char *bundlename;
size_t bundlename_len = 0;
const char *locale;
size_t locale_len = 0;
zend_bool fallback = 1;
int zpp_flags = is_constructor ? ZEND_PARSE_PARAMS_THROW : 0;
zval *object = return_value;
ResourceBundle_object *rb = Z_INTL_RESOURCEBUNDLE_P( object );
intl_error_reset( NULL );
if( zend_parse_parameters_ex( zpp_flags, ZEND_NUM_ARGS(), "s!s!|b",
&locale, &locale_len, &bundlename, &bundlename_len, &fallback ) == FAILURE )
{
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
"resourcebundle_ctor: unable to parse input parameters", 0 );
return FAILURE;
}
INTL_CHECK_LOCALE_LEN_OR_FAILURE(locale_len);
if (locale == NULL) {
locale = intl_locale_get_default();
}
if (bundlename_len >= MAXPATHLEN) {
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "Bundle name too long", 0 );
zval_ptr_dtor(return_value);
ZVAL_NULL(return_value);
return FAILURE;
}
if (fallback) {
rb->me = ures_open(bundlename, locale, &INTL_DATA_ERROR_CODE(rb));
} else {
rb->me = ures_openDirect(bundlename, locale, &INTL_DATA_ERROR_CODE(rb));
}
INTL_CTOR_CHECK_STATUS(rb, "resourcebundle_ctor: Cannot load libICU resource bundle");
if (!fallback && (INTL_DATA_ERROR_CODE(rb) == U_USING_FALLBACK_WARNING ||
INTL_DATA_ERROR_CODE(rb) == U_USING_DEFAULT_WARNING)) {
char *pbuf;
intl_errors_set_code(NULL, INTL_DATA_ERROR_CODE(rb));
spprintf(&pbuf, 0, "resourcebundle_ctor: Cannot load libICU resource "
"'%s' without fallback from %s to %s",
bundlename ? bundlename : "(default data)", locale,
ures_getLocaleByType(
rb->me, ULOC_ACTUAL_LOCALE, &INTL_DATA_ERROR_CODE(rb)));
intl_errors_set_custom_msg(INTL_DATA_ERROR_P(rb), pbuf, 1);
efree(pbuf);
return FAILURE;
}
return SUCCESS;
}
// initCDFLocaleData initializes result with data from CLDR.
// inLocale is the locale, the CLDR data is stored in result.
// We load the UNUM_SHORT and UNUM_LONG data looking first in local numbering
// system and not including root locale in fallback. Next we try in the latn
// numbering system where we fallback all the way to root. If we don't find
// UNUM_SHORT data in these three places, we report an error. If we find
// UNUM_SHORT data before finding UNUM_LONG data we make UNUM_LONG data fall
// back to UNUM_SHORT data.
static void initCDFLocaleData(const Locale& inLocale, CDFLocaleData* result, UErrorCode& status) {
LocalPointer<NumberingSystem> ns(NumberingSystem::createInstance(inLocale, status));
if (U_FAILURE(status)) {
return;
}
const char* numberingSystemName = ns->getName();
UResourceBundle* rb = ures_open(NULL, inLocale.getName(), &status);
rb = ures_getByKeyWithFallback(rb, gNumberElementsTag, rb, &status);
if (U_FAILURE(status)) {
ures_close(rb);
return;
}
UResourceBundle* shortDataFillIn = NULL;
UResourceBundle* longDataFillIn = NULL;
UResourceBundle* shortData = NULL;
UResourceBundle* longData = NULL;
if (uprv_strcmp(numberingSystemName, gLatnTag) != 0) {
LocalUResourceBundlePointer localResource(
tryGetByKeyWithFallback(rb, numberingSystemName, NULL, NOT_ROOT, status));
shortData = tryGetDecimalFallback(
localResource.getAlias(), gPatternsShort, &shortDataFillIn, NOT_ROOT, status);
longData = tryGetDecimalFallback(
localResource.getAlias(), gPatternsLong, &longDataFillIn, NOT_ROOT, status);
}
if (U_FAILURE(status)) {
ures_close(shortDataFillIn);
ures_close(longDataFillIn);
ures_close(rb);
return;
}
// If we haven't found UNUM_SHORT look in latn numbering system. We must
// succeed at finding UNUM_SHORT here.
if (shortData == NULL) {
LocalUResourceBundlePointer latnResource(tryGetByKeyWithFallback(rb, gLatnTag, NULL, MUST, status));
shortData = tryGetDecimalFallback(latnResource.getAlias(), gPatternsShort, &shortDataFillIn, MUST, status);
if (longData == NULL) {
longData = tryGetDecimalFallback(latnResource.getAlias(), gPatternsLong, &longDataFillIn, ANY, status);
if (longData != NULL && isRoot(longData, status) && !isRoot(shortData, status)) {
longData = NULL;
}
}
}
initCDFLocaleStyleData(shortData, &result->shortData, status);
ures_close(shortDataFillIn);
if (U_FAILURE(status)) {
ures_close(longDataFillIn);
ures_close(rb);
}
if (longData == NULL) {
result->longData.setToBogus();
} else {
initCDFLocaleStyleData(longData, &result->longData, status);
}
ures_close(longDataFillIn);
ures_close(rb);
}
RuleBasedNumberFormat::RuleBasedNumberFormat(URBNFRuleSetTag tag, const Locale& alocale, UErrorCode& status)
: ruleSets(NULL)
, ruleSetDescriptions(NULL)
, numRuleSets(0)
, defaultRuleSet(NULL)
, locale(alocale)
, collator(NULL)
, decimalFormatSymbols(NULL)
, lenient(FALSE)
, lenientParseRules(NULL)
, localizations(NULL)
{
if (U_FAILURE(status)) {
return;
}
const char* rules_tag = "RBNFRules";
const char* fmt_tag = "";
switch (tag) {
case URBNF_SPELLOUT: fmt_tag = "SpelloutRules"; break;
case URBNF_ORDINAL: fmt_tag = "OrdinalRules"; break;
case URBNF_DURATION: fmt_tag = "DurationRules"; break;
case URBNF_NUMBERING_SYSTEM: fmt_tag = "NumberingSystemRules"; break;
default: status = U_ILLEGAL_ARGUMENT_ERROR; return;
}
// TODO: read localization info from resource
LocalizationInfo* locinfo = NULL;
UResourceBundle* nfrb = ures_open(U_ICUDATA_RBNF, locale.getName(), &status);
if (U_SUCCESS(status)) {
setLocaleIDs(ures_getLocaleByType(nfrb, ULOC_VALID_LOCALE, &status),
ures_getLocaleByType(nfrb, ULOC_ACTUAL_LOCALE, &status));
UResourceBundle* rbnfRules = ures_getByKeyWithFallback(nfrb, rules_tag, NULL, &status);
if (U_FAILURE(status)) {
ures_close(nfrb);
}
UResourceBundle* ruleSets = ures_getByKeyWithFallback(rbnfRules, fmt_tag, NULL, &status);
if (U_FAILURE(status)) {
ures_close(rbnfRules);
ures_close(nfrb);
return;
}
UnicodeString desc;
while (ures_hasNext(ruleSets)) {
desc.append(ures_getNextUnicodeString(ruleSets,NULL,&status));
}
UParseError perror;
init (desc, locinfo, perror, status);
ures_close(ruleSets);
ures_close(rbnfRules);
}
ures_close(nfrb);
}
static void load(const Locale& inLocale, CDFLocaleData* result, UErrorCode& status) {
LocalPointer<NumberingSystem> ns(NumberingSystem::createInstance(inLocale, status));
if (U_FAILURE(status)) {
return;
}
const char* nsName = ns->getName();
LocalUResourceBundlePointer resource(ures_open(NULL, inLocale.getName(), &status));
if (U_FAILURE(status)) {
return;
}
CmptDecDataSink sink(*result);
sink.isFallback = FALSE;
// First load the number elements data if nsName is not Latin.
if (uprv_strcmp(nsName, gLatnTag) != 0) {
sink.isLatin = FALSE;
CharString path;
path.append(gNumberElementsTag, status)
.append('/', status)
.append(nsName, status);
ures_getAllItemsWithFallback(resource.getAlias(), path.data(), sink, status);
if (status == U_MISSING_RESOURCE_ERROR) {
// Silently ignore and use Latin
status = U_ZERO_ERROR;
} else if (U_FAILURE(status)) {
return;
}
sink.isFallback = TRUE;
}
// Now load Latin.
sink.isLatin = TRUE;
ures_getAllItemsWithFallback(resource.getAlias(), gLatnPath, sink, status);
if (U_FAILURE(status)) return;
// If longData is empty, default it to be equal to shortData
if (result->longData.isEmpty()) {
result->longData.setToBogus();
}
// Check for "other" variants in each of the three data classes, and resolve missing elements.
if (!result->longData.isBogus()) {
checkForOtherVariants(&result->longData, status);
if (U_FAILURE(status)) return;
fillInMissing(&result->longData);
}
checkForOtherVariants(&result->shortData, status);
if (U_FAILURE(status)) return;
fillInMissing(&result->shortData);
// TODO: Enable this statement when currency support is added
// checkForOtherVariants(&result->shortCurrencyData, status);
// if (U_FAILURE(status)) return;
// fillInMissing(&result->shortCurrencyData);
}
U_CAPI void U_EXPORT2
ucol_prepareShortStringOpen( const char *definition,
UBool,
UParseError *parseError,
UErrorCode *status)
{
if(U_FAILURE(*status)) return;
UParseError internalParseError;
if(!parseError) {
parseError = &internalParseError;
}
parseError->line = 0;
parseError->offset = 0;
parseError->preContext[0] = 0;
parseError->postContext[0] = 0;
// first we want to pick stuff out of short string.
// we'll end up with an UCA version, locale and a bunch of
// settings
// analyse the string in order to get everything we need.
CollatorSpec s;
ucol_sit_initCollatorSpecs(&s);
ucol_sit_readSpecs(&s, definition, parseError, status);
ucol_sit_calculateWholeLocale(&s);
char buffer[internalBufferSize];
uprv_memset(buffer, 0, internalBufferSize);
uloc_canonicalize(s.locale, buffer, internalBufferSize, status);
UResourceBundle *b = ures_open(U_ICUDATA_COLL, buffer, status);
/* we try to find stuff from keyword */
UResourceBundle *collations = ures_getByKey(b, "collations", NULL, status);
UResourceBundle *collElem = NULL;
char keyBuffer[256];
// if there is a keyword, we pick it up and try to get elements
if(!uloc_getKeywordValue(buffer, "collation", keyBuffer, 256, status)) {
// no keyword. we try to find the default setting, which will give us the keyword value
UResourceBundle *defaultColl = ures_getByKeyWithFallback(collations, "default", NULL, status);
if(U_SUCCESS(*status)) {
int32_t defaultKeyLen = 0;
const UChar *defaultKey = ures_getString(defaultColl, &defaultKeyLen, status);
u_UCharsToChars(defaultKey, keyBuffer, defaultKeyLen);
keyBuffer[defaultKeyLen] = 0;
} else {
*status = U_INTERNAL_PROGRAM_ERROR;
return;
}
ures_close(defaultColl);
}
collElem = ures_getByKeyWithFallback(collations, keyBuffer, collElem, status);
ures_close(collElem);
ures_close(collations);
ures_close(b);
}
LocaleAliasTest::LocaleAliasTest(){
UErrorCode status = U_ZERO_ERROR;
resIndex = ures_open(NULL,"res_index", &status);
if(U_FAILURE(status)){
errln("Could not open res_index.res. Exiting. Error: %s\n", u_errorName(status));
resIndex=NULL;
}
defLocale = Locale::getDefault();
Locale::setDefault(Locale::getUS(), status);
}
void TestAliasConflict(void) {
UErrorCode status = U_ZERO_ERROR;
UResourceBundle *he = NULL;
UResourceBundle *iw = NULL;
const UChar *result = NULL;
int32_t resultLen;
he = ures_open(NULL, "he", &status);
iw = ures_open(NULL, "iw", &status);
if(U_FAILURE(status)) {
log_err_status(status, "Failed to get resource with %s\n", myErrorName(status));
}
ures_close(iw);
result = ures_getStringByKey(he, "ExemplarCharacters", &resultLen, &status);
if(U_FAILURE(status) || result == NULL) {
log_err_status(status, "Failed to get resource with %s\n", myErrorName(status));
}
ures_close(he);
}
DictionaryMatcher *
ICULanguageBreakFactory::loadDictionaryMatcherFor(UScriptCode script, int32_t /* brkType */) {
UErrorCode status = U_ZERO_ERROR;
// open root from brkitr tree.
UResourceBundle *b = ures_open(U_ICUDATA_BRKITR, "", &status);
b = ures_getByKeyWithFallback(b, "dictionaries", b, &status);
int32_t dictnlength = 0;
const UChar *dictfname =
ures_getStringByKeyWithFallback(b, uscript_getShortName(script), &dictnlength, &status);
if (U_FAILURE(status)) {
ures_close(b);
return NULL;
}
CharString dictnbuf;
CharString ext;
const UChar *extStart = u_memrchr(dictfname, 0x002e, dictnlength); // last dot
if (extStart != NULL) {
int32_t len = (int32_t)(extStart - dictfname);
ext.appendInvariantChars(UnicodeString(FALSE, extStart + 1, dictnlength - len - 1), status);
dictnlength = len;
}
dictnbuf.appendInvariantChars(UnicodeString(FALSE, dictfname, dictnlength), status);
ures_close(b);
UDataMemory *file = udata_open(U_ICUDATA_BRKITR, ext.data(), dictnbuf.data(), &status);
if (U_SUCCESS(status)) {
// build trie
const uint8_t *data = (const uint8_t *)udata_getMemory(file);
const int32_t *indexes = (const int32_t *)data;
const int32_t offset = indexes[DictionaryData::IX_STRING_TRIE_OFFSET];
const int32_t trieType = indexes[DictionaryData::IX_TRIE_TYPE] & DictionaryData::TRIE_TYPE_MASK;
DictionaryMatcher *m = NULL;
if (trieType == DictionaryData::TRIE_TYPE_BYTES) {
const int32_t transform = indexes[DictionaryData::IX_TRANSFORM];
const char *characters = (const char *)(data + offset);
m = new BytesDictionaryMatcher(characters, transform, file);
}
else if (trieType == DictionaryData::TRIE_TYPE_UCHARS) {
const UChar *characters = (const UChar *)(data + offset);
m = new UCharsDictionaryMatcher(characters, file);
}
if (m == NULL) {
// no matcher exists to take ownership - either we are an invalid
// type or memory allocation failed
udata_close(file);
}
return m;
} else if (dictfname != NULL) {
// we don't have a dictionary matcher.
// returning NULL here will cause us to fail to find a dictionary break engine, as expected
status = U_ZERO_ERROR;
return NULL;
}
return NULL;
}
static int32_t
_getStringOrCopyKey(const char *path, const char *locale,
const char *tableKey,
const char* subTableKey,
const char *itemKey,
const char *substitute,
UChar *dest, int32_t destCapacity,
UErrorCode *pErrorCode) {
const UChar *s = NULL;
int32_t length = 0;
if(itemKey==NULL) {
/* top-level item: normal resource bundle access */
UResourceBundle *rb;
rb=ures_open(path, locale, pErrorCode);
if(U_SUCCESS(*pErrorCode)) {
s=ures_getStringByKey(rb, tableKey, &length, pErrorCode);
/* see comment about closing rb near "return item;" in _res_getTableStringWithFallback() */
ures_close(rb);
}
} else {
/* Language code should not be a number. If it is, set the error code. */
if (!uprv_strncmp(tableKey, "Languages", 9) && uprv_strtol(itemKey, NULL, 10)) {
*pErrorCode = U_MISSING_RESOURCE_ERROR;
} else {
/* second-level item, use special fallback */
s=uloc_getTableStringWithFallback(path, locale,
tableKey,
subTableKey,
itemKey,
&length,
pErrorCode);
}
}
if(U_SUCCESS(*pErrorCode)) {
int32_t copyLength=uprv_min(length, destCapacity);
if(copyLength>0 && s != NULL) {
u_memcpy(dest, s, copyLength);
}
} else {
/* no string from a resource bundle: convert the substitute */
length=(int32_t)uprv_strlen(substitute);
u_charsToUChars(substitute, dest, uprv_min(length, destCapacity));
*pErrorCode=U_USING_DEFAULT_WARNING;
}
return u_terminateUChars(dest, destCapacity, length, pErrorCode);
}
U_CAPI UResourceBundle * U_EXPORT2
ures_openU(const UChar *myPath,
const char *localeID,
UErrorCode *status)
{
char pathBuffer[1024];
int32_t length;
char *path = pathBuffer;
if(status==NULL || U_FAILURE(*status)) {
return NULL;
}
if(myPath==NULL) {
path = NULL;
}
else {
length=u_strlen(myPath);
if(length>=sizeof(pathBuffer)) {
*status=U_ILLEGAL_ARGUMENT_ERROR;
return NULL;
} else if(uprv_isInvariantUString(myPath, length)) {
/*
* the invariant converter is sufficient for package and tree names
* and is more efficient
*/
u_UCharsToChars(myPath, path, length+1); /* length+1 to include the NUL */
} else {
#if !UCONFIG_NO_CONVERSION
/* use the default converter to support variant-character paths */
UConverter *cnv=u_getDefaultConverter(status);
length=ucnv_fromUChars(cnv, path, (int32_t)sizeof(pathBuffer), myPath, length, status);
u_releaseDefaultConverter(cnv);
if(U_FAILURE(*status)) {
return NULL;
}
if(length>=sizeof(pathBuffer)) {
/* not NUL-terminated - path too long */
*status=U_ILLEGAL_ARGUMENT_ERROR;
return NULL;
}
#else
/* the default converter is not available */
*status=U_UNSUPPORTED_ERROR;
return NULL;
#endif
}
}
return ures_open(path, localeID, status);
}
static void TestFallback()
{
UErrorCode status = U_ZERO_ERROR;
UResourceBundle *fr_FR = NULL;
UResourceBundle *subResource = NULL;
const UChar *junk; /* ignored */
int32_t resultLen;
log_verbose("Opening fr_FR..");
fr_FR = ures_open(NULL, "fr_FR", &status);
if(U_FAILURE(status))
{
log_err_status(status, "Couldn't open fr_FR - %s\n", u_errorName(status));
return;
}
status = U_ZERO_ERROR;
/* clear it out.. just do some calls to get the gears turning */
junk = ures_getStringByKey(fr_FR, "LocaleID", &resultLen, &status);
(void)junk; /* Suppress set but not used warning. */
status = U_ZERO_ERROR;
junk = ures_getStringByKey(fr_FR, "LocaleString", &resultLen, &status);
status = U_ZERO_ERROR;
junk = ures_getStringByKey(fr_FR, "LocaleID", &resultLen, &status);
status = U_ZERO_ERROR;
/* OK first one. This should be a Default value. */
subResource = ures_getByKey(fr_FR, "layout", NULL, &status);
if(status != U_USING_DEFAULT_WARNING)
{
log_data_err("Expected U_USING_DEFAULT_ERROR when trying to get layout from fr_FR, got %s\n",
u_errorName(status));
}
ures_close(subResource);
status = U_ZERO_ERROR;
/* and this is a Fallback, to fr */
junk = ures_getStringByKey(fr_FR, "ExemplarCharacters", &resultLen, &status);
if(status != U_USING_FALLBACK_WARNING)
{
log_data_err("Expected U_USING_FALLBACK_ERROR when trying to get ExemplarCharacters from fr_FR, got %s\n",
u_errorName(status));
}
status = U_ZERO_ERROR;
ures_close(fr_FR);
}
template<> U_I18N_API
const MeasureFormatCacheData *LocaleCacheKey<MeasureFormatCacheData>::createObject(
const void * /*unused*/, UErrorCode &status) const {
const char *localeId = fLoc.getName();
LocalUResourceBundlePointer unitsBundle(ures_open(U_ICUDATA_UNIT, localeId, &status));
static UNumberFormatStyle currencyStyles[] = {
UNUM_CURRENCY_PLURAL, UNUM_CURRENCY_ISO, UNUM_CURRENCY};
LocalPointer<MeasureFormatCacheData> result(new MeasureFormatCacheData(), status);
if (U_FAILURE(status)) {
return NULL;
}
if (!loadMeasureUnitData(
unitsBundle.getAlias(),
*result,
status)) {
return NULL;
}
result->adoptNumericDateFormatters(loadNumericDateFormatters(
unitsBundle.getAlias(), status));
if (U_FAILURE(status)) {
return NULL;
}
for (int32_t i = 0; i < WIDTH_INDEX_COUNT; ++i) {
// NumberFormat::createInstance can erase warning codes from status, so pass it
// a separate status instance
UErrorCode localStatus = U_ZERO_ERROR;
result->adoptCurrencyFormat(i, NumberFormat::createInstance(
localeId, currencyStyles[i], localStatus));
if (localStatus != U_ZERO_ERROR) {
status = localStatus;
}
if (U_FAILURE(status)) {
return NULL;
}
}
NumberFormat *inf = NumberFormat::createInstance(
localeId, UNUM_DECIMAL, status);
if (U_FAILURE(status)) {
return NULL;
}
inf->setMaximumFractionDigits(0);
DecimalFormat *decfmt = dynamic_cast<DecimalFormat *>(inf);
if (decfmt != NULL) {
decfmt->setRoundingMode(DecimalFormat::kRoundDown);
}
result->adoptIntegerFormat(inf);
result->addRef();
return result.orphan();
}
void
Calendar::setWeekCountData(const Locale& desiredLocale, UErrorCode& status)
{
// Read the week count data from the resource bundle. This should
// have the form:
//
// DateTimeElements:intvector {
// 1, // first day of week
// 1 // min days in week
// }
// Both have a range of 1..7
if (U_FAILURE(status)) return;
fFirstDayOfWeek = UCAL_SUNDAY;
fMinimalDaysInFirstWeek = 1;
UResourceBundle *resource = ures_open(NULL, desiredLocale.getName(), &status);
// If the resource data doesn't seem to be present at all, then use last-resort
// hard-coded data.
if (U_FAILURE(status))
{
status = U_USING_FALLBACK_WARNING;
ures_close(resource);
return;
}
//dateTimeElements = resource.getStringArray(kDateTimeElements, count, status);
UResourceBundle *dateTimeElements = ures_getByKey(resource, kDateTimeElements, NULL, &status);
if (U_SUCCESS(status)) {
int32_t arrLen;
const int32_t *dateTimeElementsArr = ures_getIntVector(dateTimeElements, &arrLen, &status);
if(U_SUCCESS(status) && arrLen == 2
&& 1 <= dateTimeElementsArr[0] && dateTimeElementsArr[0] <= 7
&& 1 <= dateTimeElementsArr[1] && dateTimeElementsArr[1] <= 7)
{
fFirstDayOfWeek = (UCalendarDaysOfWeek)dateTimeElementsArr[0];
fMinimalDaysInFirstWeek = (uint8_t)dateTimeElementsArr[1];
}
else {
status = U_INVALID_FORMAT_ERROR;
}
}
ures_close(dateTimeElements);
ures_close(resource);
}
void
ResourceBundle::constructForLocale(const UnicodeString& path,
const Locale& locale,
UErrorCode& error)
{
if (path.isEmpty()) {
fResource = ures_open(NULL, locale.getName(), &error);
}
else {
UnicodeString nullTerminatedPath(path);
nullTerminatedPath.append((UChar)0);
fResource = ures_openU(nullTerminatedPath.getBuffer(), locale.getName(), &error);
}
}
