libcore_icu_ICU.cpp revision 4c94a6128d1fcfaa75539b36c9f50d0c75df6144 
1/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "ICU"
18
19#include "JNIHelp.h"
20#include "JniConstants.h"
21#include "JniException.h"
22#include "ScopedFd.h"
23#include "ScopedJavaUnicodeString.h"
24#include "ScopedLocalRef.h"
25#include "ScopedStringChars.h"
26#include "ScopedUtfChars.h"
27#include "UniquePtr.h"
28#include "cutils/log.h"
29#include "toStringArray.h"
30#include "unicode/calendar.h"
31#include "unicode/datefmt.h"
32#include "unicode/dcfmtsym.h"
33#include "unicode/decimfmt.h"
34#include "unicode/dtfmtsym.h"
35#include "unicode/gregocal.h"
36#include "unicode/locid.h"
37#include "unicode/numfmt.h"
38#include "unicode/strenum.h"
39#include "unicode/ubrk.h"
40#include "unicode/ucal.h"
41#include "unicode/uclean.h"
42#include "unicode/ucol.h"
43#include "unicode/ucurr.h"
44#include "unicode/udat.h"
45#include "unicode/uloc.h"
46#include "unicode/ustring.h"
47#include "ureslocs.h"
48#include "valueOf.h"
49
50#include <errno.h>
51#include <fcntl.h>
52#include <stdlib.h>
53#include <string.h>
54#include <string>
55#include <sys/mman.h>
56#include <sys/stat.h>
57#include <sys/time.h>
58#include <sys/types.h>
59#include <time.h>
60#include <unistd.h>
61
62class ScopedResourceBundle {
63public:
64    ScopedResourceBundle(UResourceBundle* bundle) : mBundle(bundle) {
65    }
66
67    ~ScopedResourceBundle() {
68        if (mBundle != NULL) {
69            ures_close(mBundle);
70        }
71    }
72
73    UResourceBundle* get() {
74        return mBundle;
75    }
76
77private:
78    UResourceBundle* mBundle;
79
80    // Disallow copy and assignment.
81    ScopedResourceBundle(const ScopedResourceBundle&);
82    void operator=(const ScopedResourceBundle&);
83};
84
85Locale getLocale(JNIEnv* env, jstring localeName) {
86    return Locale::createFromName(ScopedUtfChars(env, localeName).c_str());
87}
88
89static jstring ICU_addLikelySubtags(JNIEnv* env, jclass, jstring javaLocale) {
90    UErrorCode status = U_ZERO_ERROR;
91    ScopedUtfChars localeID(env, javaLocale);
92    char maximizedLocaleID[ULOC_FULLNAME_CAPACITY];
93    uloc_addLikelySubtags(localeID.c_str(), maximizedLocaleID, sizeof(maximizedLocaleID), &status);
94    if (U_FAILURE(status)) {
95        return javaLocale;
96    }
97    return env->NewStringUTF(maximizedLocaleID);
98}
99
100static jstring ICU_getScript(JNIEnv* env, jclass, jstring javaLocale) {
101    UErrorCode status = U_ZERO_ERROR;
102    ScopedUtfChars localeID(env, javaLocale);
103    char script[ULOC_SCRIPT_CAPACITY];
104    uloc_getScript(localeID.c_str(), script, sizeof(script), &status);
105    if (U_FAILURE(status)) {
106        return NULL;
107    }
108    return env->NewStringUTF(script);
109}
110
111static jint ICU_getCurrencyFractionDigits(JNIEnv* env, jclass, jstring javaCurrencyCode) {
112    ScopedJavaUnicodeString currencyCode(env, javaCurrencyCode);
113    UnicodeString icuCurrencyCode(currencyCode.unicodeString());
114    UErrorCode status = U_ZERO_ERROR;
115    return ucurr_getDefaultFractionDigits(icuCurrencyCode.getTerminatedBuffer(), &status);
116}
117
118static jstring ICU_getCurrencyCode(JNIEnv* env, jclass, jstring javaCountryCode) {
119    UErrorCode status = U_ZERO_ERROR;
120    ScopedResourceBundle supplData(ures_openDirect(U_ICUDATA_CURR, "supplementalData", &status));
121    if (U_FAILURE(status)) {
122        return NULL;
123    }
124
125    ScopedResourceBundle currencyMap(ures_getByKey(supplData.get(), "CurrencyMap", NULL, &status));
126    if (U_FAILURE(status)) {
127        return NULL;
128    }
129
130    ScopedUtfChars countryCode(env, javaCountryCode);
131    ScopedResourceBundle currency(ures_getByKey(currencyMap.get(), countryCode.c_str(), NULL, &status));
132    if (U_FAILURE(status)) {
133        return NULL;
134    }
135
136    ScopedResourceBundle currencyElem(ures_getByIndex(currency.get(), 0, NULL, &status));
137    if (U_FAILURE(status)) {
138        return env->NewStringUTF("None");
139    }
140
141    // Check if there's a 'to' date. If there is, the currency isn't used anymore.
142    ScopedResourceBundle currencyTo(ures_getByKey(currencyElem.get(), "to", NULL, &status));
143    if (!U_FAILURE(status)) {
144        return NULL;
145    }
146    // Ignore the failure to find a 'to' date.
147    status = U_ZERO_ERROR;
148
149    ScopedResourceBundle currencyId(ures_getByKey(currencyElem.get(), "id", NULL, &status));
150    if (U_FAILURE(status)) {
151        // No id defined for this country
152        return env->NewStringUTF("None");
153    }
154
155    int32_t charCount;
156    const jchar* chars = ures_getString(currencyId.get(), &charCount, &status);
157    return (charCount == 0) ? env->NewStringUTF("None") : env->NewString(chars, charCount);
158}
159
160static jstring ICU_getCurrencyDisplayName(JNIEnv* env, jclass, jstring javaLocaleName, jstring javaCurrencyCode) {
161    ScopedUtfChars localeName(env, javaLocaleName);
162    ScopedJavaUnicodeString currencyCode(env, javaCurrencyCode);
163    UnicodeString icuCurrencyCode(currencyCode.unicodeString());
164    UErrorCode status = U_ZERO_ERROR;
165    UBool isChoiceFormat;
166    int32_t charCount;
167    const UChar* chars = ucurr_getName(icuCurrencyCode.getTerminatedBuffer(), localeName.c_str(),
168            UCURR_LONG_NAME, &isChoiceFormat, &charCount, &status);
169    if (status == U_USING_DEFAULT_WARNING) {
170        // ICU's default is English. We want the ISO 4217 currency code instead.
171        chars = icuCurrencyCode.getBuffer();
172        charCount = icuCurrencyCode.length();
173    }
174    return (charCount == 0) ? NULL : env->NewString(chars, charCount);
175}
176
177static jstring ICU_getCurrencySymbol(JNIEnv* env, jclass, jstring locale, jstring currencyCode) {
178    // We can't use ucurr_getName because it doesn't distinguish between using data root from
179    // the root locale and parroting back the input because it's never heard of the currency code.
180    ScopedUtfChars localeName(env, locale);
181    UErrorCode status = U_ZERO_ERROR;
182    ScopedResourceBundle currLoc(ures_open(U_ICUDATA_CURR, localeName.c_str(), &status));
183    if (U_FAILURE(status)) {
184        return NULL;
185    }
186
187    ScopedResourceBundle currencies(ures_getByKey(currLoc.get(), "Currencies", NULL, &status));
188    if (U_FAILURE(status)) {
189        return NULL;
190    }
191
192    ScopedUtfChars currency(env, currencyCode);
193    ScopedResourceBundle currencyElems(ures_getByKey(currencies.get(), currency.c_str(), NULL, &status));
194    if (U_FAILURE(status)) {
195        return NULL;
196    }
197
198    int32_t charCount;
199    const jchar* chars = ures_getStringByIndex(currencyElems.get(), 0, &charCount, &status);
200    if (U_FAILURE(status)) {
201        return NULL;
202    }
203    return (charCount == 0) ? NULL : env->NewString(chars, charCount);
204}
205
206static jstring ICU_getDisplayCountryNative(JNIEnv* env, jclass, jstring targetLocale, jstring locale) {
207    Locale loc = getLocale(env, locale);
208    Locale targetLoc = getLocale(env, targetLocale);
209    UnicodeString str;
210    targetLoc.getDisplayCountry(loc, str);
211    return env->NewString(str.getBuffer(), str.length());
212}
213
214static jstring ICU_getDisplayLanguageNative(JNIEnv* env, jclass, jstring targetLocale, jstring locale) {
215    Locale loc = getLocale(env, locale);
216    Locale targetLoc = getLocale(env, targetLocale);
217    UnicodeString str;
218    targetLoc.getDisplayLanguage(loc, str);
219    return env->NewString(str.getBuffer(), str.length());
220}
221
222static jstring ICU_getDisplayVariantNative(JNIEnv* env, jclass, jstring targetLocale, jstring locale) {
223    Locale loc = getLocale(env, locale);
224    Locale targetLoc = getLocale(env, targetLocale);
225    UnicodeString str;
226    targetLoc.getDisplayVariant(loc, str);
227    return env->NewString(str.getBuffer(), str.length());
228}
229
230static jstring ICU_getISO3CountryNative(JNIEnv* env, jclass, jstring locale) {
231    Locale loc = getLocale(env, locale);
232    return env->NewStringUTF(loc.getISO3Country());
233}
234
235static jstring ICU_getISO3LanguageNative(JNIEnv* env, jclass, jstring locale) {
236    Locale loc = getLocale(env, locale);
237    return env->NewStringUTF(loc.getISO3Language());
238}
239
240static jobjectArray ICU_getISOCountriesNative(JNIEnv* env, jclass) {
241    return toStringArray(env, Locale::getISOCountries());
242}
243
244static jobjectArray ICU_getISOLanguagesNative(JNIEnv* env, jclass) {
245    return toStringArray(env, Locale::getISOLanguages());
246}
247
248static jobjectArray ICU_getAvailableLocalesNative(JNIEnv* env, jclass) {
249    return toStringArray(env, uloc_countAvailable, uloc_getAvailable);
250}
251
252static jobjectArray ICU_getAvailableBreakIteratorLocalesNative(JNIEnv* env, jclass) {
253    return toStringArray(env, ubrk_countAvailable, ubrk_getAvailable);
254}
255
256static jobjectArray ICU_getAvailableCalendarLocalesNative(JNIEnv* env, jclass) {
257    return toStringArray(env, ucal_countAvailable, ucal_getAvailable);
258}
259
260static jobjectArray ICU_getAvailableCollatorLocalesNative(JNIEnv* env, jclass) {
261    return toStringArray(env, ucol_countAvailable, ucol_getAvailable);
262}
263
264static jobjectArray ICU_getAvailableDateFormatLocalesNative(JNIEnv* env, jclass) {
265    return toStringArray(env, udat_countAvailable, udat_getAvailable);
266}
267
268static jobjectArray ICU_getAvailableNumberFormatLocalesNative(JNIEnv* env, jclass) {
269    return toStringArray(env, unum_countAvailable, unum_getAvailable);
270}
271
272static bool getDayIntVector(JNIEnv*, UResourceBundle* gregorian, int* values) {
273    // get the First day of week and the minimal days in first week numbers
274    UErrorCode status = U_ZERO_ERROR;
275    ScopedResourceBundle gregorianElems(ures_getByKey(gregorian, "DateTimeElements", NULL, &status));
276    if (U_FAILURE(status)) {
277        return false;
278    }
279
280    int intVectSize;
281    const int* result = ures_getIntVector(gregorianElems.get(), &intVectSize, &status);
282    if (U_FAILURE(status) || intVectSize != 2) {
283        return false;
284    }
285
286    values[0] = result[0];
287    values[1] = result[1];
288    return true;
289}
290
291// This allows you to leave extra space at the beginning or end of the array to support the
292// month names and day names arrays.
293static jobjectArray toStringArray(JNIEnv* env, UResourceBundle* rb, size_t size, int capacity, size_t offset) {
294    if (capacity == -1) {
295        capacity = size;
296    }
297    jobjectArray result = env->NewObjectArray(capacity, JniConstants::stringClass, NULL);
298    if (result == NULL) {
299        return NULL;
300    }
301    UErrorCode status = U_ZERO_ERROR;
302    for (size_t i = 0; i < size; ++i) {
303        int charCount;
304        const jchar* chars = ures_getStringByIndex(rb, i, &charCount, &status);
305        if (U_FAILURE(status)) {
306            return NULL;
307        }
308        ScopedLocalRef<jstring> s(env, env->NewString(chars, charCount));
309        if (env->ExceptionCheck()) {
310            return NULL;
311        }
312        env->SetObjectArrayElement(result, offset + i, s.get());
313        if (env->ExceptionCheck()) {
314            return NULL;
315        }
316    }
317    return result;
318}
319
320static jobjectArray getAmPmMarkers(JNIEnv* env, UResourceBundle* gregorian) {
321    UErrorCode status = U_ZERO_ERROR;
322    ScopedResourceBundle amPmMarkers(ures_getByKey(gregorian, "AmPmMarkers", NULL, &status));
323    if (U_FAILURE(status)) {
324        return NULL;
325    }
326    return toStringArray(env, amPmMarkers.get(), ures_getSize(amPmMarkers.get()), -1, 0);
327}
328
329static jobjectArray getEras(JNIEnv* env, UResourceBundle* gregorian) {
330    UErrorCode status = U_ZERO_ERROR;
331    ScopedResourceBundle eras(ures_getByKey(gregorian, "eras", NULL, &status));
332    if (U_FAILURE(status)) {
333        return NULL;
334    }
335    ScopedResourceBundle abbreviatedEras(ures_getByKey(eras.get(), "abbreviated", NULL, &status));
336    if (U_FAILURE(status)) {
337        return NULL;
338    }
339    return toStringArray(env, abbreviatedEras.get(), ures_getSize(abbreviatedEras.get()), -1, 0);
340}
341
342enum NameType { REGULAR, STAND_ALONE };
343enum NameWidth { LONG, SHORT };
344static jobjectArray getNames(JNIEnv* env, UResourceBundle* namesBundle, bool months, NameType type, NameWidth width) {
345    const char* typeKey = (type == REGULAR) ? "format" : "stand-alone";
346    const char* widthKey = (width == LONG) ? "wide" : "abbreviated";
347    UErrorCode status = U_ZERO_ERROR;
348    ScopedResourceBundle formatBundle(ures_getByKey(namesBundle, typeKey, NULL, &status));
349    ScopedResourceBundle valuesBundle(ures_getByKey(formatBundle.get(), widthKey, NULL, &status));
350    if (U_FAILURE(status)) {
351        return NULL;
352    }
353
354    // The months array has a trailing empty string. The days array has a leading empty string.
355    int count = ures_getSize(valuesBundle.get());
356    int offset = months ? 0 : 1;
357    jobjectArray result = toStringArray(env, valuesBundle.get(), count, count + 1, offset);
358    env->SetObjectArrayElement(result, months ? count : 0, env->NewStringUTF(""));
359    return result;
360}
361
362static void setIntegerField(JNIEnv* env, jobject obj, const char* fieldName, int value) {
363    ScopedLocalRef<jobject> integerValue(env, integerValueOf(env, value));
364    jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "Ljava/lang/Integer;");
365    env->SetObjectField(obj, fid, integerValue.get());
366}
367
368static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, jstring value) {
369    jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "Ljava/lang/String;");
370    env->SetObjectField(obj, fid, value);
371}
372
373static void setStringArrayField(JNIEnv* env, jobject obj, const char* fieldName, jobjectArray value) {
374    jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "[Ljava/lang/String;");
375    env->SetObjectField(obj, fid, value);
376}
377
378static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, UResourceBundle* bundle, int index) {
379    UErrorCode status = U_ZERO_ERROR;
380    int charCount;
381    const UChar* chars = ures_getStringByIndex(bundle, index, &charCount, &status);
382    if (U_SUCCESS(status)) {
383        setStringField(env, obj, fieldName, env->NewString(chars, charCount));
384    } else {
385        LOGE("Error setting String field %s from ICU resource: %s", fieldName, u_errorName(status));
386    }
387}
388
389static bool setStringField(JNIEnv* env, jobject obj, const char* key, const char* fieldName, UResourceBundle* bundle) {
390    if (bundle == NULL) {
391        return false;
392    }
393    UErrorCode status = U_ZERO_ERROR;
394    int charCount;
395    const UChar* chars = ures_getStringByKey(bundle, key, &charCount, &status);
396    if (U_SUCCESS(status)) {
397        setStringField(env, obj, fieldName, env->NewString(chars, charCount));
398        return true;
399    } else {
400        // Missing item in current resource bundle but not an error.
401        return false;
402    }
403}
404
405static void setStringField(JNIEnv* env, jobject obj, const char* key, const char* fieldName,
406    UResourceBundle* bundle, UResourceBundle* fallbackBundle) {
407    if (!setStringField(env, obj, key, fieldName, bundle) && fallbackBundle != NULL) {
408        setStringField(env, obj, key, fieldName, fallbackBundle);
409    }
410}
411
412static bool setCharField(JNIEnv* env, jobject obj, const char* key, const char* fieldName,
413    UResourceBundle* bundle) {
414    if (bundle == NULL) {
415        return false;
416    }
417    UErrorCode status = U_ZERO_ERROR;
418    int charCount;
419    const UChar* chars = ures_getStringByKey(bundle, key, &charCount, &status);
420    if (U_SUCCESS(status)) {
421        jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "C");
422        env->SetCharField(obj, fid, chars[0]);
423        return true;
424    } else {
425        // Missing item in current resource bundle but not an error.
426        return false;
427    }
428}
429
430static void setCharField(JNIEnv* env, jobject obj, const char* key, const char* fieldName,
431    UResourceBundle* bundle, UResourceBundle* fallbackBundle) {
432    if (!setCharField(env, obj, key, fieldName, bundle) && fallbackBundle != NULL) {
433        setCharField(env, obj, key, fieldName, fallbackBundle);
434    }
435}
436
437static void setNumberSymbols(JNIEnv* env, jobject obj, UResourceBundle* numberSymbols,
438    UResourceBundle* fallbackNumberSymbols) {
439    setCharField(env, obj, "decimal", "decimalSeparator", numberSymbols, fallbackNumberSymbols);
440    setCharField(env, obj, "group", "groupingSeparator", numberSymbols, fallbackNumberSymbols);
441    setCharField(env, obj, "list", "patternSeparator", numberSymbols, fallbackNumberSymbols);
442    setCharField(env, obj, "percentSign", "percent", numberSymbols, fallbackNumberSymbols);
443    setCharField(env, obj, "perMille", "perMill", numberSymbols, fallbackNumberSymbols);
444    setCharField(env, obj, "decimal", "monetarySeparator", numberSymbols, fallbackNumberSymbols);
445    setCharField(env, obj, "minusSign", "minusSign", numberSymbols, fallbackNumberSymbols);
446    setStringField(env, obj, "exponential", "exponentSeparator", numberSymbols, fallbackNumberSymbols);
447    setStringField(env, obj, "infinity", "infinity", numberSymbols, fallbackNumberSymbols);
448    setStringField(env, obj, "nan", "NaN", numberSymbols, fallbackNumberSymbols);
449    // TODO: Digit field is removed in ICU4.6 release.
450    jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, "digit", "C");
451    env->SetCharField(obj, fid, '#');
452}
453
454static void setZeroDigitToDefault(JNIEnv* env, jobject obj) {
455    jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, "zeroDigit", "C");
456    env->SetCharField(obj, fid, '0');
457}
458
459static void setZeroDigit(JNIEnv* env, jobject obj, bool isLatn, char* buffer) {
460    if (isLatn || buffer == NULL || buffer[0] == '\0') {
461        return setZeroDigitToDefault(env, obj);
462    }
463    UErrorCode status = U_ZERO_ERROR;
464    ScopedResourceBundle numSystemRoot(ures_openDirect(NULL, "numberingSystems", &status));
465    if (U_FAILURE(status)) {
466        return setZeroDigitToDefault(env, obj);
467    }
468    ScopedResourceBundle numSystem(ures_getByKey(numSystemRoot.get(), "numberingSystems", NULL, &status));
469    if (U_FAILURE(status)) {
470        return setZeroDigitToDefault(env, obj);
471    }
472    ScopedResourceBundle nonLatnSystem(ures_getByKey(numSystem.get(), buffer, NULL, &status));
473    if (U_FAILURE(status)) {
474        return setZeroDigitToDefault(env, obj);
475    }
476    int32_t charCount = 0;
477    const UChar* chars = ures_getStringByKey(nonLatnSystem.get(), "desc", &charCount, &status);
478    if (charCount == 0) {
479        setZeroDigitToDefault(env, obj);
480    } else {
481        jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, "zeroDigit", "C");
482        env->SetCharField(obj, fid, chars[0]);
483    }
484}
485
486static void setNumberElements(JNIEnv* env, jobject obj, UResourceBundle* numberElements) {
487    UErrorCode status = U_ZERO_ERROR;
488    ScopedResourceBundle latnNumberRB(ures_getByKey(numberElements, "latn", NULL, &status));
489    if (U_FAILURE(status)) {
490        LOGW("Error getting ICU latn number elements system value: %s", u_errorName(status));
491        return;
492    }
493    ScopedResourceBundle patternsRB(ures_getByKey(latnNumberRB.get(), "patterns", NULL, &status));
494    if (U_FAILURE(status)) {
495        LOGW("Error getting ICU latn number patterns value: %s", u_errorName(status));
496        return;
497    }
498    // Get the patterns from the 'latn' numberElements
499    // This is a temporary workaround for ICU ticket#8611.
500    UResourceBundle* bundle = patternsRB.get();
501    setStringField(env, obj, "currencyFormat", "currencyPattern", bundle);
502    setStringField(env, obj, "decimalFormat", "numberPattern", bundle);
503    setStringField(env, obj, "percentFormat", "percentPattern", bundle);
504    // setStringField(env, obj, "scientificFormat", "???", bundle);
505
506    status = U_ZERO_ERROR;
507    bool isLatn = false;
508    char buffer[256];
509    buffer[0] = '\0';
510    ScopedResourceBundle defaultNumberElem(ures_getByKey(numberElements, "default", NULL, &status));
511    if (U_SUCCESS(status)) {
512        int32_t charCount = 256;
513        ures_getUTF8String(defaultNumberElem.get(), buffer, &charCount, true, &status);
514        buffer[charCount] = '\0';
515        if (U_FAILURE(status)) {
516            LOGW("Error getting ICU default number element system value: %s", u_errorName(status));
517            // Use latn number symbols instead.
518            isLatn = true;
519        } else {
520            isLatn = (strcmp(buffer, "latn") == 0);
521        }
522    } else {
523        // Not default data, fallback to latn number elements.
524        isLatn = true;
525    }
526
527    status = U_ZERO_ERROR;
528    setZeroDigit(env, obj, isLatn, buffer);
529    if (isLatn) {
530        ScopedResourceBundle symbolsRB(ures_getByKey(latnNumberRB.get(), "symbols", NULL, &status));
531        if (U_SUCCESS(status)) {
532            setNumberSymbols(env, obj, symbolsRB.get(), NULL);
533        } else {
534            LOGW("Missing ICU latn symbols system value: %s", u_errorName(status));
535        }
536    } else {
537        // Get every symbol item from default numbering system first. If it does not
538        // exist, get the symbol from latn numbering system.
539        ScopedResourceBundle defaultNumberRB(ures_getByKey(numberElements, (const char*)buffer, NULL, &status));
540        ScopedResourceBundle defaultSymbolsRB(ures_getByKey(defaultNumberRB.get(), "symbols", NULL, &status));
541        if (U_FAILURE(status)) {
542            LOGW("Missing ICU %s symbols system value: %s", buffer, u_errorName(status));
543            isLatn = true;  // Fallback to latn symbols.
544            status = U_ZERO_ERROR;
545        }
546        ScopedResourceBundle latnSymbolsRB(ures_getByKey(latnNumberRB.get(), "symbols", NULL, &status));
547        if (isLatn && U_FAILURE(status)) {
548            return;
549        }
550        setNumberSymbols(env, obj, defaultSymbolsRB.get(), latnSymbolsRB.get());
551    }
552}
553
554static jboolean ICU_initLocaleDataImpl(JNIEnv* env, jclass, jstring locale, jobject localeData) {
555    ScopedUtfChars localeName(env, locale);
556    UErrorCode status = U_ZERO_ERROR;
557    ScopedResourceBundle root(ures_open(NULL, localeName.c_str(), &status));
558    if (U_FAILURE(status)) {
559        LOGE("Error getting ICU resource bundle: %s", u_errorName(status));
560        status = U_ZERO_ERROR;
561        return JNI_FALSE;
562    }
563
564    ScopedResourceBundle calendar(ures_getByKey(root.get(), "calendar", NULL, &status));
565    if (U_FAILURE(status)) {
566        LOGE("Error getting ICU calendar resource bundle: %s", u_errorName(status));
567        return JNI_FALSE;
568    }
569
570    ScopedResourceBundle gregorian(ures_getByKey(calendar.get(), "gregorian", NULL, &status));
571    if (U_FAILURE(status)) {
572        LOGE("Error getting ICU gregorian resource bundle: %s", u_errorName(status));
573        return JNI_FALSE;
574    }
575
576    int firstDayVals[] = { 0, 0 };
577    if (getDayIntVector(env, gregorian.get(), firstDayVals)) {
578        setIntegerField(env, localeData, "firstDayOfWeek", firstDayVals[0]);
579        setIntegerField(env, localeData, "minimalDaysInFirstWeek", firstDayVals[1]);
580    }
581
582    setStringArrayField(env, localeData, "amPm", getAmPmMarkers(env, gregorian.get()));
583    setStringArrayField(env, localeData, "eras", getEras(env, gregorian.get()));
584
585    ScopedResourceBundle dayNames(ures_getByKey(gregorian.get(), "dayNames", NULL, &status));
586    ScopedResourceBundle monthNames(ures_getByKey(gregorian.get(), "monthNames", NULL, &status));
587
588    // Get the regular month and weekday names.
589    jobjectArray longMonthNames = getNames(env, monthNames.get(), true, REGULAR, LONG);
590    jobjectArray shortMonthNames = getNames(env, monthNames.get(), true, REGULAR, SHORT);
591    jobjectArray longWeekdayNames = getNames(env, dayNames.get(), false, REGULAR, LONG);
592    jobjectArray shortWeekdayNames = getNames(env, dayNames.get(), false, REGULAR, SHORT);
593    setStringArrayField(env, localeData, "longMonthNames", longMonthNames);
594    setStringArrayField(env, localeData, "shortMonthNames", shortMonthNames);
595    setStringArrayField(env, localeData, "longWeekdayNames", longWeekdayNames);
596    setStringArrayField(env, localeData, "shortWeekdayNames", shortWeekdayNames);
597
598    // Get the stand-alone month and weekday names. If they're not available (as they aren't for
599    // English), we reuse the regular names. If we returned null to Java, the usual fallback
600    // mechanisms would come into play and we'd end up with the bogus stand-alone names from the
601    // root locale ("1" for January, and so on).
602    jobjectArray longStandAloneMonthNames = getNames(env, monthNames.get(), true, STAND_ALONE, LONG);
603    if (longStandAloneMonthNames == NULL) {
604        longStandAloneMonthNames = longMonthNames;
605    }
606    jobjectArray shortStandAloneMonthNames = getNames(env, monthNames.get(), true, STAND_ALONE, SHORT);
607    if (shortStandAloneMonthNames == NULL) {
608        shortStandAloneMonthNames = shortMonthNames;
609    }
610    jobjectArray longStandAloneWeekdayNames = getNames(env, dayNames.get(), false, STAND_ALONE, LONG);
611    if (longStandAloneWeekdayNames == NULL) {
612        longStandAloneWeekdayNames = longWeekdayNames;
613    }
614    jobjectArray shortStandAloneWeekdayNames = getNames(env, dayNames.get(), false, STAND_ALONE, SHORT);
615    if (shortStandAloneWeekdayNames == NULL) {
616        shortStandAloneWeekdayNames = shortWeekdayNames;
617    }
618    setStringArrayField(env, localeData, "longStandAloneMonthNames", longStandAloneMonthNames);
619    setStringArrayField(env, localeData, "shortStandAloneMonthNames", shortStandAloneMonthNames);
620    setStringArrayField(env, localeData, "longStandAloneWeekdayNames", longStandAloneWeekdayNames);
621    setStringArrayField(env, localeData, "shortStandAloneWeekdayNames", shortStandAloneWeekdayNames);
622
623    ScopedResourceBundle dateTimePatterns(ures_getByKey(gregorian.get(), "DateTimePatterns", NULL, &status));
624    if (U_SUCCESS(status)) {
625        setStringField(env, localeData, "fullTimeFormat", dateTimePatterns.get(), 0);
626        setStringField(env, localeData, "longTimeFormat", dateTimePatterns.get(), 1);
627        setStringField(env, localeData, "mediumTimeFormat", dateTimePatterns.get(), 2);
628        setStringField(env, localeData, "shortTimeFormat", dateTimePatterns.get(), 3);
629        setStringField(env, localeData, "fullDateFormat", dateTimePatterns.get(), 4);
630        setStringField(env, localeData, "longDateFormat", dateTimePatterns.get(), 5);
631        setStringField(env, localeData, "mediumDateFormat", dateTimePatterns.get(), 6);
632        setStringField(env, localeData, "shortDateFormat", dateTimePatterns.get(), 7);
633    }
634    status = U_ZERO_ERROR;
635
636    // For numberPatterns and symbols.
637    ScopedResourceBundle numberElements(ures_getByKey(root.get(), "NumberElements", NULL, &status));
638    if (U_SUCCESS(status)) {
639        setNumberElements(env, localeData, numberElements.get());
640    }
641    status = U_ZERO_ERROR;
642
643    jstring countryCode = env->NewStringUTF(Locale::createFromName(localeName.c_str()).getCountry());
644    jstring internationalCurrencySymbol = ICU_getCurrencyCode(env, NULL, countryCode);
645    jstring currencySymbol = NULL;
646    if (internationalCurrencySymbol != NULL) {
647        currencySymbol = ICU_getCurrencySymbol(env, NULL, locale, internationalCurrencySymbol);
648    } else {
649        internationalCurrencySymbol = env->NewStringUTF("XXX");
650    }
651    if (currencySymbol == NULL) {
652        // This is the UTF-8 encoding of U+00A4 (CURRENCY SIGN).
653        currencySymbol = env->NewStringUTF("\xc2\xa4");
654    }
655    setStringField(env, localeData, "currencySymbol", currencySymbol);
656    setStringField(env, localeData, "internationalCurrencySymbol", internationalCurrencySymbol);
657
658    return JNI_TRUE;
659}
660
661static jstring ICU_toLowerCase(JNIEnv* env, jclass, jstring javaString, jstring localeName) {
662    ScopedJavaUnicodeString scopedString(env, javaString);
663    UnicodeString& s(scopedString.unicodeString());
664    UnicodeString original(s);
665    s.toLower(Locale::createFromName(ScopedUtfChars(env, localeName).c_str()));
666    return s == original ? javaString : env->NewString(s.getBuffer(), s.length());
667}
668
669static jstring ICU_toUpperCase(JNIEnv* env, jclass, jstring javaString, jstring localeName) {
670    ScopedJavaUnicodeString scopedString(env, javaString);
671    UnicodeString& s(scopedString.unicodeString());
672    UnicodeString original(s);
673    s.toUpper(Locale::createFromName(ScopedUtfChars(env, localeName).c_str()));
674    return s == original ? javaString : env->NewString(s.getBuffer(), s.length());
675}
676
677static jstring versionString(JNIEnv* env, const UVersionInfo& version) {
678    char versionString[U_MAX_VERSION_STRING_LENGTH];
679    u_versionToString(const_cast<UVersionInfo&>(version), &versionString[0]);
680    return env->NewStringUTF(versionString);
681}
682
683static jstring ICU_getIcuVersion(JNIEnv* env, jclass) {
684    UVersionInfo icuVersion;
685    u_getVersion(icuVersion);
686    return versionString(env, icuVersion);
687}
688
689static jstring ICU_getUnicodeVersion(JNIEnv* env, jclass) {
690    UVersionInfo unicodeVersion;
691    u_getUnicodeVersion(unicodeVersion);
692    return versionString(env, unicodeVersion);
693}
694
695
696struct EnumerationCounter {
697    const size_t count;
698    EnumerationCounter(size_t count) : count(count) {}
699    size_t operator()() { return count; }
700};
701struct EnumerationGetter {
702    UEnumeration* e;
703    UErrorCode* status;
704    EnumerationGetter(UEnumeration* e, UErrorCode* status) : e(e), status(status) {}
705    const UChar* operator()(int32_t* charCount) { return uenum_unext(e, charCount, status); }
706};
707static jobject ICU_getAvailableCurrencyCodes(JNIEnv* env, jclass) {
708    UErrorCode status = U_ZERO_ERROR;
709    UEnumeration* e(ucurr_openISOCurrencies(UCURR_COMMON|UCURR_NON_DEPRECATED, &status));
710    EnumerationCounter counter(uenum_count(e, &status));
711    EnumerationGetter getter(e, &status);
712    jobject result = toStringArray16(env, &counter, &getter);
713    maybeThrowIcuException(env, status);
714    uenum_close(e);
715    return result;
716}
717
718static JNINativeMethod gMethods[] = {
719    NATIVE_METHOD(ICU, addLikelySubtags, "(Ljava/lang/String;)Ljava/lang/String;"),
720    NATIVE_METHOD(ICU, getAvailableBreakIteratorLocalesNative, "()[Ljava/lang/String;"),
721    NATIVE_METHOD(ICU, getAvailableCalendarLocalesNative, "()[Ljava/lang/String;"),
722    NATIVE_METHOD(ICU, getAvailableCollatorLocalesNative, "()[Ljava/lang/String;"),
723    NATIVE_METHOD(ICU, getAvailableCurrencyCodes, "()[Ljava/lang/String;"),
724    NATIVE_METHOD(ICU, getAvailableDateFormatLocalesNative, "()[Ljava/lang/String;"),
725    NATIVE_METHOD(ICU, getAvailableLocalesNative, "()[Ljava/lang/String;"),
726    NATIVE_METHOD(ICU, getAvailableNumberFormatLocalesNative, "()[Ljava/lang/String;"),
727    NATIVE_METHOD(ICU, getCurrencyCode, "(Ljava/lang/String;)Ljava/lang/String;"),
728    NATIVE_METHOD(ICU, getCurrencyDisplayName, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
729    NATIVE_METHOD(ICU, getCurrencyFractionDigits, "(Ljava/lang/String;)I"),
730    NATIVE_METHOD(ICU, getCurrencySymbol, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
731    NATIVE_METHOD(ICU, getDisplayCountryNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
732    NATIVE_METHOD(ICU, getDisplayLanguageNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
733    NATIVE_METHOD(ICU, getDisplayVariantNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
734    NATIVE_METHOD(ICU, getISO3CountryNative, "(Ljava/lang/String;)Ljava/lang/String;"),
735    NATIVE_METHOD(ICU, getISO3LanguageNative, "(Ljava/lang/String;)Ljava/lang/String;"),
736    NATIVE_METHOD(ICU, getISOCountriesNative, "()[Ljava/lang/String;"),
737    NATIVE_METHOD(ICU, getISOLanguagesNative, "()[Ljava/lang/String;"),
738    NATIVE_METHOD(ICU, getIcuVersion, "()Ljava/lang/String;"),
739    NATIVE_METHOD(ICU, getScript, "(Ljava/lang/String;)Ljava/lang/String;"),
740    NATIVE_METHOD(ICU, getUnicodeVersion, "()Ljava/lang/String;"),
741    NATIVE_METHOD(ICU, initLocaleDataImpl, "(Ljava/lang/String;Llibcore/icu/LocaleData;)Z"),
742    NATIVE_METHOD(ICU, toLowerCase, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
743    NATIVE_METHOD(ICU, toUpperCase, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
744};
745int register_libcore_icu_ICU(JNIEnv* env) {
746    std::string path;
747    path = u_getDataDirectory();
748    path += "/";
749    path += U_ICUDATA_NAME;
750    path += ".dat";
751
752    #define FAIL_WITH_STRERROR(s) \
753        LOGE("Couldn't " s " '%s': %s", path.c_str(), strerror(errno)); \
754        return -1;
755    #define MAYBE_FAIL_WITH_ICU_ERROR(s) \
756        if (status != U_ZERO_ERROR) {\
757            LOGE("Couldn't initialize ICU (" s "): %s (%s)", u_errorName(status), path.c_str()); \
758            return -1; \
759        }
760
761    // Open the file and get its length.
762    ScopedFd fd(open(path.c_str(), O_RDONLY));
763    if (fd.get() == -1) {
764        FAIL_WITH_STRERROR("open");
765    }
766    struct stat sb;
767    if (fstat(fd.get(), &sb) == -1) {
768        FAIL_WITH_STRERROR("stat");
769    }
770
771    // Map it.
772    void* data = mmap(NULL, sb.st_size, PROT_READ, MAP_SHARED, fd.get(), 0);
773    if (data == MAP_FAILED) {
774        FAIL_WITH_STRERROR("mmap");
775    }
776
777    // Tell the kernel that accesses are likely to be random rather than sequential.
778    if (madvise(data, sb.st_size, MADV_RANDOM) == -1) {
779        FAIL_WITH_STRERROR("madvise(MADV_RANDOM)");
780    }
781
782    // Tell ICU to use our memory-mapped data.
783    UErrorCode status = U_ZERO_ERROR;
784    udata_setCommonData(data, &status);
785    MAYBE_FAIL_WITH_ICU_ERROR("udata_setCommonData");
786    // Tell ICU it can *only* use our memory-mapped data.
787    udata_setFileAccess(UDATA_NO_FILES, &status);
788    MAYBE_FAIL_WITH_ICU_ERROR("udata_setFileAccess");
789
790    // Failures to find the ICU data tend to be somewhat obscure because ICU loads its data on first
791    // use, which can be anywhere. Force initialization up front so we can report a nice clear error
792    // and bail.
793    u_init(&status);
794    MAYBE_FAIL_WITH_ICU_ERROR("u_init");
795    return jniRegisterNativeMethods(env, "libcore/icu/ICU", gMethods, NELEM(gMethods));
796}
797