libcore_icu_ICU.cpp revision 007776e50b6305e2c4551f8ace682fffab412202 
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 "ScopedUtfChars.h"
26#include "UniquePtr.h"
27#include "cutils/log.h"
28#include "toStringArray.h"
29#include "unicode/calendar.h"
30#include "unicode/datefmt.h"
31#include "unicode/dcfmtsym.h"
32#include "unicode/decimfmt.h"
33#include "unicode/dtfmtsym.h"
34#include "unicode/dtptngen.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
62// TODO: put this in a header file and use it everywhere!
63// DISALLOW_COPY_AND_ASSIGN disallows the copy and operator= functions.
64// It goes in the private: declarations in a class.
65#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
66    TypeName(const TypeName&); \
67    void operator=(const TypeName&)
68
69class ScopedResourceBundle {
70 public:
71  ScopedResourceBundle(UResourceBundle* bundle) : bundle_(bundle) {
72  }
73
74  ~ScopedResourceBundle() {
75    if (bundle_ != NULL) {
76      ures_close(bundle_);
77    }
78  }
79
80  UResourceBundle* get() {
81    return bundle_;
82  }
83
84  bool hasKey(const char* key) {
85    UErrorCode status = U_ZERO_ERROR;
86    ures_getStringByKey(bundle_, key, NULL, &status);
87    return U_SUCCESS(status);
88  }
89
90 private:
91  UResourceBundle* bundle_;
92  DISALLOW_COPY_AND_ASSIGN(ScopedResourceBundle);
93};
94
95Locale getLocale(JNIEnv* env, jstring localeName) {
96    return Locale::createFromName(ScopedUtfChars(env, localeName).c_str());
97}
98
99static jstring ICU_addLikelySubtags(JNIEnv* env, jclass, jstring javaLocale) {
100    UErrorCode status = U_ZERO_ERROR;
101    ScopedUtfChars localeID(env, javaLocale);
102    char maximizedLocaleID[ULOC_FULLNAME_CAPACITY];
103    uloc_addLikelySubtags(localeID.c_str(), maximizedLocaleID, sizeof(maximizedLocaleID), &status);
104    if (U_FAILURE(status)) {
105        return javaLocale;
106    }
107    return env->NewStringUTF(maximizedLocaleID);
108}
109
110static jstring ICU_getScript(JNIEnv* env, jclass, jstring javaLocale) {
111    UErrorCode status = U_ZERO_ERROR;
112    ScopedUtfChars localeID(env, javaLocale);
113    char script[ULOC_SCRIPT_CAPACITY];
114    uloc_getScript(localeID.c_str(), script, sizeof(script), &status);
115    if (U_FAILURE(status)) {
116        return NULL;
117    }
118    return env->NewStringUTF(script);
119}
120
121static jint ICU_getCurrencyFractionDigits(JNIEnv* env, jclass, jstring javaCurrencyCode) {
122    ScopedJavaUnicodeString currencyCode(env, javaCurrencyCode);
123    UnicodeString icuCurrencyCode(currencyCode.unicodeString());
124    UErrorCode status = U_ZERO_ERROR;
125    return ucurr_getDefaultFractionDigits(icuCurrencyCode.getTerminatedBuffer(), &status);
126}
127
128// TODO: rewrite this with int32_t ucurr_forLocale(const char* locale, UChar* buff, int32_t buffCapacity, UErrorCode* ec)...
129static jstring ICU_getCurrencyCode(JNIEnv* env, jclass, jstring javaCountryCode) {
130    UErrorCode status = U_ZERO_ERROR;
131    ScopedResourceBundle supplData(ures_openDirect(U_ICUDATA_CURR, "supplementalData", &status));
132    if (U_FAILURE(status)) {
133        return NULL;
134    }
135
136    ScopedResourceBundle currencyMap(ures_getByKey(supplData.get(), "CurrencyMap", NULL, &status));
137    if (U_FAILURE(status)) {
138        return NULL;
139    }
140
141    ScopedUtfChars countryCode(env, javaCountryCode);
142    ScopedResourceBundle currency(ures_getByKey(currencyMap.get(), countryCode.c_str(), NULL, &status));
143    if (U_FAILURE(status)) {
144        return NULL;
145    }
146
147    ScopedResourceBundle currencyElem(ures_getByIndex(currency.get(), 0, NULL, &status));
148    if (U_FAILURE(status)) {
149        return env->NewStringUTF("XXX");
150    }
151
152    // Check if there's a 'to' date. If there is, the currency isn't used anymore.
153    ScopedResourceBundle currencyTo(ures_getByKey(currencyElem.get(), "to", NULL, &status));
154    if (!U_FAILURE(status)) {
155        return NULL;
156    }
157    // Ignore the failure to find a 'to' date.
158    status = U_ZERO_ERROR;
159
160    ScopedResourceBundle currencyId(ures_getByKey(currencyElem.get(), "id", NULL, &status));
161    if (U_FAILURE(status)) {
162        // No id defined for this country
163        return env->NewStringUTF("XXX");
164    }
165
166    int32_t charCount;
167    const jchar* chars = ures_getString(currencyId.get(), &charCount, &status);
168    return (charCount == 0) ? env->NewStringUTF("XXX") : env->NewString(chars, charCount);
169}
170
171static jstring getCurrencyName(JNIEnv* env, jstring javaLocaleName, jstring javaCurrencyCode, UCurrNameStyle nameStyle) {
172  ScopedUtfChars localeName(env, javaLocaleName);
173  ScopedJavaUnicodeString currencyCode(env, javaCurrencyCode);
174  UnicodeString icuCurrencyCode(currencyCode.unicodeString());
175  UErrorCode status = U_ZERO_ERROR;
176  UBool isChoiceFormat = false;
177  int32_t charCount;
178  const UChar* chars = ucurr_getName(icuCurrencyCode.getTerminatedBuffer(), localeName.c_str(),
179                                     nameStyle, &isChoiceFormat, &charCount, &status);
180  if (status == U_USING_DEFAULT_WARNING) {
181    if (nameStyle == UCURR_SYMBOL_NAME) {
182      // ICU doesn't distinguish between falling back to the root locale and meeting a genuinely
183      // unknown currency. The Currency class does.
184      if (!ucurr_isAvailable(icuCurrencyCode.getTerminatedBuffer(), U_DATE_MIN, U_DATE_MAX, &status)) {
185        return NULL;
186      }
187    }
188    if (nameStyle == UCURR_LONG_NAME) {
189      // ICU's default is English. We want the ISO 4217 currency code instead.
190      chars = icuCurrencyCode.getBuffer();
191      charCount = icuCurrencyCode.length();
192    }
193  }
194  return (charCount == 0) ? NULL : env->NewString(chars, charCount);
195}
196
197static jstring ICU_getCurrencyDisplayName(JNIEnv* env, jclass, jstring javaLocaleName, jstring javaCurrencyCode) {
198  return getCurrencyName(env, javaLocaleName, javaCurrencyCode, UCURR_LONG_NAME);
199}
200
201static jstring ICU_getCurrencySymbol(JNIEnv* env, jclass, jstring javaLocaleName, jstring javaCurrencyCode) {
202  return getCurrencyName(env, javaLocaleName, javaCurrencyCode, UCURR_SYMBOL_NAME);
203}
204
205static jstring ICU_getDisplayCountryNative(JNIEnv* env, jclass, jstring targetLocale, jstring locale) {
206    Locale loc = getLocale(env, locale);
207    Locale targetLoc = getLocale(env, targetLocale);
208    UnicodeString str;
209    targetLoc.getDisplayCountry(loc, str);
210    return env->NewString(str.getBuffer(), str.length());
211}
212
213static jstring ICU_getDisplayLanguageNative(JNIEnv* env, jclass, jstring targetLocale, jstring locale) {
214    Locale loc = getLocale(env, locale);
215    Locale targetLoc = getLocale(env, targetLocale);
216    UnicodeString str;
217    targetLoc.getDisplayLanguage(loc, str);
218    return env->NewString(str.getBuffer(), str.length());
219}
220
221static jstring ICU_getDisplayVariantNative(JNIEnv* env, jclass, jstring targetLocale, jstring locale) {
222    Locale loc = getLocale(env, locale);
223    Locale targetLoc = getLocale(env, targetLocale);
224    UnicodeString str;
225    targetLoc.getDisplayVariant(loc, str);
226    return env->NewString(str.getBuffer(), str.length());
227}
228
229static jstring ICU_getISO3CountryNative(JNIEnv* env, jclass, jstring locale) {
230    Locale loc = getLocale(env, locale);
231    return env->NewStringUTF(loc.getISO3Country());
232}
233
234static jstring ICU_getISO3LanguageNative(JNIEnv* env, jclass, jstring locale) {
235    Locale loc = getLocale(env, locale);
236    return env->NewStringUTF(loc.getISO3Language());
237}
238
239static jobjectArray ICU_getISOCountriesNative(JNIEnv* env, jclass) {
240    return toStringArray(env, Locale::getISOCountries());
241}
242
243static jobjectArray ICU_getISOLanguagesNative(JNIEnv* env, jclass) {
244    return toStringArray(env, Locale::getISOLanguages());
245}
246
247static jobjectArray ICU_getAvailableLocalesNative(JNIEnv* env, jclass) {
248    return toStringArray(env, uloc_countAvailable, uloc_getAvailable);
249}
250
251static jobjectArray ICU_getAvailableBreakIteratorLocalesNative(JNIEnv* env, jclass) {
252    return toStringArray(env, ubrk_countAvailable, ubrk_getAvailable);
253}
254
255static jobjectArray ICU_getAvailableCalendarLocalesNative(JNIEnv* env, jclass) {
256    return toStringArray(env, ucal_countAvailable, ucal_getAvailable);
257}
258
259static jobjectArray ICU_getAvailableCollatorLocalesNative(JNIEnv* env, jclass) {
260    return toStringArray(env, ucol_countAvailable, ucol_getAvailable);
261}
262
263static jobjectArray ICU_getAvailableDateFormatLocalesNative(JNIEnv* env, jclass) {
264    return toStringArray(env, udat_countAvailable, udat_getAvailable);
265}
266
267static jobjectArray ICU_getAvailableNumberFormatLocalesNative(JNIEnv* env, jclass) {
268    return toStringArray(env, unum_countAvailable, unum_getAvailable);
269}
270
271static void setIntegerField(JNIEnv* env, jobject obj, const char* fieldName, int value) {
272    ScopedLocalRef<jobject> integerValue(env, integerValueOf(env, value));
273    jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "Ljava/lang/Integer;");
274    env->SetObjectField(obj, fid, integerValue.get());
275}
276
277static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, jstring value) {
278    jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "Ljava/lang/String;");
279    env->SetObjectField(obj, fid, value);
280    env->DeleteLocalRef(value);
281}
282
283static void setStringArrayField(JNIEnv* env, jobject obj, const char* fieldName, jobjectArray value) {
284    jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "[Ljava/lang/String;");
285    env->SetObjectField(obj, fid, value);
286}
287
288static void setStringArrayField(JNIEnv* env, jobject obj, const char* fieldName, const UnicodeString* valueArray, int32_t size) {
289    ScopedLocalRef<jobjectArray> result(env, env->NewObjectArray(size, JniConstants::stringClass, NULL));
290    for (int32_t i = 0; i < size ; i++) {
291        ScopedLocalRef<jstring> s(env, env->NewString(valueArray[i].getBuffer(),valueArray[i].length()));
292        if (env->ExceptionCheck()) {
293            return;
294        }
295        env->SetObjectArrayElement(result.get(), i, s.get());
296        if (env->ExceptionCheck()) {
297            return;
298        }
299    }
300    setStringArrayField(env, obj, fieldName, result.get());
301}
302
303static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, UResourceBundle* bundle, int index) {
304  UErrorCode status = U_ZERO_ERROR;
305  int charCount;
306  const UChar* chars = ures_getStringByIndex(bundle, index, &charCount, &status);
307  if (U_SUCCESS(status)) {
308    setStringField(env, obj, fieldName, env->NewString(chars, charCount));
309  } else {
310    ALOGE("Error setting String field %s from ICU resource (index %d): %s", fieldName, index, u_errorName(status));
311  }
312}
313
314static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, UResourceBundle* bundle, const char* key) {
315  UErrorCode status = U_ZERO_ERROR;
316  int charCount;
317  const UChar* chars = ures_getStringByKey(bundle, key, &charCount, &status);
318  if (U_SUCCESS(status)) {
319    setStringField(env, obj, fieldName, env->NewString(chars, charCount));
320  } else {
321    ALOGE("Error setting String field %s from ICU resource (key %s): %s", fieldName, key, u_errorName(status));
322  }
323}
324
325static void setCharField(JNIEnv* env, jobject obj, const char* fieldName, const UnicodeString& value) {
326    if (value.length() == 0) {
327        return;
328    }
329    jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "C");
330    env->SetCharField(obj, fid, value.charAt(0));
331}
332
333static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, const UnicodeString& value) {
334    const UChar* chars = value.getBuffer();
335    setStringField(env, obj, fieldName, env->NewString(chars, value.length()));
336}
337
338static void setNumberPatterns(JNIEnv* env, jobject obj, Locale& locale) {
339    UErrorCode status = U_ZERO_ERROR;
340
341    UnicodeString pattern;
342    UniquePtr<DecimalFormat> fmt(static_cast<DecimalFormat*>(NumberFormat::createInstance(locale, UNUM_CURRENCY, status)));
343    pattern = fmt->toPattern(pattern.remove());
344    setStringField(env, obj, "currencyPattern", pattern);
345
346    fmt.reset(static_cast<DecimalFormat*>(NumberFormat::createInstance(locale, UNUM_DECIMAL, status)));
347    pattern = fmt->toPattern(pattern.remove());
348    setStringField(env, obj, "numberPattern", pattern);
349
350    fmt.reset(static_cast<DecimalFormat*>(NumberFormat::createInstance(locale, UNUM_PERCENT, status)));
351    pattern = fmt->toPattern(pattern.remove());
352    setStringField(env, obj, "percentPattern", pattern);
353}
354
355static void setDecimalFormatSymbolsData(JNIEnv* env, jobject obj, Locale& locale) {
356    UErrorCode status = U_ZERO_ERROR;
357    DecimalFormatSymbols dfs(locale, status);
358
359    setCharField(env, obj, "decimalSeparator", dfs.getSymbol(DecimalFormatSymbols::kDecimalSeparatorSymbol));
360    setCharField(env, obj, "groupingSeparator", dfs.getSymbol(DecimalFormatSymbols::kGroupingSeparatorSymbol));
361    setCharField(env, obj, "patternSeparator", dfs.getSymbol(DecimalFormatSymbols::kPatternSeparatorSymbol));
362    setCharField(env, obj, "percent", dfs.getSymbol(DecimalFormatSymbols::kPercentSymbol));
363    setCharField(env, obj, "perMill", dfs.getSymbol(DecimalFormatSymbols::kPerMillSymbol));
364    setCharField(env, obj, "monetarySeparator", dfs.getSymbol(DecimalFormatSymbols::kMonetarySeparatorSymbol));
365    setCharField(env, obj, "minusSign", dfs.getSymbol(DecimalFormatSymbols:: kMinusSignSymbol));
366    setStringField(env, obj, "exponentSeparator", dfs.getSymbol(DecimalFormatSymbols::kExponentialSymbol));
367    setStringField(env, obj, "infinity", dfs.getSymbol(DecimalFormatSymbols::kInfinitySymbol));
368    setStringField(env, obj, "NaN", dfs.getSymbol(DecimalFormatSymbols::kNaNSymbol));
369    setCharField(env, obj, "zeroDigit", dfs.getSymbol(DecimalFormatSymbols::kZeroDigitSymbol));
370}
371
372
373// Iterates up through the locale hierarchy. So "en_US" would return "en_US", "en", "".
374class LocaleNameIterator {
375 public:
376  LocaleNameIterator(const char* locale_name, UErrorCode& status) : status_(status), has_next_(true) {
377    strcpy(locale_name_, locale_name);
378    locale_name_length_ = strlen(locale_name_);
379  }
380
381  const char* Get() {
382      return locale_name_;
383  }
384
385  bool HasNext() {
386    return has_next_;
387  }
388
389  void Up() {
390    locale_name_length_ = uloc_getParent(locale_name_, locale_name_, sizeof(locale_name_), &status_);
391    if (locale_name_length_ == 0) {
392      has_next_ = false;
393    }
394  }
395
396 private:
397  UErrorCode& status_;
398  bool has_next_;
399  char locale_name_[ULOC_FULLNAME_CAPACITY];
400  int32_t locale_name_length_;
401
402  DISALLOW_COPY_AND_ASSIGN(LocaleNameIterator);
403};
404
405static bool getDateTimePatterns(JNIEnv* env, jobject localeData, const char* locale_name) {
406  UErrorCode status = U_ZERO_ERROR;
407  ScopedResourceBundle root(ures_open(NULL, locale_name, &status));
408  if (U_FAILURE(status)) {
409    return false;
410  }
411  ScopedResourceBundle calendar(ures_getByKey(root.get(), "calendar", NULL, &status));
412  if (U_FAILURE(status)) {
413    return false;
414  }
415  ScopedResourceBundle gregorian(ures_getByKey(calendar.get(), "gregorian", NULL, &status));
416  if (U_FAILURE(status)) {
417    return false;
418  }
419  ScopedResourceBundle dateTimePatterns(ures_getByKey(gregorian.get(), "DateTimePatterns", NULL, &status));
420  if (U_FAILURE(status)) {
421    return false;
422  }
423  setStringField(env, localeData, "fullTimeFormat", dateTimePatterns.get(), 0);
424  setStringField(env, localeData, "longTimeFormat", dateTimePatterns.get(), 1);
425  setStringField(env, localeData, "mediumTimeFormat", dateTimePatterns.get(), 2);
426  setStringField(env, localeData, "shortTimeFormat", dateTimePatterns.get(), 3);
427  setStringField(env, localeData, "fullDateFormat", dateTimePatterns.get(), 4);
428  setStringField(env, localeData, "longDateFormat", dateTimePatterns.get(), 5);
429  setStringField(env, localeData, "mediumDateFormat", dateTimePatterns.get(), 6);
430  setStringField(env, localeData, "shortDateFormat", dateTimePatterns.get(), 7);
431  return true;
432}
433
434static bool getYesterdayTodayAndTomorrow(JNIEnv* env, jobject localeData, const char* locale_name) {
435  UErrorCode status = U_ZERO_ERROR;
436  ScopedResourceBundle root(ures_open(NULL, locale_name, &status));
437  if (U_FAILURE(status)) {
438    return false;
439  }
440  ScopedResourceBundle calendar(ures_getByKey(root.get(), "calendar", NULL, &status));
441  if (U_FAILURE(status)) {
442    return false;
443  }
444  ScopedResourceBundle gregorian(ures_getByKey(calendar.get(), "gregorian", NULL, &status));
445  if (U_FAILURE(status)) {
446    return false;
447  }
448  ScopedResourceBundle fields(ures_getByKey(gregorian.get(), "fields", NULL, &status));
449  if (U_FAILURE(status)) {
450    return false;
451  }
452  ScopedResourceBundle day(ures_getByKey(fields.get(), "day", NULL, &status));
453  if (U_FAILURE(status)) {
454    return false;
455  }
456  ScopedResourceBundle relative(ures_getByKey(day.get(), "relative", NULL, &status));
457  if (U_FAILURE(status)) {
458    return false;
459  }
460  // bn_BD only has a "-2" entry.
461  if (relative.hasKey("-1") && relative.hasKey("0") && relative.hasKey("1")) {
462    setStringField(env, localeData, "yesterday", relative.get(), "-1");
463    setStringField(env, localeData, "today", relative.get(), "0");
464    setStringField(env, localeData, "tomorrow", relative.get(), "1");
465    return true;
466  }
467  return false;
468}
469
470static jboolean ICU_initLocaleDataImpl(JNIEnv* env, jclass, jstring javaLocaleName, jobject localeData) {
471    ScopedUtfChars localeName(env, javaLocaleName);
472    if (localeName.c_str() == NULL) {
473        return JNI_FALSE;
474    }
475    if (localeName.size() >= ULOC_FULLNAME_CAPACITY) {
476        return JNI_FALSE; // ICU has a fixed-length limit.
477    }
478
479    // Get the DateTimePatterns.
480    UErrorCode status = U_ZERO_ERROR;
481    bool foundDateTimePatterns = false;
482    for (LocaleNameIterator it(localeName.c_str(), status); it.HasNext(); it.Up()) {
483      if (getDateTimePatterns(env, localeData, it.Get())) {
484          foundDateTimePatterns = true;
485          break;
486      }
487    }
488    if (!foundDateTimePatterns) {
489        ALOGE("Couldn't find ICU DateTimePatterns for %s", localeName.c_str());
490        return JNI_FALSE;
491    }
492
493    // Get the "Yesterday", "Today", and "Tomorrow" strings.
494    bool foundYesterdayTodayAndTomorrow = false;
495    for (LocaleNameIterator it(localeName.c_str(), status); it.HasNext(); it.Up()) {
496      if (getYesterdayTodayAndTomorrow(env, localeData, it.Get())) {
497        foundYesterdayTodayAndTomorrow = true;
498        break;
499      }
500    }
501    if (!foundYesterdayTodayAndTomorrow) {
502      ALOGE("Couldn't find ICU yesterday/today/tomorrow for %s", localeName.c_str());
503      return JNI_FALSE;
504    }
505
506    status = U_ZERO_ERROR;
507    Locale locale = getLocale(env, javaLocaleName);
508    UniquePtr<Calendar> cal(Calendar::createInstance(locale, status));
509    if (U_FAILURE(status)) {
510        return JNI_FALSE;
511    }
512
513    setIntegerField(env, localeData, "firstDayOfWeek", cal->getFirstDayOfWeek());
514    setIntegerField(env, localeData, "minimalDaysInFirstWeek", cal->getMinimalDaysInFirstWeek());
515
516    // Get DateFormatSymbols.
517    status = U_ZERO_ERROR;
518    DateFormatSymbols dateFormatSym(locale, status);
519    if (U_FAILURE(status)) {
520        return JNI_FALSE;
521    }
522
523    // Get AM/PM and BC/AD.
524    int32_t count = 0;
525    const UnicodeString* amPmStrs = dateFormatSym.getAmPmStrings(count);
526    setStringArrayField(env, localeData, "amPm", amPmStrs, count);
527    const UnicodeString* erasStrs = dateFormatSym.getEras(count);
528    setStringArrayField(env, localeData, "eras", erasStrs, count);
529
530    const UnicodeString* longMonthNames =
531       dateFormatSym.getMonths(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
532    setStringArrayField(env, localeData, "longMonthNames", longMonthNames, count);
533    const UnicodeString* shortMonthNames =
534        dateFormatSym.getMonths(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
535    setStringArrayField(env, localeData, "shortMonthNames", shortMonthNames, count);
536    const UnicodeString* tinyMonthNames =
537        dateFormatSym.getMonths(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
538    setStringArrayField(env, localeData, "tinyMonthNames", tinyMonthNames, count);
539    const UnicodeString* longWeekdayNames =
540        dateFormatSym.getWeekdays(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
541    setStringArrayField(env, localeData, "longWeekdayNames", longWeekdayNames, count);
542    const UnicodeString* shortWeekdayNames =
543        dateFormatSym.getWeekdays(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
544    setStringArrayField(env, localeData, "shortWeekdayNames", shortWeekdayNames, count);
545    const UnicodeString* tinyWeekdayNames =
546        dateFormatSym.getWeekdays(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
547    setStringArrayField(env, localeData, "tinyWeekdayNames", tinyWeekdayNames, count);
548
549    const UnicodeString* longStandAloneMonthNames =
550        dateFormatSym.getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
551    setStringArrayField(env, localeData, "longStandAloneMonthNames", longStandAloneMonthNames, count);
552    const UnicodeString* shortStandAloneMonthNames =
553        dateFormatSym.getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
554    setStringArrayField(env, localeData, "shortStandAloneMonthNames", shortStandAloneMonthNames, count);
555    const UnicodeString* tinyStandAloneMonthNames =
556        dateFormatSym.getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::NARROW);
557    setStringArrayField(env, localeData, "tinyStandAloneMonthNames", tinyStandAloneMonthNames, count);
558    const UnicodeString* longStandAloneWeekdayNames =
559        dateFormatSym.getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
560    setStringArrayField(env, localeData, "longStandAloneWeekdayNames", longStandAloneWeekdayNames, count);
561    const UnicodeString* shortStandAloneWeekdayNames =
562        dateFormatSym.getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
563    setStringArrayField(env, localeData, "shortStandAloneWeekdayNames", shortStandAloneWeekdayNames, count);
564    const UnicodeString* tinyStandAloneWeekdayNames =
565        dateFormatSym.getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::NARROW);
566    setStringArrayField(env, localeData, "tinyStandAloneWeekdayNames", tinyStandAloneWeekdayNames, count);
567
568    status = U_ZERO_ERROR;
569
570    // For numberPatterns and symbols.
571    setNumberPatterns(env, localeData, locale);
572    setDecimalFormatSymbolsData(env, localeData, locale);
573
574    jstring countryCode = env->NewStringUTF(Locale::createFromName(localeName.c_str()).getCountry());
575    jstring internationalCurrencySymbol = ICU_getCurrencyCode(env, NULL, countryCode);
576    env->DeleteLocalRef(countryCode);
577    countryCode = NULL;
578
579    jstring currencySymbol = NULL;
580    if (internationalCurrencySymbol != NULL) {
581        currencySymbol = ICU_getCurrencySymbol(env, NULL, javaLocaleName, internationalCurrencySymbol);
582    } else {
583        internationalCurrencySymbol = env->NewStringUTF("XXX");
584    }
585    if (currencySymbol == NULL) {
586        // This is the UTF-8 encoding of U+00A4 (CURRENCY SIGN).
587        currencySymbol = env->NewStringUTF("\xc2\xa4");
588    }
589    setStringField(env, localeData, "currencySymbol", currencySymbol);
590    setStringField(env, localeData, "internationalCurrencySymbol", internationalCurrencySymbol);
591
592    return JNI_TRUE;
593}
594
595static jstring ICU_toLowerCase(JNIEnv* env, jclass, jstring javaString, jstring localeName) {
596    ScopedJavaUnicodeString scopedString(env, javaString);
597    UnicodeString& s(scopedString.unicodeString());
598    UnicodeString original(s);
599    s.toLower(Locale::createFromName(ScopedUtfChars(env, localeName).c_str()));
600    return s == original ? javaString : env->NewString(s.getBuffer(), s.length());
601}
602
603static jstring ICU_toUpperCase(JNIEnv* env, jclass, jstring javaString, jstring localeName) {
604    ScopedJavaUnicodeString scopedString(env, javaString);
605    UnicodeString& s(scopedString.unicodeString());
606    UnicodeString original(s);
607    s.toUpper(Locale::createFromName(ScopedUtfChars(env, localeName).c_str()));
608    return s == original ? javaString : env->NewString(s.getBuffer(), s.length());
609}
610
611static jstring versionString(JNIEnv* env, const UVersionInfo& version) {
612    char versionString[U_MAX_VERSION_STRING_LENGTH];
613    u_versionToString(const_cast<UVersionInfo&>(version), &versionString[0]);
614    return env->NewStringUTF(versionString);
615}
616
617static jstring ICU_getIcuVersion(JNIEnv* env, jclass) {
618    UVersionInfo icuVersion;
619    u_getVersion(icuVersion);
620    return versionString(env, icuVersion);
621}
622
623static jstring ICU_getUnicodeVersion(JNIEnv* env, jclass) {
624    UVersionInfo unicodeVersion;
625    u_getUnicodeVersion(unicodeVersion);
626    return versionString(env, unicodeVersion);
627}
628
629
630struct EnumerationCounter {
631    const size_t count;
632    EnumerationCounter(size_t count) : count(count) {}
633    size_t operator()() { return count; }
634};
635struct EnumerationGetter {
636    UEnumeration* e;
637    UErrorCode* status;
638    EnumerationGetter(UEnumeration* e, UErrorCode* status) : e(e), status(status) {}
639    const UChar* operator()(int32_t* charCount) { return uenum_unext(e, charCount, status); }
640};
641static jobject ICU_getAvailableCurrencyCodes(JNIEnv* env, jclass) {
642    UErrorCode status = U_ZERO_ERROR;
643    UEnumeration* e(ucurr_openISOCurrencies(UCURR_COMMON|UCURR_NON_DEPRECATED, &status));
644    EnumerationCounter counter(uenum_count(e, &status));
645    if (maybeThrowIcuException(env, "uenum_count", status)) {
646        return NULL;
647    }
648    EnumerationGetter getter(e, &status);
649    jobject result = toStringArray16(env, &counter, &getter);
650    maybeThrowIcuException(env, "uenum_unext", status);
651    uenum_close(e);
652    return result;
653}
654
655static jstring ICU_getBestDateTimePattern(JNIEnv* env, jclass, jstring javaPattern, jstring javaLocaleName) {
656  Locale locale = getLocale(env, javaLocaleName);
657  UErrorCode status = U_ZERO_ERROR;
658  DateTimePatternGenerator* generator = DateTimePatternGenerator::createInstance(locale, status);
659  if (maybeThrowIcuException(env, "DateTimePatternGenerator::createInstance", status)) {
660    return NULL;
661  }
662
663  ScopedJavaUnicodeString patternHolder(env, javaPattern);
664  UnicodeString result(generator->getBestPattern(patternHolder.unicodeString(), status));
665  if (maybeThrowIcuException(env, "DateTimePatternGenerator::getBestPattern", status)) {
666    return NULL;
667  }
668
669  return env->NewString(result.getBuffer(), result.length());
670}
671
672static JNINativeMethod gMethods[] = {
673    NATIVE_METHOD(ICU, addLikelySubtags, "(Ljava/lang/String;)Ljava/lang/String;"),
674    NATIVE_METHOD(ICU, getAvailableBreakIteratorLocalesNative, "()[Ljava/lang/String;"),
675    NATIVE_METHOD(ICU, getAvailableCalendarLocalesNative, "()[Ljava/lang/String;"),
676    NATIVE_METHOD(ICU, getAvailableCollatorLocalesNative, "()[Ljava/lang/String;"),
677    NATIVE_METHOD(ICU, getAvailableCurrencyCodes, "()[Ljava/lang/String;"),
678    NATIVE_METHOD(ICU, getAvailableDateFormatLocalesNative, "()[Ljava/lang/String;"),
679    NATIVE_METHOD(ICU, getAvailableLocalesNative, "()[Ljava/lang/String;"),
680    NATIVE_METHOD(ICU, getAvailableNumberFormatLocalesNative, "()[Ljava/lang/String;"),
681    NATIVE_METHOD(ICU, getBestDateTimePattern, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
682    NATIVE_METHOD(ICU, getCurrencyCode, "(Ljava/lang/String;)Ljava/lang/String;"),
683    NATIVE_METHOD(ICU, getCurrencyDisplayName, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
684    NATIVE_METHOD(ICU, getCurrencyFractionDigits, "(Ljava/lang/String;)I"),
685    NATIVE_METHOD(ICU, getCurrencySymbol, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
686    NATIVE_METHOD(ICU, getDisplayCountryNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
687    NATIVE_METHOD(ICU, getDisplayLanguageNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
688    NATIVE_METHOD(ICU, getDisplayVariantNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
689    NATIVE_METHOD(ICU, getISO3CountryNative, "(Ljava/lang/String;)Ljava/lang/String;"),
690    NATIVE_METHOD(ICU, getISO3LanguageNative, "(Ljava/lang/String;)Ljava/lang/String;"),
691    NATIVE_METHOD(ICU, getISOCountriesNative, "()[Ljava/lang/String;"),
692    NATIVE_METHOD(ICU, getISOLanguagesNative, "()[Ljava/lang/String;"),
693    NATIVE_METHOD(ICU, getIcuVersion, "()Ljava/lang/String;"),
694    NATIVE_METHOD(ICU, getScript, "(Ljava/lang/String;)Ljava/lang/String;"),
695    NATIVE_METHOD(ICU, getUnicodeVersion, "()Ljava/lang/String;"),
696    NATIVE_METHOD(ICU, initLocaleDataImpl, "(Ljava/lang/String;Llibcore/icu/LocaleData;)Z"),
697    NATIVE_METHOD(ICU, toLowerCase, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
698    NATIVE_METHOD(ICU, toUpperCase, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
699};
700void register_libcore_icu_ICU(JNIEnv* env) {
701    std::string path;
702    path = u_getDataDirectory();
703    path += "/";
704    path += U_ICUDATA_NAME;
705    path += ".dat";
706
707    #define FAIL_WITH_STRERROR(s) \
708        ALOGE("Couldn't " s " '%s': %s", path.c_str(), strerror(errno)); \
709        abort();
710    #define MAYBE_FAIL_WITH_ICU_ERROR(s) \
711        if (status != U_ZERO_ERROR) {\
712            ALOGE("Couldn't initialize ICU (" s "): %s (%s)", u_errorName(status), path.c_str()); \
713            abort(); \
714        }
715
716    // Open the file and get its length.
717    ScopedFd fd(open(path.c_str(), O_RDONLY));
718    if (fd.get() == -1) {
719        FAIL_WITH_STRERROR("open");
720    }
721    struct stat sb;
722    if (fstat(fd.get(), &sb) == -1) {
723        FAIL_WITH_STRERROR("stat");
724    }
725
726    // Map it.
727    void* data = mmap(NULL, sb.st_size, PROT_READ, MAP_SHARED, fd.get(), 0);
728    if (data == MAP_FAILED) {
729        FAIL_WITH_STRERROR("mmap");
730    }
731
732    // Tell the kernel that accesses are likely to be random rather than sequential.
733    if (madvise(data, sb.st_size, MADV_RANDOM) == -1) {
734        FAIL_WITH_STRERROR("madvise(MADV_RANDOM)");
735    }
736
737    // Tell ICU to use our memory-mapped data.
738    UErrorCode status = U_ZERO_ERROR;
739    udata_setCommonData(data, &status);
740    MAYBE_FAIL_WITH_ICU_ERROR("udata_setCommonData");
741    // Tell ICU it can *only* use our memory-mapped data.
742    udata_setFileAccess(UDATA_NO_FILES, &status);
743    MAYBE_FAIL_WITH_ICU_ERROR("udata_setFileAccess");
744
745    // Failures to find the ICU data tend to be somewhat obscure because ICU loads its data on first
746    // use, which can be anywhere. Force initialization up front so we can report a nice clear error
747    // and bail.
748    u_init(&status);
749    MAYBE_FAIL_WITH_ICU_ERROR("u_init");
750    jniRegisterNativeMethods(env, "libcore/icu/ICU", gMethods, NELEM(gMethods));
751}
752