ERL_NIF_TERM locale_parent(ErlNifEnv* env, int argc,
const ERL_NIF_TERM argv[])
{
UErrorCode status = U_ZERO_ERROR;
int32_t /*value_len,*/ key_len;
char value[LOCALE_LEN], key[LOCALE_LEN];
if (argc != 1)
return enif_make_badarg(env);
key_len = enif_get_atom(env, argv[0], (char*) key,
LOCALE_LEN, ERL_NIF_LATIN1);
if (!key_len) {
return enif_make_badarg(env);
}
/*value_len =*/ uloc_getParent((const char*) key, /* Locale Id */
(char *) value, /* Name */
(int32_t) LOCALE_LEN,
&status);
CHECK(env, status);
return enif_make_atom(env, value);
}
void Up() {
if (locale_name_length_ == 0) {
has_next_ = false;
} else {
locale_name_length_ = uloc_getParent(locale_name_, locale_name_, sizeof(locale_name_), &status_);
}
}
/**
* Modify the given locale name by removing the rightmost _-delimited
* element. If there is none, empty the string ("" == root).
* NOTE: The string "root" is not recognized; do not use it.
* @return TRUE if the fallback happened; FALSE if locale is already
* root ("").
*/
static UBool fallback(char *loc) {
if (!*loc) {
return FALSE;
}
UErrorCode status = U_ZERO_ERROR;
uloc_getParent(loc, loc, (int32_t)uprv_strlen(loc), &status);
/*
char *i = uprv_strrchr(loc, '_');
if (i == NULL) {
i = loc;
}
*i = 0;
*/
return TRUE;
}
const DayPeriodRules *DayPeriodRules::getInstance(const Locale &locale, UErrorCode &errorCode) {
umtx_initOnce(initOnce, DayPeriodRules::load, errorCode);
// If the entire day period rules data doesn't conform to spec (even if the part we want
// does), return NULL.
if(U_FAILURE(errorCode)) { return NULL; }
const char *localeCode = locale.getName();
char name[ULOC_FULLNAME_CAPACITY];
char parentName[ULOC_FULLNAME_CAPACITY];
if (uprv_strlen(localeCode) < ULOC_FULLNAME_CAPACITY) {
uprv_strcpy(name, localeCode);
// Treat empty string as root.
if (*name == '\0') {
uprv_strcpy(name, "root");
}
} else {
errorCode = U_BUFFER_OVERFLOW_ERROR;
return NULL;
}
int32_t ruleSetNum = 0; // NB there is no rule set 0 and 0 is returned upon lookup failure.
while (*name != '\0') {
ruleSetNum = uhash_geti(data->localeToRuleSetNumMap, name);
if (ruleSetNum == 0) {
// name and parentName can't be the same pointer, so fill in parent then copy to child.
uloc_getParent(name, parentName, ULOC_FULLNAME_CAPACITY, &errorCode);
if (*parentName == '\0') {
// Saves a lookup in the hash table.
break;
}
uprv_strcpy(name, parentName);
} else {
break;
}
}
if (ruleSetNum <= 0 || data->rules[ruleSetNum].getDayPeriodForHour(0) == DAYPERIOD_UNKNOWN) {
// If day period for hour 0 is UNKNOWN then day period for all hours are UNKNOWN.
// Data doesn't exist even with fallback.
return NULL;
} else {
return &data->rules[ruleSetNum];
}
}
const GenderInfo* GenderInfo::loadInstance(const Locale& locale, UErrorCode& status) {
LocalUResourceBundlePointer rb(
ures_openDirect(NULL, "genderList", &status));
if (U_FAILURE(status)) {
return NULL;
}
LocalUResourceBundlePointer locRes(ures_getByKey(rb.getAlias(), "genderList", NULL, &status));
if (U_FAILURE(status)) {
return NULL;
}
int32_t resLen = 0;
const char* curLocaleName = locale.getName();
UErrorCode key_status = U_ZERO_ERROR;
const UChar* s = ures_getStringByKey(locRes.getAlias(), curLocaleName, &resLen, &key_status);
if (s == NULL) {
key_status = U_ZERO_ERROR;
char parentLocaleName[ULOC_FULLNAME_CAPACITY];
uprv_strcpy(parentLocaleName, curLocaleName);
while (s == NULL && uloc_getParent(parentLocaleName, parentLocaleName, ULOC_FULLNAME_CAPACITY, &key_status) > 0) {
key_status = U_ZERO_ERROR;
resLen = 0;
s = ures_getStringByKey(locRes.getAlias(), parentLocaleName, &resLen, &key_status);
key_status = U_ZERO_ERROR;
}
}
if (s == NULL) {
return &gObjs[NEUTRAL];
}
char type_str[256];
u_UCharsToChars(s, type_str, resLen + 1);
if (uprv_strcmp(type_str, gNeutralStr) == 0) {
return &gObjs[NEUTRAL];
}
if (uprv_strcmp(type_str, gMixedNeutralStr) == 0) {
return &gObjs[MIXED_NEUTRAL];
}
if (uprv_strcmp(type_str, gMailTaintsStr) == 0) {
return &gObjs[MALE_TAINTS];
}
return &gObjs[NEUTRAL];
}
/*
PAL Function:
GetLocaleInfoString
Obtains string locale information.
Returns 1 for success, 0 otherwise
*/
int32_t GlobalizationNative_GetLocaleInfoString(const UChar* localeName,
LocaleStringData localeStringData,
UChar* value,
int32_t valueLength)
{
UErrorCode status = U_ZERO_ERROR;
char locale[ULOC_FULLNAME_CAPACITY];
GetLocale(localeName, locale, ULOC_FULLNAME_CAPACITY, FALSE, &status);
if (U_FAILURE(status))
{
return UErrorCodeToBool(U_ILLEGAL_ARGUMENT_ERROR);
}
switch (localeStringData)
{
case LocaleString_LocalizedDisplayName:
uloc_getDisplayName(locale, DetectDefaultLocaleName(), value, valueLength, &status);
break;
case LocaleString_EnglishDisplayName:
uloc_getDisplayName(locale, ULOC_ENGLISH, value, valueLength, &status);
break;
case LocaleString_NativeDisplayName:
uloc_getDisplayName(locale, locale, value, valueLength, &status);
break;
case LocaleString_LocalizedLanguageName:
uloc_getDisplayLanguage(locale, DetectDefaultLocaleName(), value, valueLength, &status);
break;
case LocaleString_EnglishLanguageName:
uloc_getDisplayLanguage(locale, ULOC_ENGLISH, value, valueLength, &status);
break;
case LocaleString_NativeLanguageName:
uloc_getDisplayLanguage(locale, locale, value, valueLength, &status);
break;
case LocaleString_EnglishCountryName:
uloc_getDisplayCountry(locale, ULOC_ENGLISH, value, valueLength, &status);
break;
case LocaleString_NativeCountryName:
uloc_getDisplayCountry(locale, locale, value, valueLength, &status);
break;
case LocaleString_ListSeparator:
// fall through
case LocaleString_ThousandSeparator:
status = GetLocaleInfoDecimalFormatSymbol(locale, UNUM_GROUPING_SEPARATOR_SYMBOL, value, valueLength);
break;
case LocaleString_DecimalSeparator:
status = GetLocaleInfoDecimalFormatSymbol(locale, UNUM_DECIMAL_SEPARATOR_SYMBOL, value, valueLength);
break;
case LocaleString_Digits:
status = GetDigitSymbol(locale, status, UNUM_ZERO_DIGIT_SYMBOL, 0, value, valueLength);
// symbols UNUM_ONE_DIGIT to UNUM_NINE_DIGIT are contiguous
for (int32_t symbol = UNUM_ONE_DIGIT_SYMBOL; symbol <= UNUM_NINE_DIGIT_SYMBOL; symbol++)
{
int charIndex = symbol - UNUM_ONE_DIGIT_SYMBOL + 1;
status = GetDigitSymbol(
locale, status, (UNumberFormatSymbol)symbol, charIndex, value, valueLength);
}
break;
case LocaleString_MonetarySymbol:
status = GetLocaleInfoDecimalFormatSymbol(locale, UNUM_CURRENCY_SYMBOL, value, valueLength);
break;
case LocaleString_Iso4217MonetarySymbol:
status = GetLocaleInfoDecimalFormatSymbol(locale, UNUM_INTL_CURRENCY_SYMBOL, value, valueLength);
break;
case LocaleString_CurrencyEnglishName:
status = GetLocaleCurrencyName(locale, FALSE, value, valueLength);
break;
case LocaleString_CurrencyNativeName:
status = GetLocaleCurrencyName(locale, TRUE, value, valueLength);
break;
case LocaleString_MonetaryDecimalSeparator:
status = GetLocaleInfoDecimalFormatSymbol(locale, UNUM_MONETARY_SEPARATOR_SYMBOL, value, valueLength);
break;
case LocaleString_MonetaryThousandSeparator:
status =
GetLocaleInfoDecimalFormatSymbol(locale, UNUM_MONETARY_GROUPING_SEPARATOR_SYMBOL, value, valueLength);
break;
case LocaleString_AMDesignator:
status = GetLocaleInfoAmPm(locale, TRUE, value, valueLength);
break;
case LocaleString_PMDesignator:
status = GetLocaleInfoAmPm(locale, FALSE, value, valueLength);
break;
case LocaleString_PositiveSign:
status = GetLocaleInfoDecimalFormatSymbol(locale, UNUM_PLUS_SIGN_SYMBOL, value, valueLength);
break;
case LocaleString_NegativeSign:
status = GetLocaleInfoDecimalFormatSymbol(locale, UNUM_MINUS_SIGN_SYMBOL, value, valueLength);
break;
case LocaleString_Iso639LanguageTwoLetterName:
status = GetLocaleIso639LanguageTwoLetterName(locale, value, valueLength);
break;
case LocaleString_Iso639LanguageThreeLetterName:
status = GetLocaleIso639LanguageThreeLetterName(locale, value, valueLength);
break;
case LocaleString_Iso3166CountryName:
status = GetLocaleIso3166CountryName(locale, value, valueLength);
break;
case LocaleString_Iso3166CountryName2:
status = GetLocaleIso3166CountryCode(locale, value, valueLength);
break;
case LocaleString_NaNSymbol:
status = GetLocaleInfoDecimalFormatSymbol(locale, UNUM_NAN_SYMBOL, value, valueLength);
break;
case LocaleString_PositiveInfinitySymbol:
status = GetLocaleInfoDecimalFormatSymbol(locale, UNUM_INFINITY_SYMBOL, value, valueLength);
break;
case LocaleString_ParentName:
{
// ICU supports lang[-script][-region][-variant] so up to 4 parents
// including invariant locale
char localeNameTemp[ULOC_FULLNAME_CAPACITY];
uloc_getParent(locale, localeNameTemp, ULOC_FULLNAME_CAPACITY, &status);
u_charsToUChars_safe(localeNameTemp, value, valueLength, &status);
if (U_SUCCESS(status))
{
FixupLocaleName(value, valueLength);
}
break;
}
case LocaleString_PercentSymbol:
status = GetLocaleInfoDecimalFormatSymbol(locale, UNUM_PERCENT_SYMBOL, value, valueLength);
break;
case LocaleString_PerMilleSymbol:
status = GetLocaleInfoDecimalFormatSymbol(locale, UNUM_PERMILL_SYMBOL, value, valueLength);
break;
default:
status = U_UNSUPPORTED_ERROR;
break;
};
return UErrorCodeToBool(status);
}
/*
Function:
EnumAbbrevEraNames
Enumerates all the abbreviated era names of the specified locale and calendar, invoking the
callback function for each era name.
*/
static int32_t EnumAbbrevEraNames(const char* locale,
CalendarId calendarId,
EnumCalendarInfoCallback callback,
const void* context)
{
// The C-API for ICU provides no way to get at the abbreviated era names for a calendar (so we can't use EnumSymbols
// here). Instead we will try to walk the ICU resource tables directly and fall back to regular era names if can't
// find good data.
char localeNameBuf[ULOC_FULLNAME_CAPACITY];
char parentNameBuf[ULOC_FULLNAME_CAPACITY];
char* localeNamePtr = localeNameBuf;
char* parentNamePtr = parentNameBuf;
strncpy(localeNamePtr, locale, ULOC_FULLNAME_CAPACITY);
while (TRUE)
{
UErrorCode status = U_ZERO_ERROR;
const char* name = GetCalendarName(calendarId);
UResourceBundle* rootResBundle = ures_open(NULL, localeNamePtr, &status);
UResourceBundle* calResBundle = ures_getByKey(rootResBundle, "calendar", NULL, &status);
UResourceBundle* targetCalResBundle = ures_getByKey(calResBundle, name, NULL, &status);
UResourceBundle* erasColResBundle = ures_getByKey(targetCalResBundle, "eras", NULL, &status);
UResourceBundle* erasResBundle = ures_getByKey(erasColResBundle, "narrow", NULL, &status);
if (U_SUCCESS(status))
{
EnumUResourceBundle(erasResBundle, callback, context);
CloseResBundle(rootResBundle, calResBundle, targetCalResBundle, erasColResBundle, erasResBundle);
return TRUE;
}
// Couldn't find the data we need for this locale, we should fallback.
if (localeNameBuf[0] == 0x0)
{
CloseResBundle(rootResBundle, calResBundle, targetCalResBundle, erasColResBundle, erasResBundle);
// We are already at the root locale so there is nothing to fall back to, just use the regular eras.
break;
}
uloc_getParent(localeNamePtr, parentNamePtr, ULOC_FULLNAME_CAPACITY, &status);
if (U_FAILURE(status))
{
CloseResBundle(rootResBundle, calResBundle, targetCalResBundle, erasColResBundle, erasResBundle);
// Something bad happened getting the parent name, bail out.
break;
}
// Swap localeNamePtr and parentNamePtr, parentNamePtr is what we want to use on the next iteration
// and we can use the current localeName as scratch space if we have to fall back on that
// iteration.
char* temp = localeNamePtr;
localeNamePtr = parentNamePtr;
parentNamePtr = temp;
CloseResBundle(rootResBundle, calResBundle, targetCalResBundle, erasColResBundle, erasResBundle);
}
// Walking the resource bundles didn't work, just use the regular eras.
return EnumSymbols(locale, calendarId, UDAT_ERAS, 0, callback, context);
}
static jboolean ICU_initLocaleDataImpl(JNIEnv* env, jclass, jstring locale, jobject localeData) {
ScopedUtfChars localeName(env, locale);
if (localeName.c_str() == NULL) {
return JNI_FALSE;
}
// Get DateTimePatterns
UErrorCode status;
char currentLocale[ULOC_FULLNAME_CAPACITY];
int32_t localeNameLen = 0;
if (localeName.size() >= ULOC_FULLNAME_CAPACITY) {
return JNI_FALSE; // Exceed ICU defined limit of the whole locale ID.
}
strcpy(currentLocale, localeName.c_str());
do {
status = U_ZERO_ERROR;
ScopedResourceBundle root(ures_open(NULL, currentLocale, &status));
if (U_FAILURE(status)) {
if (localeNameLen == 0) {
break; // No parent locale, report this error outside the loop.
} else {
status = U_ZERO_ERROR;
continue; // get parent locale.
}
}
ScopedResourceBundle calendar(ures_getByKey(root.get(), "calendar", NULL, &status));
if (U_FAILURE(status)) {
status = U_ZERO_ERROR;
continue; // get parent locale.
}
ScopedResourceBundle gregorian(ures_getByKey(calendar.get(), "gregorian", NULL, &status));
if (U_FAILURE(status)) {
status = U_ZERO_ERROR;
continue; // get parent locale.
}
ScopedResourceBundle dateTimePatterns(ures_getByKey(gregorian.get(), "DateTimePatterns", NULL, &status));
if (U_SUCCESS(status)) {
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);
break;
} else {
status = U_ZERO_ERROR; // get parent locale.
}
} while((localeNameLen = uloc_getParent(currentLocale, currentLocale, sizeof(currentLocale), &status)) >= 0);
if (U_FAILURE(status)) {
ALOGE("Error getting ICU resource bundle: %s", u_errorName(status));
return JNI_FALSE;
}
status = U_ZERO_ERROR;
Locale localeObj = getLocale(env, locale);
UniquePtr<Calendar> cal(Calendar::createInstance(localeObj, status));
if (U_FAILURE(status)) {
return JNI_FALSE;
}
setIntegerField(env, localeData, "firstDayOfWeek", cal->getFirstDayOfWeek());
setIntegerField(env, localeData, "minimalDaysInFirstWeek", cal->getMinimalDaysInFirstWeek());
// Get DateFormatSymbols
status = U_ZERO_ERROR;
DateFormatSymbols dateFormatSym(localeObj, status);
if (U_FAILURE(status)) {
return JNI_FALSE;
}
int32_t count = 0;
// Get AM/PM marker
const UnicodeString* amPmStrs = dateFormatSym.getAmPmStrings(count);
setStringArrayField(env, localeData, "amPm", amPmStrs, count);
const UnicodeString* erasStrs = dateFormatSym.getEras(count);
setStringArrayField(env, localeData, "eras", erasStrs, count);
const UnicodeString* longMonthNames =
dateFormatSym.getMonths(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
setStringArrayField(env, localeData, "longMonthNames", longMonthNames, count);
const UnicodeString* shortMonthNames =
dateFormatSym.getMonths(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
setStringArrayField(env, localeData, "shortMonthNames", shortMonthNames, count);
const UnicodeString* longWeekdayNames =
dateFormatSym.getWeekdays(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
setStringArrayField(env, localeData, "longWeekdayNames", longWeekdayNames, count);
const UnicodeString* shortWeekdayNames =
dateFormatSym.getWeekdays(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
setStringArrayField(env, localeData, "shortWeekdayNames", shortWeekdayNames, count);
const UnicodeString* longStandAloneMonthNames =
dateFormatSym.getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
setStringArrayField(env, localeData, "longStandAloneMonthNames", longStandAloneMonthNames, count);
const UnicodeString* shortStandAloneMonthNames =
dateFormatSym.getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
setStringArrayField(env, localeData, "shortStandAloneMonthNames", shortStandAloneMonthNames, count);
const UnicodeString* longStandAloneWeekdayNames =
dateFormatSym.getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
setStringArrayField(env, localeData, "longStandAloneWeekdayNames", longStandAloneWeekdayNames, count);
const UnicodeString* shortStandAloneWeekdayNames =
dateFormatSym.getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
setStringArrayField(env, localeData, "shortStandAloneWeekdayNames", shortStandAloneWeekdayNames, count);
status = U_ZERO_ERROR;
// For numberPatterns and symbols.
setNumberPatterns(env, localeData, locale);
setDecimalFormatSymbolsData(env, localeData, locale);
jstring countryCode = env->NewStringUTF(Locale::createFromName(localeName.c_str()).getCountry());
jstring internationalCurrencySymbol = ICU_getCurrencyCode(env, NULL, countryCode);
env->DeleteLocalRef(countryCode);
countryCode = NULL;
jstring currencySymbol = NULL;
if (internationalCurrencySymbol != NULL) {
currencySymbol = ICU_getCurrencySymbol(env, NULL, locale, internationalCurrencySymbol);
} else {
internationalCurrencySymbol = env->NewStringUTF("XXX");
}
if (currencySymbol == NULL) {
// This is the UTF-8 encoding of U+00A4 (CURRENCY SIGN).
currencySymbol = env->NewStringUTF("\xc2\xa4");
}
setStringField(env, localeData, "currencySymbol", currencySymbol);
setStringField(env, localeData, "internationalCurrencySymbol", internationalCurrencySymbol);
return JNI_TRUE;
}
U_CAPI int32_t U_EXPORT2
ualoc_getAppleParent(const char* localeID,
char * parent,
int32_t parentCapacity,
UErrorCode* err)
{
UResourceBundle *rb;
int32_t len;
UErrorCode tempStatus;
char locbuf[ULOC_FULLNAME_CAPACITY+1];
char * foundDoubleUnderscore;
if (U_FAILURE(*err)) {
return 0;
}
if ( (parent==NULL)? parentCapacity!=0: parentCapacity<0 ) {
*err = U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
len = uloc_getBaseName(localeID, locbuf, ULOC_FULLNAME_CAPACITY, err); /* canonicalize and strip keywords */
if (U_FAILURE(*err)) {
return 0;
}
if (*err == U_STRING_NOT_TERMINATED_WARNING) {
locbuf[ULOC_FULLNAME_CAPACITY] = 0;
*err = U_ZERO_ERROR;
}
foundDoubleUnderscore = uprv_strstr(locbuf, "__"); /* __ comes from bad/missing subtag or variant */
if (foundDoubleUnderscore != NULL) {
*foundDoubleUnderscore = 0; /* terminate at the __ */
len = uprv_strlen(locbuf);
}
if (len >= 2 && uprv_strncmp(locbuf, "zh", 2) == 0) {
const char ** forceParentPtr = forceParent;
const char * testCurLoc;
while ( (testCurLoc = *forceParentPtr++) != NULL ) {
int cmp = uprv_strcmp(locbuf, testCurLoc);
if (cmp <= 0) {
if (cmp == 0) {
len = uprv_strlen(*forceParentPtr);
if (len < parentCapacity) {
uprv_strcpy(parent, *forceParentPtr);
} else {
*err = U_BUFFER_OVERFLOW_ERROR;
}
return len;
}
break;
}
forceParentPtr++;
}
}
tempStatus = U_ZERO_ERROR;
rb = ures_openDirect(NULL, locbuf, &tempStatus);
if (U_SUCCESS(tempStatus)) {
const char * actualLocale = ures_getLocaleByType(rb, ULOC_ACTUAL_LOCALE, &tempStatus);
if (U_SUCCESS(tempStatus) && uprv_strcmp(locbuf, actualLocale) != 0) {
// we have followed an alias
len = uprv_strlen(actualLocale);
if (len < parentCapacity) {
uprv_strcpy(parent, actualLocale);
} else {
*err = U_BUFFER_OVERFLOW_ERROR;
}
ures_close(rb);
return len;
}
tempStatus = U_ZERO_ERROR;
const UChar * parentUName = ures_getStringByKey(rb, "%%Parent", &len, &tempStatus);
if (U_SUCCESS(tempStatus) && tempStatus != U_USING_FALLBACK_WARNING) {
if (len < parentCapacity) {
u_UCharsToChars(parentUName, parent, len + 1);
} else {
*err = U_BUFFER_OVERFLOW_ERROR;
}
ures_close(rb);
return len;
}
ures_close(rb);
}
len = uloc_getParent(locbuf, parent, parentCapacity, err);
if (U_SUCCESS(*err) && len == 0) {
len = 4;
if (len < parentCapacity) {
uprv_strcpy(parent, "root");
} else {
*err = U_BUFFER_OVERFLOW_ERROR;
}
}
return len;
}
// srcPluralCount is the original plural count on which the pattern is
// searched for.
// searchPluralCount is the fallback plural count.
// For example, to search for pattern for ""one" hour",
// "one" is the srcPluralCount,
// if the pattern is not found even in root, fallback to
// using patterns of plural count "other",
// then, "other" is the searchPluralCount.
void
TimeUnitFormat::searchInLocaleChain(UTimeUnitFormatStyle style, const char* key, const char* localeName,
TimeUnit::UTimeUnitFields srcTimeUnitField,
const UnicodeString& srcPluralCount,
const char* searchPluralCount,
Hashtable* countToPatterns,
UErrorCode& err) {
if (U_FAILURE(err)) {
return;
}
UErrorCode status = U_ZERO_ERROR;
char parentLocale[ULOC_FULLNAME_CAPACITY];
uprv_strcpy(parentLocale, localeName);
int32_t locNameLen;
U_ASSERT(countToPatterns != NULL);
while ((locNameLen = uloc_getParent(parentLocale, parentLocale,
ULOC_FULLNAME_CAPACITY, &status)) >= 0){
// look for pattern for srcPluralCount in locale tree
UResourceBundle *rb, *unitsRes, *countsToPatternRB;
rb = ures_open(U_ICUDATA_UNIT, parentLocale, &status);
unitsRes = ures_getByKey(rb, key, NULL, &status);
const char* timeUnitName = getTimeUnitName(srcTimeUnitField, status);
countsToPatternRB = ures_getByKey(unitsRes, timeUnitName, NULL, &status);
const UChar* pattern;
int32_t ptLength;
pattern = ures_getStringByKeyWithFallback(countsToPatternRB, searchPluralCount, &ptLength, &status);
if (U_SUCCESS(status)) {
//found
MessageFormat* messageFormat = new MessageFormat(UnicodeString(TRUE, pattern, ptLength), getLocale(err), err);
if (U_SUCCESS(err)) {
MessageFormat** formatters = (MessageFormat**)countToPatterns->get(srcPluralCount);
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(srcPluralCount, formatters, err);
if (U_FAILURE(err)) {
uprv_free(formatters);
delete messageFormat;
}
}
if (U_SUCCESS(err)) {
//delete formatters[style];
formatters[style] = messageFormat;
}
} else {
delete messageFormat;
}
ures_close(countsToPatternRB);
ures_close(unitsRes);
ures_close(rb);
return;
}
ures_close(countsToPatternRB);
ures_close(unitsRes);
ures_close(rb);
status = U_ZERO_ERROR;
if ( locNameLen ==0 ) {
break;
}
}
// if no unitsShort resource was found even after fallback to root locale
// then search the units resource fallback from the current level to root
if ( locNameLen == 0 && uprv_strcmp(key, gShortUnitsTag) == 0) {
#ifdef TMUTFMT_DEBUG
std::cout << "loop into searchInLocaleChain since Short-Long-Alternative \n";
#endif
char pLocale[ULOC_FULLNAME_CAPACITY];
uprv_strcpy(pLocale, localeName);
// Add an underscore at the tail of locale name,
// so that searchInLocaleChain will check the current locale before falling back
uprv_strcat(pLocale, "_");
searchInLocaleChain(style, gUnitsTag, pLocale, srcTimeUnitField, srcPluralCount,
searchPluralCount, countToPatterns, err);
MessageFormat** formatters = (MessageFormat**)countToPatterns->get(srcPluralCount);
if (formatters != NULL && formatters[style] != NULL) {
return;
}
}
// if not found the pattern for this plural count at all,
// fall-back to plural count "other"
if ( uprv_strcmp(searchPluralCount, gPluralCountOther) == 0 ) {
// set default fall back the same as the resource in root
MessageFormat* messageFormat = NULL;
const UChar *pattern = NULL;
if ( srcTimeUnitField == TimeUnit::UTIMEUNIT_SECOND ) {
pattern = DEFAULT_PATTERN_FOR_SECOND;
} else if ( srcTimeUnitField == TimeUnit::UTIMEUNIT_MINUTE ) {
pattern = DEFAULT_PATTERN_FOR_MINUTE;
} else if ( srcTimeUnitField == TimeUnit::UTIMEUNIT_HOUR ) {
pattern = DEFAULT_PATTERN_FOR_HOUR;
} else if ( srcTimeUnitField == TimeUnit::UTIMEUNIT_WEEK ) {
pattern = DEFAULT_PATTERN_FOR_WEEK;
} else if ( srcTimeUnitField == TimeUnit::UTIMEUNIT_DAY ) {
pattern = DEFAULT_PATTERN_FOR_DAY;
} else if ( srcTimeUnitField == TimeUnit::UTIMEUNIT_MONTH ) {
pattern = DEFAULT_PATTERN_FOR_MONTH;
} else if ( srcTimeUnitField == TimeUnit::UTIMEUNIT_YEAR ) {
pattern = DEFAULT_PATTERN_FOR_YEAR;
}
if (pattern != NULL) {
messageFormat = new MessageFormat(UnicodeString(TRUE, pattern, -1), getLocale(err), err);
}
if (U_SUCCESS(err)) {
MessageFormat** formatters = (MessageFormat**)countToPatterns->get(srcPluralCount);
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(srcPluralCount, formatters, err);
if (U_FAILURE(err)) {
uprv_free(formatters);
delete messageFormat;
}
}
if (U_SUCCESS(err)) {
//delete formatters[style];
formatters[style] = messageFormat;
}
} else {
delete messageFormat;
}
} else {
// fall back to rule "other", and search in parents
searchInLocaleChain(style, key, localeName, srcTimeUnitField, srcPluralCount,
gPluralCountOther, countToPatterns, err);
}
}
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;
}
UnicodeString
PluralRules::getRuleFromResource(const Locale& locale, UPluralType type, UErrorCode& errCode) {
UnicodeString emptyStr;
if (U_FAILURE(errCode)) {
return emptyStr;
}
LocalUResourceBundlePointer rb(ures_openDirect(NULL, "plurals", &errCode));
if(U_FAILURE(errCode)) {
return emptyStr;
}
const char *typeKey;
switch (type) {
case UPLURAL_TYPE_CARDINAL:
typeKey = "locales";
break;
case UPLURAL_TYPE_ORDINAL:
typeKey = "locales_ordinals";
break;
default:
// Must not occur: The caller should have checked for valid types.
errCode = U_ILLEGAL_ARGUMENT_ERROR;
return emptyStr;
}
LocalUResourceBundlePointer locRes(ures_getByKey(rb.getAlias(), typeKey, NULL, &errCode));
if(U_FAILURE(errCode)) {
return emptyStr;
}
int32_t resLen=0;
const char *curLocaleName=locale.getName();
const UChar* s = ures_getStringByKey(locRes.getAlias(), curLocaleName, &resLen, &errCode);
if (s == NULL) {
// Check parent locales.
UErrorCode status = U_ZERO_ERROR;
char parentLocaleName[ULOC_FULLNAME_CAPACITY];
const char *curLocaleName=locale.getName();
uprv_strcpy(parentLocaleName, curLocaleName);
while (uloc_getParent(parentLocaleName, parentLocaleName,
ULOC_FULLNAME_CAPACITY, &status) > 0) {
resLen=0;
s = ures_getStringByKey(locRes.getAlias(), parentLocaleName, &resLen, &status);
if (s != NULL) {
errCode = U_ZERO_ERROR;
break;
}
status = U_ZERO_ERROR;
}
}
if (s==NULL) {
return emptyStr;
}
char setKey[256];
UChar result[256];
u_UCharsToChars(s, setKey, resLen + 1);
// printf("\n PluralRule: %s\n", setKey);
LocalUResourceBundlePointer ruleRes(ures_getByKey(rb.getAlias(), "rules", NULL, &errCode));
if(U_FAILURE(errCode)) {
return emptyStr;
}
resLen=0;
LocalUResourceBundlePointer setRes(ures_getByKey(ruleRes.getAlias(), setKey, NULL, &errCode));
if (U_FAILURE(errCode)) {
return emptyStr;
}
int32_t numberKeys = ures_getSize(setRes.getAlias());
char *key=NULL;
int32_t len=0;
for(int32_t i=0; i<numberKeys; ++i) {
int32_t keyLen;
resLen=0;
s=ures_getNextString(setRes.getAlias(), &resLen, (const char**)&key, &errCode);
keyLen = (int32_t)uprv_strlen(key);
u_charsToUChars(key, result+len, keyLen);
len += keyLen;
result[len++]=COLON;
uprv_memcpy(result+len, s, resLen*sizeof(UChar));
len += resLen;
result[len++]=SEMI_COLON;
}
result[len++]=0;
u_UCharsToChars(result, setKey, len);
// printf(" Rule: %s\n", setKey);
return UnicodeString(result);
}
