libcore_icu_ICU.cpp revision bef9ec33e1368f57c731fce63b6a8c61628c64b0 
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/ustring.h"
46#include "ureslocs.h"
47#include "valueOf.h"
48
49#include <errno.h>
50#include <fcntl.h>
51#include <stdlib.h>
52#include <string.h>
53#include <string>
54#include <sys/mman.h>
55#include <sys/stat.h>
56#include <sys/time.h>
57#include <sys/types.h>
58#include <time.h>
59#include <unistd.h>
60
61class ScopedResourceBundle {
62public:
63    ScopedResourceBundle(UResourceBundle* bundle) : mBundle(bundle) {
64    }
65
66    ~ScopedResourceBundle() {
67        if (mBundle != NULL) {
68            ures_close(mBundle);
69        }
70    }
71
72    UResourceBundle* get() {
73        return mBundle;
74    }
75
76private:
77    UResourceBundle* mBundle;
78
79    // Disallow copy and assignment.
80    ScopedResourceBundle(const ScopedResourceBundle&);
81    void operator=(const ScopedResourceBundle&);
82};
83
84Locale getLocale(JNIEnv* env, jstring localeName) {
85    return Locale::createFromName(ScopedUtfChars(env, localeName).c_str());
86}
87
88static jint ICU_getCurrencyFractionDigits(JNIEnv* env, jclass, jstring javaCurrencyCode) {
89    ScopedJavaUnicodeString currencyCode(env, javaCurrencyCode);
90    UnicodeString icuCurrencyCode(currencyCode.unicodeString());
91    UErrorCode status = U_ZERO_ERROR;
92    return ucurr_getDefaultFractionDigits(icuCurrencyCode.getTerminatedBuffer(), &status);
93}
94
95static jstring ICU_getCurrencyCode(JNIEnv* env, jclass, jstring javaCountryCode) {
96    UErrorCode status = U_ZERO_ERROR;
97    ScopedResourceBundle supplData(ures_openDirect(U_ICUDATA_CURR, "supplementalData", &status));
98    if (U_FAILURE(status)) {
99        return NULL;
100    }
101
102    ScopedResourceBundle currencyMap(ures_getByKey(supplData.get(), "CurrencyMap", NULL, &status));
103    if (U_FAILURE(status)) {
104        return NULL;
105    }
106
107    ScopedUtfChars countryCode(env, javaCountryCode);
108    ScopedResourceBundle currency(ures_getByKey(currencyMap.get(), countryCode.c_str(), NULL, &status));
109    if (U_FAILURE(status)) {
110        return NULL;
111    }
112
113    ScopedResourceBundle currencyElem(ures_getByIndex(currency.get(), 0, NULL, &status));
114    if (U_FAILURE(status)) {
115        return env->NewStringUTF("None");
116    }
117
118    // Check if there's a 'to' date. If there is, the currency isn't used anymore.
119    ScopedResourceBundle currencyTo(ures_getByKey(currencyElem.get(), "to", NULL, &status));
120    if (!U_FAILURE(status)) {
121        return NULL;
122    }
123    // Ignore the failure to find a 'to' date.
124    status = U_ZERO_ERROR;
125
126    ScopedResourceBundle currencyId(ures_getByKey(currencyElem.get(), "id", NULL, &status));
127    if (U_FAILURE(status)) {
128        // No id defined for this country
129        return env->NewStringUTF("None");
130    }
131
132    int32_t charCount;
133    const jchar* chars = ures_getString(currencyId.get(), &charCount, &status);
134    return (charCount == 0) ? env->NewStringUTF("None") : env->NewString(chars, charCount);
135}
136
137static jstring ICU_getCurrencyDisplayName(JNIEnv* env, jclass, jstring javaLocaleName, jstring javaCurrencyCode) {
138    ScopedUtfChars localeName(env, javaLocaleName);
139    ScopedJavaUnicodeString currencyCode(env, javaCurrencyCode);
140    UnicodeString icuCurrencyCode(currencyCode.unicodeString());
141    UErrorCode status = U_ZERO_ERROR;
142    UBool isChoiceFormat;
143    int32_t charCount;
144    const UChar* chars = ucurr_getName(icuCurrencyCode.getTerminatedBuffer(), localeName.c_str(),
145            UCURR_LONG_NAME, &isChoiceFormat, &charCount, &status);
146    if (status == U_USING_DEFAULT_WARNING) {
147        // ICU's default is English. We want the ISO 4217 currency code instead.
148        chars = icuCurrencyCode.getBuffer();
149        charCount = icuCurrencyCode.length();
150    }
151    return (charCount == 0) ? NULL : env->NewString(chars, charCount);
152}
153
154static jstring ICU_getCurrencySymbol(JNIEnv* env, jclass, jstring locale, jstring currencyCode) {
155    // We can't use ucurr_getName because it doesn't distinguish between using data root from
156    // the root locale and parroting back the input because it's never heard of the currency code.
157    ScopedUtfChars localeName(env, locale);
158    UErrorCode status = U_ZERO_ERROR;
159    ScopedResourceBundle currLoc(ures_open(U_ICUDATA_CURR, localeName.c_str(), &status));
160    if (U_FAILURE(status)) {
161        return NULL;
162    }
163
164    ScopedResourceBundle currencies(ures_getByKey(currLoc.get(), "Currencies", NULL, &status));
165    if (U_FAILURE(status)) {
166        return NULL;
167    }
168
169    ScopedUtfChars currency(env, currencyCode);
170    ScopedResourceBundle currencyElems(ures_getByKey(currencies.get(), currency.c_str(), NULL, &status));
171    if (U_FAILURE(status)) {
172        return NULL;
173    }
174
175    int32_t charCount;
176    const jchar* chars = ures_getStringByIndex(currencyElems.get(), 0, &charCount, &status);
177    if (U_FAILURE(status)) {
178        return NULL;
179    }
180    return (charCount == 0) ? NULL : env->NewString(chars, charCount);
181}
182
183static jstring ICU_getDisplayCountryNative(JNIEnv* env, jclass, jstring targetLocale, jstring locale) {
184    Locale loc = getLocale(env, locale);
185    Locale targetLoc = getLocale(env, targetLocale);
186    UnicodeString str;
187    targetLoc.getDisplayCountry(loc, str);
188    return env->NewString(str.getBuffer(), str.length());
189}
190
191static jstring ICU_getDisplayLanguageNative(JNIEnv* env, jclass, jstring targetLocale, jstring locale) {
192    Locale loc = getLocale(env, locale);
193    Locale targetLoc = getLocale(env, targetLocale);
194    UnicodeString str;
195    targetLoc.getDisplayLanguage(loc, str);
196    return env->NewString(str.getBuffer(), str.length());
197}
198
199static jstring ICU_getDisplayVariantNative(JNIEnv* env, jclass, jstring targetLocale, jstring locale) {
200    Locale loc = getLocale(env, locale);
201    Locale targetLoc = getLocale(env, targetLocale);
202    UnicodeString str;
203    targetLoc.getDisplayVariant(loc, str);
204    return env->NewString(str.getBuffer(), str.length());
205}
206
207static jstring ICU_getISO3CountryNative(JNIEnv* env, jclass, jstring locale) {
208    Locale loc = getLocale(env, locale);
209    return env->NewStringUTF(loc.getISO3Country());
210}
211
212static jstring ICU_getISO3LanguageNative(JNIEnv* env, jclass, jstring locale) {
213    Locale loc = getLocale(env, locale);
214    return env->NewStringUTF(loc.getISO3Language());
215}
216
217static jobjectArray ICU_getISOCountriesNative(JNIEnv* env, jclass) {
218    return toStringArray(env, Locale::getISOCountries());
219}
220
221static jobjectArray ICU_getISOLanguagesNative(JNIEnv* env, jclass) {
222    return toStringArray(env, Locale::getISOLanguages());
223}
224
225static jobjectArray ICU_getAvailableLocalesNative(JNIEnv* env, jclass) {
226    return toStringArray(env, uloc_countAvailable, uloc_getAvailable);
227}
228
229static jobjectArray ICU_getAvailableBreakIteratorLocalesNative(JNIEnv* env, jclass) {
230    return toStringArray(env, ubrk_countAvailable, ubrk_getAvailable);
231}
232
233static jobjectArray ICU_getAvailableCalendarLocalesNative(JNIEnv* env, jclass) {
234    return toStringArray(env, ucal_countAvailable, ucal_getAvailable);
235}
236
237static jobjectArray ICU_getAvailableCollatorLocalesNative(JNIEnv* env, jclass) {
238    return toStringArray(env, ucol_countAvailable, ucol_getAvailable);
239}
240
241static jobjectArray ICU_getAvailableDateFormatLocalesNative(JNIEnv* env, jclass) {
242    return toStringArray(env, udat_countAvailable, udat_getAvailable);
243}
244
245static jobjectArray ICU_getAvailableNumberFormatLocalesNative(JNIEnv* env, jclass) {
246    return toStringArray(env, unum_countAvailable, unum_getAvailable);
247}
248
249static bool getDayIntVector(JNIEnv*, UResourceBundle* gregorian, int* values) {
250    // get the First day of week and the minimal days in first week numbers
251    UErrorCode status = U_ZERO_ERROR;
252    ScopedResourceBundle gregorianElems(ures_getByKey(gregorian, "DateTimeElements", NULL, &status));
253    if (U_FAILURE(status)) {
254        return false;
255    }
256
257    int intVectSize;
258    const int* result = ures_getIntVector(gregorianElems.get(), &intVectSize, &status);
259    if (U_FAILURE(status) || intVectSize != 2) {
260        return false;
261    }
262
263    values[0] = result[0];
264    values[1] = result[1];
265    return true;
266}
267
268// This allows you to leave extra space at the beginning or end of the array to support the
269// month names and day names arrays.
270static jobjectArray toStringArray(JNIEnv* env, UResourceBundle* rb, size_t size, int capacity, size_t offset) {
271    if (capacity == -1) {
272        capacity = size;
273    }
274    jobjectArray result = env->NewObjectArray(capacity, JniConstants::stringClass, NULL);
275    if (result == NULL) {
276        return NULL;
277    }
278    UErrorCode status = U_ZERO_ERROR;
279    for (size_t i = 0; i < size; ++i) {
280        int charCount;
281        const jchar* chars = ures_getStringByIndex(rb, i, &charCount, &status);
282        if (U_FAILURE(status)) {
283            return NULL;
284        }
285        ScopedLocalRef<jstring> s(env, env->NewString(chars, charCount));
286        if (env->ExceptionCheck()) {
287            return NULL;
288        }
289        env->SetObjectArrayElement(result, offset + i, s.get());
290        if (env->ExceptionCheck()) {
291            return NULL;
292        }
293    }
294    return result;
295}
296
297static jobjectArray getAmPmMarkers(JNIEnv* env, UResourceBundle* gregorian) {
298    UErrorCode status = U_ZERO_ERROR;
299    ScopedResourceBundle amPmMarkers(ures_getByKey(gregorian, "AmPmMarkers", NULL, &status));
300    if (U_FAILURE(status)) {
301        return NULL;
302    }
303    return toStringArray(env, amPmMarkers.get(), ures_getSize(amPmMarkers.get()), -1, 0);
304}
305
306static jobjectArray getEras(JNIEnv* env, UResourceBundle* gregorian) {
307    UErrorCode status = U_ZERO_ERROR;
308    ScopedResourceBundle eras(ures_getByKey(gregorian, "eras", NULL, &status));
309    if (U_FAILURE(status)) {
310        return NULL;
311    }
312    ScopedResourceBundle abbreviatedEras(ures_getByKey(eras.get(), "abbreviated", NULL, &status));
313    if (U_FAILURE(status)) {
314        return NULL;
315    }
316    return toStringArray(env, abbreviatedEras.get(), ures_getSize(abbreviatedEras.get()), -1, 0);
317}
318
319enum NameType { REGULAR, STAND_ALONE };
320enum NameWidth { LONG, SHORT };
321static jobjectArray getNames(JNIEnv* env, UResourceBundle* namesBundle, bool months, NameType type, NameWidth width) {
322    const char* typeKey = (type == REGULAR) ? "format" : "stand-alone";
323    const char* widthKey = (width == LONG) ? "wide" : "abbreviated";
324    UErrorCode status = U_ZERO_ERROR;
325    ScopedResourceBundle formatBundle(ures_getByKey(namesBundle, typeKey, NULL, &status));
326    ScopedResourceBundle valuesBundle(ures_getByKey(formatBundle.get(), widthKey, NULL, &status));
327    if (U_FAILURE(status)) {
328        return NULL;
329    }
330
331    // The months array has a trailing empty string. The days array has a leading empty string.
332    int count = ures_getSize(valuesBundle.get());
333    int offset = months ? 0 : 1;
334    jobjectArray result = toStringArray(env, valuesBundle.get(), count, count + 1, offset);
335    env->SetObjectArrayElement(result, months ? count : 0, env->NewStringUTF(""));
336    return result;
337}
338
339static void setIntegerField(JNIEnv* env, jobject obj, const char* fieldName, int value) {
340    ScopedLocalRef<jobject> integerValue(env, integerValueOf(env, value));
341    jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "Ljava/lang/Integer;");
342    env->SetObjectField(obj, fid, integerValue.get());
343}
344
345static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, jstring value) {
346    jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "Ljava/lang/String;");
347    env->SetObjectField(obj, fid, value);
348}
349
350static void setStringArrayField(JNIEnv* env, jobject obj, const char* fieldName, jobjectArray value) {
351    jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "[Ljava/lang/String;");
352    env->SetObjectField(obj, fid, value);
353}
354
355static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, UResourceBundle* bundle, int index) {
356    UErrorCode status = U_ZERO_ERROR;
357    int charCount;
358    const UChar* chars = ures_getStringByIndex(bundle, index, &charCount, &status);
359    if (U_SUCCESS(status)) {
360        setStringField(env, obj, fieldName, env->NewString(chars, charCount));
361    } else {
362        LOGE("Error setting String field %s from ICU resource: %s", fieldName, u_errorName(status));
363    }
364}
365
366static void setCharField(JNIEnv* env, jobject obj, const char* fieldName, UResourceBundle* bundle, int index) {
367    UErrorCode status = U_ZERO_ERROR;
368    int charCount;
369    const UChar* chars = ures_getStringByIndex(bundle, index, &charCount, &status);
370    if (U_SUCCESS(status)) {
371        jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "C");
372        env->SetCharField(obj, fid, chars[0]);
373    } else {
374        LOGE("Error setting char field %s from ICU resource: %s", fieldName, u_errorName(status));
375    }
376}
377
378static jboolean ICU_initLocaleDataImpl(JNIEnv* env, jclass, jstring locale, jobject localeData) {
379    ScopedUtfChars localeName(env, locale);
380    UErrorCode status = U_ZERO_ERROR;
381    ScopedResourceBundle root(ures_open(NULL, localeName.c_str(), &status));
382    if (U_FAILURE(status)) {
383        LOGE("Error getting ICU resource bundle: %s", u_errorName(status));
384        status = U_ZERO_ERROR;
385        return JNI_FALSE;
386    }
387
388    ScopedResourceBundle calendar(ures_getByKey(root.get(), "calendar", NULL, &status));
389    if (U_FAILURE(status)) {
390        LOGE("Error getting ICU calendar resource bundle: %s", u_errorName(status));
391        return JNI_FALSE;
392    }
393
394    ScopedResourceBundle gregorian(ures_getByKey(calendar.get(), "gregorian", NULL, &status));
395    if (U_FAILURE(status)) {
396        LOGE("Error getting ICU gregorian resource bundle: %s", u_errorName(status));
397        return JNI_FALSE;
398    }
399
400    int firstDayVals[] = { 0, 0 };
401    if (getDayIntVector(env, gregorian.get(), firstDayVals)) {
402        setIntegerField(env, localeData, "firstDayOfWeek", firstDayVals[0]);
403        setIntegerField(env, localeData, "minimalDaysInFirstWeek", firstDayVals[1]);
404    }
405
406    setStringArrayField(env, localeData, "amPm", getAmPmMarkers(env, gregorian.get()));
407    setStringArrayField(env, localeData, "eras", getEras(env, gregorian.get()));
408
409    ScopedResourceBundle dayNames(ures_getByKey(gregorian.get(), "dayNames", NULL, &status));
410    ScopedResourceBundle monthNames(ures_getByKey(gregorian.get(), "monthNames", NULL, &status));
411
412    // Get the regular month and weekday names.
413    jobjectArray longMonthNames = getNames(env, monthNames.get(), true, REGULAR, LONG);
414    jobjectArray shortMonthNames = getNames(env, monthNames.get(), true, REGULAR, SHORT);
415    jobjectArray longWeekdayNames = getNames(env, dayNames.get(), false, REGULAR, LONG);
416    jobjectArray shortWeekdayNames = getNames(env, dayNames.get(), false, REGULAR, SHORT);
417    setStringArrayField(env, localeData, "longMonthNames", longMonthNames);
418    setStringArrayField(env, localeData, "shortMonthNames", shortMonthNames);
419    setStringArrayField(env, localeData, "longWeekdayNames", longWeekdayNames);
420    setStringArrayField(env, localeData, "shortWeekdayNames", shortWeekdayNames);
421
422    // Get the stand-alone month and weekday names. If they're not available (as they aren't for
423    // English), we reuse the regular names. If we returned null to Java, the usual fallback
424    // mechanisms would come into play and we'd end up with the bogus stand-alone names from the
425    // root locale ("1" for January, and so on).
426    jobjectArray longStandAloneMonthNames = getNames(env, monthNames.get(), true, STAND_ALONE, LONG);
427    if (longStandAloneMonthNames == NULL) {
428        longStandAloneMonthNames = longMonthNames;
429    }
430    jobjectArray shortStandAloneMonthNames = getNames(env, monthNames.get(), true, STAND_ALONE, SHORT);
431    if (shortStandAloneMonthNames == NULL) {
432        shortStandAloneMonthNames = shortMonthNames;
433    }
434    jobjectArray longStandAloneWeekdayNames = getNames(env, dayNames.get(), false, STAND_ALONE, LONG);
435    if (longStandAloneWeekdayNames == NULL) {
436        longStandAloneWeekdayNames = longWeekdayNames;
437    }
438    jobjectArray shortStandAloneWeekdayNames = getNames(env, dayNames.get(), false, STAND_ALONE, SHORT);
439    if (shortStandAloneWeekdayNames == NULL) {
440        shortStandAloneWeekdayNames = shortWeekdayNames;
441    }
442    setStringArrayField(env, localeData, "longStandAloneMonthNames", longStandAloneMonthNames);
443    setStringArrayField(env, localeData, "shortStandAloneMonthNames", shortStandAloneMonthNames);
444    setStringArrayField(env, localeData, "longStandAloneWeekdayNames", longStandAloneWeekdayNames);
445    setStringArrayField(env, localeData, "shortStandAloneWeekdayNames", shortStandAloneWeekdayNames);
446
447    ScopedResourceBundle dateTimePatterns(ures_getByKey(gregorian.get(), "DateTimePatterns", NULL, &status));
448    if (U_SUCCESS(status)) {
449        setStringField(env, localeData, "fullTimeFormat", dateTimePatterns.get(), 0);
450        setStringField(env, localeData, "longTimeFormat", dateTimePatterns.get(), 1);
451        setStringField(env, localeData, "mediumTimeFormat", dateTimePatterns.get(), 2);
452        setStringField(env, localeData, "shortTimeFormat", dateTimePatterns.get(), 3);
453        setStringField(env, localeData, "fullDateFormat", dateTimePatterns.get(), 4);
454        setStringField(env, localeData, "longDateFormat", dateTimePatterns.get(), 5);
455        setStringField(env, localeData, "mediumDateFormat", dateTimePatterns.get(), 6);
456        setStringField(env, localeData, "shortDateFormat", dateTimePatterns.get(), 7);
457    }
458    status = U_ZERO_ERROR;
459
460    ScopedResourceBundle numberElements(ures_getByKey(root.get(), "NumberElements", NULL, &status));
461    if (U_SUCCESS(status) && ures_getSize(numberElements.get()) >= 11) {
462        setCharField(env, localeData, "zeroDigit", numberElements.get(), 4);
463        setCharField(env, localeData, "digit", numberElements.get(), 5);
464        setCharField(env, localeData, "decimalSeparator", numberElements.get(), 0);
465        setCharField(env, localeData, "groupingSeparator", numberElements.get(), 1);
466        setCharField(env, localeData, "patternSeparator", numberElements.get(), 2);
467        setCharField(env, localeData, "percent", numberElements.get(), 3);
468        setCharField(env, localeData, "perMill", numberElements.get(), 8);
469        setCharField(env, localeData, "monetarySeparator", numberElements.get(), 0);
470        setCharField(env, localeData, "minusSign", numberElements.get(), 6);
471        setStringField(env, localeData, "exponentSeparator", numberElements.get(), 7);
472        setStringField(env, localeData, "infinity", numberElements.get(), 9);
473        setStringField(env, localeData, "NaN", numberElements.get(), 10);
474    }
475    status = U_ZERO_ERROR;
476
477    jstring countryCode = env->NewStringUTF(Locale::createFromName(localeName.c_str()).getCountry());
478    jstring internationalCurrencySymbol = ICU_getCurrencyCode(env, NULL, countryCode);
479    jstring currencySymbol = NULL;
480    if (internationalCurrencySymbol != NULL) {
481        currencySymbol = ICU_getCurrencySymbol(env, NULL, locale, internationalCurrencySymbol);
482    } else {
483        internationalCurrencySymbol = env->NewStringUTF("XXX");
484    }
485    if (currencySymbol == NULL) {
486        // This is the UTF-8 encoding of U+00A4 (CURRENCY SIGN).
487        currencySymbol = env->NewStringUTF("\xc2\xa4");
488    }
489    setStringField(env, localeData, "currencySymbol", currencySymbol);
490    setStringField(env, localeData, "internationalCurrencySymbol", internationalCurrencySymbol);
491
492    ScopedResourceBundle numberPatterns(ures_getByKey(root.get(), "NumberPatterns", NULL, &status));
493    if (U_SUCCESS(status) && ures_getSize(numberPatterns.get()) >= 3) {
494        setStringField(env, localeData, "numberPattern", numberPatterns.get(), 0);
495        setStringField(env, localeData, "currencyPattern", numberPatterns.get(), 1);
496        setStringField(env, localeData, "percentPattern", numberPatterns.get(), 2);
497    }
498
499    return JNI_TRUE;
500}
501
502static jstring ICU_toLowerCase(JNIEnv* env, jclass, jstring javaString, jstring localeName) {
503    ScopedJavaUnicodeString scopedString(env, javaString);
504    UnicodeString& s(scopedString.unicodeString());
505    UnicodeString original(s);
506    s.toLower(Locale::createFromName(ScopedUtfChars(env, localeName).c_str()));
507    return s == original ? javaString : env->NewString(s.getBuffer(), s.length());
508}
509
510static jstring ICU_toUpperCase(JNIEnv* env, jclass, jstring javaString, jstring localeName) {
511    ScopedJavaUnicodeString scopedString(env, javaString);
512    UnicodeString& s(scopedString.unicodeString());
513    UnicodeString original(s);
514    s.toUpper(Locale::createFromName(ScopedUtfChars(env, localeName).c_str()));
515    return s == original ? javaString : env->NewString(s.getBuffer(), s.length());
516}
517
518static jstring versionString(JNIEnv* env, const UVersionInfo& version) {
519    char versionString[U_MAX_VERSION_STRING_LENGTH];
520    u_versionToString(const_cast<UVersionInfo&>(version), &versionString[0]);
521    return env->NewStringUTF(versionString);
522}
523
524static jstring ICU_getIcuVersion(JNIEnv* env, jclass) {
525    UVersionInfo icuVersion;
526    u_getVersion(icuVersion);
527    return versionString(env, icuVersion);
528}
529
530static jstring ICU_getUnicodeVersion(JNIEnv* env, jclass) {
531    UVersionInfo unicodeVersion;
532    u_getUnicodeVersion(unicodeVersion);
533    return versionString(env, unicodeVersion);
534}
535
536
537struct EnumerationCounter {
538    const size_t count;
539    EnumerationCounter(size_t count) : count(count) {}
540    size_t operator()() { return count; }
541};
542struct EnumerationGetter {
543    UEnumeration* e;
544    UErrorCode* status;
545    EnumerationGetter(UEnumeration* e, UErrorCode* status) : e(e), status(status) {}
546    const UChar* operator()(int32_t* charCount) { return uenum_unext(e, charCount, status); }
547};
548static jobject ICU_getAvailableCurrencyCodes(JNIEnv* env, jclass) {
549    UErrorCode status = U_ZERO_ERROR;
550    UEnumeration* e(ucurr_openISOCurrencies(UCURR_COMMON|UCURR_NON_DEPRECATED, &status));
551    EnumerationCounter counter(uenum_count(e, &status));
552    EnumerationGetter getter(e, &status);
553    jobject result = toStringArray16(env, &counter, &getter);
554    maybeThrowIcuException(env, status);
555    uenum_close(e);
556    return result;
557}
558
559static JNINativeMethod gMethods[] = {
560    NATIVE_METHOD(ICU, getAvailableBreakIteratorLocalesNative, "()[Ljava/lang/String;"),
561    NATIVE_METHOD(ICU, getAvailableCalendarLocalesNative, "()[Ljava/lang/String;"),
562    NATIVE_METHOD(ICU, getAvailableCollatorLocalesNative, "()[Ljava/lang/String;"),
563    NATIVE_METHOD(ICU, getAvailableCurrencyCodes, "()[Ljava/lang/String;"),
564    NATIVE_METHOD(ICU, getAvailableDateFormatLocalesNative, "()[Ljava/lang/String;"),
565    NATIVE_METHOD(ICU, getAvailableLocalesNative, "()[Ljava/lang/String;"),
566    NATIVE_METHOD(ICU, getAvailableNumberFormatLocalesNative, "()[Ljava/lang/String;"),
567    NATIVE_METHOD(ICU, getCurrencyCode, "(Ljava/lang/String;)Ljava/lang/String;"),
568    NATIVE_METHOD(ICU, getCurrencyDisplayName, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
569    NATIVE_METHOD(ICU, getCurrencyFractionDigits, "(Ljava/lang/String;)I"),
570    NATIVE_METHOD(ICU, getCurrencySymbol, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
571    NATIVE_METHOD(ICU, getDisplayCountryNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
572    NATIVE_METHOD(ICU, getDisplayLanguageNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
573    NATIVE_METHOD(ICU, getDisplayVariantNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
574    NATIVE_METHOD(ICU, getISO3CountryNative, "(Ljava/lang/String;)Ljava/lang/String;"),
575    NATIVE_METHOD(ICU, getISO3LanguageNative, "(Ljava/lang/String;)Ljava/lang/String;"),
576    NATIVE_METHOD(ICU, getISOCountriesNative, "()[Ljava/lang/String;"),
577    NATIVE_METHOD(ICU, getISOLanguagesNative, "()[Ljava/lang/String;"),
578    NATIVE_METHOD(ICU, getIcuVersion, "()Ljava/lang/String;"),
579    NATIVE_METHOD(ICU, getUnicodeVersion, "()Ljava/lang/String;"),
580    NATIVE_METHOD(ICU, initLocaleDataImpl, "(Ljava/lang/String;Llibcore/icu/LocaleData;)Z"),
581    NATIVE_METHOD(ICU, toLowerCase, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
582    NATIVE_METHOD(ICU, toUpperCase, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
583};
584int register_libcore_icu_ICU(JNIEnv* env) {
585    std::string path;
586    path = u_getDataDirectory();
587    path += "/";
588    path += U_ICUDATA_NAME;
589    path += ".dat";
590
591    #define FAIL_WITH_STRERROR(s) \
592        LOGE("Couldn't " s " '%s': %s", path.c_str(), strerror(errno)); \
593        return -1;
594    #define MAYBE_FAIL_WITH_ICU_ERROR(s) \
595        if (status != U_ZERO_ERROR) {\
596            LOGE("Couldn't initialize ICU (" s "): %s (%s)", u_errorName(status), path.c_str()); \
597            return -1; \
598        }
599
600    // Open the file and get its length.
601    ScopedFd fd(open(path.c_str(), O_RDONLY));
602    if (fd.get() == -1) {
603        FAIL_WITH_STRERROR("open");
604    }
605    struct stat sb;
606    if (fstat(fd.get(), &sb) == -1) {
607        FAIL_WITH_STRERROR("stat");
608    }
609
610    // Map it.
611    void* data = mmap(NULL, sb.st_size, PROT_READ, MAP_SHARED, fd.get(), 0);
612    if (data == MAP_FAILED) {
613        FAIL_WITH_STRERROR("mmap");
614    }
615
616    // Tell the kernel that accesses are likely to be random rather than sequential.
617    if (madvise(data, sb.st_size, MADV_RANDOM) == -1) {
618        FAIL_WITH_STRERROR("madvise(MADV_RANDOM)");
619    }
620
621    // Tell ICU to use our memory-mapped data.
622    UErrorCode status = U_ZERO_ERROR;
623    udata_setCommonData(data, &status);
624    MAYBE_FAIL_WITH_ICU_ERROR("udata_setCommonData");
625    // Tell ICU it can *only* use our memory-mapped data.
626    udata_setFileAccess(UDATA_NO_FILES, &status);
627    MAYBE_FAIL_WITH_ICU_ERROR("udata_setFileAccess");
628
629    // Failures to find the ICU data tend to be somewhat obscure because ICU loads its data on first
630    // use, which can be anywhere. Force initialization up front so we can report a nice clear error
631    // and bail.
632    u_init(&status);
633    MAYBE_FAIL_WITH_ICU_ERROR("u_init");
634    return jniRegisterNativeMethods(env, "libcore/icu/ICU", gMethods, NELEM(gMethods));
635}
636