src/v8/src/i18n.cc

   1 // Copyright 2013 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4 // limitations under the License.
   5
   6 #include "src/i18n.h"
   7
   8 #include "unicode/brkiter.h"
   9 #include "unicode/calendar.h"
  10 #include "unicode/coll.h"
  11 #include "unicode/curramt.h"
  12 #include "unicode/dcfmtsym.h"
  13 #include "unicode/decimfmt.h"
  14 #include "unicode/dtfmtsym.h"
  15 #include "unicode/dtptngen.h"
  16 #include "unicode/locid.h"
  17 #include "unicode/numfmt.h"
  18 #include "unicode/numsys.h"
  19 #include "unicode/rbbi.h"
  20 #include "unicode/smpdtfmt.h"
  21 #include "unicode/timezone.h"
  22 #include "unicode/uchar.h"
  23 #include "unicode/ucol.h"
  24 #include "unicode/ucurr.h"
  25 #include "unicode/unum.h"
  26 #include "unicode/uversion.h"
  27
  28 namespace v8 {
  29 namespace internal {
  30
  31 namespace {
  32
  33 bool ExtractStringSetting(Isolate* isolate,
  34                           Handle<JSObject> options,
  35                           const char* key,
  36                           icu::UnicodeString* setting) {
  37   Handle<String> str = isolate->factory()->NewStringFromAsciiChecked(key);
  38   Handle<Object> object = Object::GetProperty(options, str).ToHandleChecked();
  39   if (object->IsString()) {
  40     v8::String::Utf8Value utf8_string(
  41         v8::Utils::ToLocal(Handle<String>::cast(object)));
  42     *setting = icu::UnicodeString::fromUTF8(*utf8_string);
  43     return true;
  44   }
  45   return false;
  46 }
  47
  48
  49 bool ExtractIntegerSetting(Isolate* isolate,
  50                            Handle<JSObject> options,
  51                            const char* key,
  52                            int32_t* value) {
  53   Handle<String> str = isolate->factory()->NewStringFromAsciiChecked(key);
  54   Handle<Object> object = Object::GetProperty(options, str).ToHandleChecked();
  55   if (object->IsNumber()) {
  56     object->ToInt32(value);
  57     return true;
  58   }
  59   return false;
  60 }
  61
  62
  63 bool ExtractBooleanSetting(Isolate* isolate,
  64                            Handle<JSObject> options,
  65                            const char* key,
  66                            bool* value) {
  67   Handle<String> str = isolate->factory()->NewStringFromAsciiChecked(key);
  68   Handle<Object> object = Object::GetProperty(options, str).ToHandleChecked();
  69   if (object->IsBoolean()) {
  70     *value = object->BooleanValue();
  71     return true;
  72   }
  73   return false;
  74 }
  75
  76
  77 icu::SimpleDateFormat* CreateICUDateFormat(
  78     Isolate* isolate,
  79     const icu::Locale& icu_locale,
  80     Handle<JSObject> options) {
  81   // Create time zone as specified by the user. We have to re-create time zone
  82   // since calendar takes ownership.
  83   icu::TimeZone* tz = NULL;
  84   icu::UnicodeString timezone;
  85   if (ExtractStringSetting(isolate, options, "timeZone", &timezone)) {
  86     tz = icu::TimeZone::createTimeZone(timezone);
  87   } else {
  88     tz = icu::TimeZone::createDefault();
  89   }
  90
  91   // Create a calendar using locale, and apply time zone to it.
  92   UErrorCode status = U_ZERO_ERROR;
  93   icu::Calendar* calendar =
  94       icu::Calendar::createInstance(tz, icu_locale, status);
  95
  96   // Make formatter from skeleton. Calendar and numbering system are added
  97   // to the locale as Unicode extension (if they were specified at all).
  98   icu::SimpleDateFormat* date_format = NULL;
  99   icu::UnicodeString skeleton;
 100   if (ExtractStringSetting(isolate, options, "skeleton", &skeleton)) {
 101     icu::DateTimePatternGenerator* generator =
 102         icu::DateTimePatternGenerator::createInstance(icu_locale, status);
 103     icu::UnicodeString pattern;
 104     if (U_SUCCESS(status)) {
 105       pattern = generator->getBestPattern(skeleton, status);
 106       delete generator;
 107     }
 108
 109     date_format = new icu::SimpleDateFormat(pattern, icu_locale, status);
 110     if (U_SUCCESS(status)) {
 111       date_format->adoptCalendar(calendar);
 112     }
 113   }
 114
 115   if (U_FAILURE(status)) {
 116     delete calendar;
 117     delete date_format;
 118     date_format = NULL;
 119   }
 120
 121   return date_format;
 122 }
 123
 124
 125 void SetResolvedDateSettings(Isolate* isolate,
 126                              const icu::Locale& icu_locale,
 127                              icu::SimpleDateFormat* date_format,
 128                              Handle<JSObject> resolved) {
 129   Factory* factory = isolate->factory();
 130   UErrorCode status = U_ZERO_ERROR;
 131   icu::UnicodeString pattern;
 132   date_format->toPattern(pattern);
 133   JSObject::SetProperty(
 134       resolved, factory->NewStringFromStaticChars("pattern"),
 135       factory->NewStringFromTwoByte(
 136                    Vector<const uint16_t>(
 137                        reinterpret_cast<const uint16_t*>(pattern.getBuffer()),
 138                        pattern.length())).ToHandleChecked(),
 139       SLOPPY).Assert();
 140
 141   // Set time zone and calendar.
 142   const icu::Calendar* calendar = date_format->getCalendar();
 143   const char* calendar_name = calendar->getType();
 144   JSObject::SetProperty(resolved, factory->NewStringFromStaticChars("calendar"),
 145                         factory->NewStringFromAsciiChecked(calendar_name),
 146                         SLOPPY).Assert();
 147
 148   const icu::TimeZone& tz = calendar->getTimeZone();
 149   icu::UnicodeString time_zone;
 150   tz.getID(time_zone);
 151
 152   icu::UnicodeString canonical_time_zone;
 153   icu::TimeZone::getCanonicalID(time_zone, canonical_time_zone, status);
 154   if (U_SUCCESS(status)) {
 155     if (canonical_time_zone == UNICODE_STRING_SIMPLE("Etc/GMT")) {
 156       JSObject::SetProperty(
 157           resolved, factory->NewStringFromStaticChars("timeZone"),
 158           factory->NewStringFromStaticChars("UTC"), SLOPPY).Assert();
 159     } else {
 160       JSObject::SetProperty(
 161           resolved, factory->NewStringFromStaticChars("timeZone"),
 162           factory->NewStringFromTwoByte(
 163                        Vector<const uint16_t>(
 164                            reinterpret_cast<const uint16_t*>(
 165                                canonical_time_zone.getBuffer()),
 166                            canonical_time_zone.length())).ToHandleChecked(),
 167           SLOPPY).Assert();
 168     }
 169   }
 170
 171   // Ugly hack. ICU doesn't expose numbering system in any way, so we have
 172   // to assume that for given locale NumberingSystem constructor produces the
 173   // same digits as NumberFormat/Calendar would.
 174   status = U_ZERO_ERROR;
 175   icu::NumberingSystem* numbering_system =
 176       icu::NumberingSystem::createInstance(icu_locale, status);
 177   if (U_SUCCESS(status)) {
 178     const char* ns = numbering_system->getName();
 179     JSObject::SetProperty(
 180         resolved, factory->NewStringFromStaticChars("numberingSystem"),
 181         factory->NewStringFromAsciiChecked(ns), SLOPPY).Assert();
 182   } else {
 183     JSObject::SetProperty(resolved,
 184                           factory->NewStringFromStaticChars("numberingSystem"),
 185                           factory->undefined_value(), SLOPPY).Assert();
 186   }
 187   delete numbering_system;
 188
 189   // Set the locale
 190   char result[ULOC_FULLNAME_CAPACITY];
 191   status = U_ZERO_ERROR;
 192   uloc_toLanguageTag(
 193       icu_locale.getName(), result, ULOC_FULLNAME_CAPACITY, FALSE, &status);
 194   if (U_SUCCESS(status)) {
 195     JSObject::SetProperty(resolved, factory->NewStringFromStaticChars("locale"),
 196                           factory->NewStringFromAsciiChecked(result),
 197                           SLOPPY).Assert();
 198   } else {
 199     // This would never happen, since we got the locale from ICU.
 200     JSObject::SetProperty(resolved, factory->NewStringFromStaticChars("locale"),
 201                           factory->NewStringFromStaticChars("und"),
 202                           SLOPPY).Assert();
 203   }
 204 }
 205
 206
 207 template<int internal_fields, EternalHandles::SingletonHandle field>
 208 Handle<ObjectTemplateInfo> GetEternal(Isolate* isolate) {
 209   if (isolate->eternal_handles()->Exists(field)) {
 210     return Handle<ObjectTemplateInfo>::cast(
 211         isolate->eternal_handles()->GetSingleton(field));
 212   }
 213   v8::Local<v8::ObjectTemplate> raw_template =
 214       v8::ObjectTemplate::New(reinterpret_cast<v8::Isolate*>(isolate));
 215   raw_template->SetInternalFieldCount(internal_fields);
 216   return Handle<ObjectTemplateInfo>::cast(
 217       isolate->eternal_handles()->CreateSingleton(
 218         isolate,
 219         *v8::Utils::OpenHandle(*raw_template),
 220         field));
 221 }
 222
 223
 224 icu::DecimalFormat* CreateICUNumberFormat(
 225     Isolate* isolate,
 226     const icu::Locale& icu_locale,
 227     Handle<JSObject> options) {
 228   // Make formatter from options. Numbering system is added
 229   // to the locale as Unicode extension (if it was specified at all).
 230   UErrorCode status = U_ZERO_ERROR;
 231   icu::DecimalFormat* number_format = NULL;
 232   icu::UnicodeString style;
 233   icu::UnicodeString currency;
 234   if (ExtractStringSetting(isolate, options, "style", &style)) {
 235     if (style == UNICODE_STRING_SIMPLE("currency")) {
 236       icu::UnicodeString display;
 237       ExtractStringSetting(isolate, options, "currency", &currency);
 238       ExtractStringSetting(isolate, options, "currencyDisplay", &display);
 239
 240 #if (U_ICU_VERSION_MAJOR_NUM == 4) && (U_ICU_VERSION_MINOR_NUM <= 6)
 241       icu::NumberFormat::EStyles format_style;
 242       if (display == UNICODE_STRING_SIMPLE("code")) {
 243         format_style = icu::NumberFormat::kIsoCurrencyStyle;
 244       } else if (display == UNICODE_STRING_SIMPLE("name")) {
 245         format_style = icu::NumberFormat::kPluralCurrencyStyle;
 246       } else {
 247         format_style = icu::NumberFormat::kCurrencyStyle;
 248       }
 249 #else  // ICU version is 4.8 or above (we ignore versions below 4.0).
 250       UNumberFormatStyle format_style;
 251       if (display == UNICODE_STRING_SIMPLE("code")) {
 252         format_style = UNUM_CURRENCY_ISO;
 253       } else if (display == UNICODE_STRING_SIMPLE("name")) {
 254         format_style = UNUM_CURRENCY_PLURAL;
 255       } else {
 256         format_style = UNUM_CURRENCY;
 257       }
 258 #endif
 259
 260       number_format = static_cast<icu::DecimalFormat*>(
 261           icu::NumberFormat::createInstance(icu_locale, format_style,  status));
 262     } else if (style == UNICODE_STRING_SIMPLE("percent")) {
 263       number_format = static_cast<icu::DecimalFormat*>(
 264           icu::NumberFormat::createPercentInstance(icu_locale, status));
 265       if (U_FAILURE(status)) {
 266         delete number_format;
 267         return NULL;
 268       }
 269       // Make sure 1.1% doesn't go into 2%.
 270       number_format->setMinimumFractionDigits(1);
 271     } else {
 272       // Make a decimal instance by default.
 273       number_format = static_cast<icu::DecimalFormat*>(
 274           icu::NumberFormat::createInstance(icu_locale, status));
 275     }
 276   }
 277
 278   if (U_FAILURE(status)) {
 279     delete number_format;
 280     return NULL;
 281   }
 282
 283   // Set all options.
 284   if (!currency.isEmpty()) {
 285     number_format->setCurrency(currency.getBuffer(), status);
 286   }
 287
 288   int32_t digits;
 289   if (ExtractIntegerSetting(
 290           isolate, options, "minimumIntegerDigits", &digits)) {
 291     number_format->setMinimumIntegerDigits(digits);
 292   }
 293
 294   if (ExtractIntegerSetting(
 295           isolate, options, "minimumFractionDigits", &digits)) {
 296     number_format->setMinimumFractionDigits(digits);
 297   }
 298
 299   if (ExtractIntegerSetting(
 300           isolate, options, "maximumFractionDigits", &digits)) {
 301     number_format->setMaximumFractionDigits(digits);
 302   }
 303
 304   bool significant_digits_used = false;
 305   if (ExtractIntegerSetting(
 306           isolate, options, "minimumSignificantDigits", &digits)) {
 307     number_format->setMinimumSignificantDigits(digits);
 308     significant_digits_used = true;
 309   }
 310
 311   if (ExtractIntegerSetting(
 312           isolate, options, "maximumSignificantDigits", &digits)) {
 313     number_format->setMaximumSignificantDigits(digits);
 314     significant_digits_used = true;
 315   }
 316
 317   number_format->setSignificantDigitsUsed(significant_digits_used);
 318
 319   bool grouping;
 320   if (ExtractBooleanSetting(isolate, options, "useGrouping", &grouping)) {
 321     number_format->setGroupingUsed(grouping);
 322   }
 323
 324   // Set rounding mode.
 325   number_format->setRoundingMode(icu::DecimalFormat::kRoundHalfUp);
 326
 327   return number_format;
 328 }
 329
 330
 331 void SetResolvedNumberSettings(Isolate* isolate,
 332                                const icu::Locale& icu_locale,
 333                                icu::DecimalFormat* number_format,
 334                                Handle<JSObject> resolved) {
 335   Factory* factory = isolate->factory();
 336   icu::UnicodeString pattern;
 337   number_format->toPattern(pattern);
 338   JSObject::SetProperty(
 339       resolved, factory->NewStringFromStaticChars("pattern"),
 340       factory->NewStringFromTwoByte(
 341                    Vector<const uint16_t>(
 342                        reinterpret_cast<const uint16_t*>(pattern.getBuffer()),
 343                        pattern.length())).ToHandleChecked(),
 344       SLOPPY).Assert();
 345
 346   // Set resolved currency code in options.currency if not empty.
 347   icu::UnicodeString currency(number_format->getCurrency());
 348   if (!currency.isEmpty()) {
 349     JSObject::SetProperty(
 350         resolved, factory->NewStringFromStaticChars("currency"),
 351         factory->NewStringFromTwoByte(Vector<const uint16_t>(
 352                                           reinterpret_cast<const uint16_t*>(
 353                                               currency.getBuffer()),
 354                                           currency.length())).ToHandleChecked(),
 355         SLOPPY).Assert();
 356   }
 357
 358   // Ugly hack. ICU doesn't expose numbering system in any way, so we have
 359   // to assume that for given locale NumberingSystem constructor produces the
 360   // same digits as NumberFormat/Calendar would.
 361   UErrorCode status = U_ZERO_ERROR;
 362   icu::NumberingSystem* numbering_system =
 363       icu::NumberingSystem::createInstance(icu_locale, status);
 364   if (U_SUCCESS(status)) {
 365     const char* ns = numbering_system->getName();
 366     JSObject::SetProperty(
 367         resolved, factory->NewStringFromStaticChars("numberingSystem"),
 368         factory->NewStringFromAsciiChecked(ns), SLOPPY).Assert();
 369   } else {
 370     JSObject::SetProperty(resolved,
 371                           factory->NewStringFromStaticChars("numberingSystem"),
 372                           factory->undefined_value(), SLOPPY).Assert();
 373   }
 374   delete numbering_system;
 375
 376   JSObject::SetProperty(
 377       resolved, factory->NewStringFromStaticChars("useGrouping"),
 378       factory->ToBoolean(number_format->isGroupingUsed()), SLOPPY).Assert();
 379
 380   JSObject::SetProperty(
 381       resolved, factory->NewStringFromStaticChars("minimumIntegerDigits"),
 382       factory->NewNumberFromInt(number_format->getMinimumIntegerDigits()),
 383       SLOPPY).Assert();
 384
 385   JSObject::SetProperty(
 386       resolved, factory->NewStringFromStaticChars("minimumFractionDigits"),
 387       factory->NewNumberFromInt(number_format->getMinimumFractionDigits()),
 388       SLOPPY).Assert();
 389
 390   JSObject::SetProperty(
 391       resolved, factory->NewStringFromStaticChars("maximumFractionDigits"),
 392       factory->NewNumberFromInt(number_format->getMaximumFractionDigits()),
 393       SLOPPY).Assert();
 394
 395   Handle<String> key =
 396       factory->NewStringFromStaticChars("minimumSignificantDigits");
 397   Maybe<bool> maybe = JSReceiver::HasOwnProperty(resolved, key);
 398   CHECK(maybe.has_value);
 399   if (maybe.value) {
 400     JSObject::SetProperty(
 401         resolved, factory->NewStringFromStaticChars("minimumSignificantDigits"),
 402         factory->NewNumberFromInt(number_format->getMinimumSignificantDigits()),
 403         SLOPPY).Assert();
 404   }
 405
 406   key = factory->NewStringFromStaticChars("maximumSignificantDigits");
 407   maybe = JSReceiver::HasOwnProperty(resolved, key);
 408   CHECK(maybe.has_value);
 409   if (maybe.value) {
 410     JSObject::SetProperty(
 411         resolved, factory->NewStringFromStaticChars("maximumSignificantDigits"),
 412         factory->NewNumberFromInt(number_format->getMaximumSignificantDigits()),
 413         SLOPPY).Assert();
 414   }
 415
 416   // Set the locale
 417   char result[ULOC_FULLNAME_CAPACITY];
 418   status = U_ZERO_ERROR;
 419   uloc_toLanguageTag(
 420       icu_locale.getName(), result, ULOC_FULLNAME_CAPACITY, FALSE, &status);
 421   if (U_SUCCESS(status)) {
 422     JSObject::SetProperty(resolved, factory->NewStringFromStaticChars("locale"),
 423                           factory->NewStringFromAsciiChecked(result),
 424                           SLOPPY).Assert();
 425   } else {
 426     // This would never happen, since we got the locale from ICU.
 427     JSObject::SetProperty(resolved, factory->NewStringFromStaticChars("locale"),
 428                           factory->NewStringFromStaticChars("und"),
 429                           SLOPPY).Assert();
 430   }
 431 }
 432
 433
 434 icu::Collator* CreateICUCollator(
 435     Isolate* isolate,
 436     const icu::Locale& icu_locale,
 437     Handle<JSObject> options) {
 438   // Make collator from options.
 439   icu::Collator* collator = NULL;
 440   UErrorCode status = U_ZERO_ERROR;
 441   collator = icu::Collator::createInstance(icu_locale, status);
 442
 443   if (U_FAILURE(status)) {
 444     delete collator;
 445     return NULL;
 446   }
 447
 448   // Set flags first, and then override them with sensitivity if necessary.
 449   bool numeric;
 450   if (ExtractBooleanSetting(isolate, options, "numeric", &numeric)) {
 451     collator->setAttribute(
 452         UCOL_NUMERIC_COLLATION, numeric ? UCOL_ON : UCOL_OFF, status);
 453   }
 454
 455   // Normalization is always on, by the spec. We are free to optimize
 456   // if the strings are already normalized (but we don't have a way to tell
 457   // that right now).
 458   collator->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
 459
 460   icu::UnicodeString case_first;
 461   if (ExtractStringSetting(isolate, options, "caseFirst", &case_first)) {
 462     if (case_first == UNICODE_STRING_SIMPLE("upper")) {
 463       collator->setAttribute(UCOL_CASE_FIRST, UCOL_UPPER_FIRST, status);
 464     } else if (case_first == UNICODE_STRING_SIMPLE("lower")) {
 465       collator->setAttribute(UCOL_CASE_FIRST, UCOL_LOWER_FIRST, status);
 466     } else {
 467       // Default (false/off).
 468       collator->setAttribute(UCOL_CASE_FIRST, UCOL_OFF, status);
 469     }
 470   }
 471
 472   icu::UnicodeString sensitivity;
 473   if (ExtractStringSetting(isolate, options, "sensitivity", &sensitivity)) {
 474     if (sensitivity == UNICODE_STRING_SIMPLE("base")) {
 475       collator->setStrength(icu::Collator::PRIMARY);
 476     } else if (sensitivity == UNICODE_STRING_SIMPLE("accent")) {
 477       collator->setStrength(icu::Collator::SECONDARY);
 478     } else if (sensitivity == UNICODE_STRING_SIMPLE("case")) {
 479       collator->setStrength(icu::Collator::PRIMARY);
 480       collator->setAttribute(UCOL_CASE_LEVEL, UCOL_ON, status);
 481     } else {
 482       // variant (default)
 483       collator->setStrength(icu::Collator::TERTIARY);
 484     }
 485   }
 486
 487   bool ignore;
 488   if (ExtractBooleanSetting(isolate, options, "ignorePunctuation", &ignore)) {
 489     if (ignore) {
 490       collator->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, status);
 491     }
 492   }
 493
 494   return collator;
 495 }
 496
 497
 498 void SetResolvedCollatorSettings(Isolate* isolate,
 499                                  const icu::Locale& icu_locale,
 500                                  icu::Collator* collator,
 501                                  Handle<JSObject> resolved) {
 502   Factory* factory = isolate->factory();
 503   UErrorCode status = U_ZERO_ERROR;
 504
 505   JSObject::SetProperty(
 506       resolved, factory->NewStringFromStaticChars("numeric"),
 507       factory->ToBoolean(
 508           collator->getAttribute(UCOL_NUMERIC_COLLATION, status) == UCOL_ON),
 509       SLOPPY).Assert();
 510
 511   switch (collator->getAttribute(UCOL_CASE_FIRST, status)) {
 512     case UCOL_LOWER_FIRST:
 513       JSObject::SetProperty(
 514           resolved, factory->NewStringFromStaticChars("caseFirst"),
 515           factory->NewStringFromStaticChars("lower"), SLOPPY).Assert();
 516       break;
 517     case UCOL_UPPER_FIRST:
 518       JSObject::SetProperty(
 519           resolved, factory->NewStringFromStaticChars("caseFirst"),
 520           factory->NewStringFromStaticChars("upper"), SLOPPY).Assert();
 521       break;
 522     default:
 523       JSObject::SetProperty(
 524           resolved, factory->NewStringFromStaticChars("caseFirst"),
 525           factory->NewStringFromStaticChars("false"), SLOPPY).Assert();
 526   }
 527
 528   switch (collator->getAttribute(UCOL_STRENGTH, status)) {
 529     case UCOL_PRIMARY: {
 530       JSObject::SetProperty(
 531           resolved, factory->NewStringFromStaticChars("strength"),
 532           factory->NewStringFromStaticChars("primary"), SLOPPY).Assert();
 533
 534       // case level: true + s1 -> case, s1 -> base.
 535       if (UCOL_ON == collator->getAttribute(UCOL_CASE_LEVEL, status)) {
 536         JSObject::SetProperty(
 537             resolved, factory->NewStringFromStaticChars("sensitivity"),
 538             factory->NewStringFromStaticChars("case"), SLOPPY).Assert();
 539       } else {
 540         JSObject::SetProperty(
 541             resolved, factory->NewStringFromStaticChars("sensitivity"),
 542             factory->NewStringFromStaticChars("base"), SLOPPY).Assert();
 543       }
 544       break;
 545     }
 546     case UCOL_SECONDARY:
 547       JSObject::SetProperty(
 548           resolved, factory->NewStringFromStaticChars("strength"),
 549           factory->NewStringFromStaticChars("secondary"), SLOPPY).Assert();
 550       JSObject::SetProperty(
 551           resolved, factory->NewStringFromStaticChars("sensitivity"),
 552           factory->NewStringFromStaticChars("accent"), SLOPPY).Assert();
 553       break;
 554     case UCOL_TERTIARY:
 555       JSObject::SetProperty(
 556           resolved, factory->NewStringFromStaticChars("strength"),
 557           factory->NewStringFromStaticChars("tertiary"), SLOPPY).Assert();
 558       JSObject::SetProperty(
 559           resolved, factory->NewStringFromStaticChars("sensitivity"),
 560           factory->NewStringFromStaticChars("variant"), SLOPPY).Assert();
 561       break;
 562     case UCOL_QUATERNARY:
 563       // We shouldn't get quaternary and identical from ICU, but if we do
 564       // put them into variant.
 565       JSObject::SetProperty(
 566           resolved, factory->NewStringFromStaticChars("strength"),
 567           factory->NewStringFromStaticChars("quaternary"), SLOPPY).Assert();
 568       JSObject::SetProperty(
 569           resolved, factory->NewStringFromStaticChars("sensitivity"),
 570           factory->NewStringFromStaticChars("variant"), SLOPPY).Assert();
 571       break;
 572     default:
 573       JSObject::SetProperty(
 574           resolved, factory->NewStringFromStaticChars("strength"),
 575           factory->NewStringFromStaticChars("identical"), SLOPPY).Assert();
 576       JSObject::SetProperty(
 577           resolved, factory->NewStringFromStaticChars("sensitivity"),
 578           factory->NewStringFromStaticChars("variant"), SLOPPY).Assert();
 579   }
 580
 581   JSObject::SetProperty(
 582       resolved, factory->NewStringFromStaticChars("ignorePunctuation"),
 583       factory->ToBoolean(collator->getAttribute(UCOL_ALTERNATE_HANDLING,
 584                                                 status) == UCOL_SHIFTED),
 585       SLOPPY).Assert();
 586
 587   // Set the locale
 588   char result[ULOC_FULLNAME_CAPACITY];
 589   status = U_ZERO_ERROR;
 590   uloc_toLanguageTag(
 591       icu_locale.getName(), result, ULOC_FULLNAME_CAPACITY, FALSE, &status);
 592   if (U_SUCCESS(status)) {
 593     JSObject::SetProperty(resolved, factory->NewStringFromStaticChars("locale"),
 594                           factory->NewStringFromAsciiChecked(result),
 595                           SLOPPY).Assert();
 596   } else {
 597     // This would never happen, since we got the locale from ICU.
 598     JSObject::SetProperty(resolved, factory->NewStringFromStaticChars("locale"),
 599                           factory->NewStringFromStaticChars("und"),
 600                           SLOPPY).Assert();
 601   }
 602 }
 603
 604
 605 icu::BreakIterator* CreateICUBreakIterator(
 606     Isolate* isolate,
 607     const icu::Locale& icu_locale,
 608     Handle<JSObject> options) {
 609   UErrorCode status = U_ZERO_ERROR;
 610   icu::BreakIterator* break_iterator = NULL;
 611   icu::UnicodeString type;
 612   if (!ExtractStringSetting(isolate, options, "type", &type)) return NULL;
 613
 614   if (type == UNICODE_STRING_SIMPLE("character")) {
 615     break_iterator =
 616       icu::BreakIterator::createCharacterInstance(icu_locale, status);
 617   } else if (type == UNICODE_STRING_SIMPLE("sentence")) {
 618     break_iterator =
 619       icu::BreakIterator::createSentenceInstance(icu_locale, status);
 620   } else if (type == UNICODE_STRING_SIMPLE("line")) {
 621     break_iterator =
 622       icu::BreakIterator::createLineInstance(icu_locale, status);
 623   } else {
 624     // Defualt is word iterator.
 625     break_iterator =
 626       icu::BreakIterator::createWordInstance(icu_locale, status);
 627   }
 628
 629   if (U_FAILURE(status)) {
 630     delete break_iterator;
 631     return NULL;
 632   }
 633
 634   return break_iterator;
 635 }
 636
 637
 638 void SetResolvedBreakIteratorSettings(Isolate* isolate,
 639                                       const icu::Locale& icu_locale,
 640                                       icu::BreakIterator* break_iterator,
 641                                       Handle<JSObject> resolved) {
 642   Factory* factory = isolate->factory();
 643   UErrorCode status = U_ZERO_ERROR;
 644
 645   // Set the locale
 646   char result[ULOC_FULLNAME_CAPACITY];
 647   status = U_ZERO_ERROR;
 648   uloc_toLanguageTag(
 649       icu_locale.getName(), result, ULOC_FULLNAME_CAPACITY, FALSE, &status);
 650   if (U_SUCCESS(status)) {
 651     JSObject::SetProperty(resolved, factory->NewStringFromStaticChars("locale"),
 652                           factory->NewStringFromAsciiChecked(result),
 653                           SLOPPY).Assert();
 654   } else {
 655     // This would never happen, since we got the locale from ICU.
 656     JSObject::SetProperty(resolved, factory->NewStringFromStaticChars("locale"),
 657                           factory->NewStringFromStaticChars("und"),
 658                           SLOPPY).Assert();
 659   }
 660 }
 661
 662 }  // namespace
 663
 664
 665 // static
 666 Handle<ObjectTemplateInfo> I18N::GetTemplate(Isolate* isolate) {
 667   return GetEternal<1, i::EternalHandles::I18N_TEMPLATE_ONE>(isolate);
 668 }
 669
 670
 671 // static
 672 Handle<ObjectTemplateInfo> I18N::GetTemplate2(Isolate* isolate) {
 673   return GetEternal<2, i::EternalHandles::I18N_TEMPLATE_TWO>(isolate);
 674 }
 675
 676
 677 // static
 678 icu::SimpleDateFormat* DateFormat::InitializeDateTimeFormat(
 679     Isolate* isolate,
 680     Handle<String> locale,
 681     Handle<JSObject> options,
 682     Handle<JSObject> resolved) {
 683   // Convert BCP47 into ICU locale format.
 684   UErrorCode status = U_ZERO_ERROR;
 685   icu::Locale icu_locale;
 686   char icu_result[ULOC_FULLNAME_CAPACITY];
 687   int icu_length = 0;
 688   v8::String::Utf8Value bcp47_locale(v8::Utils::ToLocal(locale));
 689   if (bcp47_locale.length() != 0) {
 690     uloc_forLanguageTag(*bcp47_locale, icu_result, ULOC_FULLNAME_CAPACITY,
 691                         &icu_length, &status);
 692     if (U_FAILURE(status) || icu_length == 0) {
 693       return NULL;
 694     }
 695     icu_locale = icu::Locale(icu_result);
 696   }
 697
 698   icu::SimpleDateFormat* date_format = CreateICUDateFormat(
 699       isolate, icu_locale, options);
 700   if (!date_format) {
 701     // Remove extensions and try again.
 702     icu::Locale no_extension_locale(icu_locale.getBaseName());
 703     date_format = CreateICUDateFormat(isolate, no_extension_locale, options);
 704
 705     // Set resolved settings (pattern, numbering system, calendar).
 706     SetResolvedDateSettings(
 707         isolate, no_extension_locale, date_format, resolved);
 708   } else {
 709     SetResolvedDateSettings(isolate, icu_locale, date_format, resolved);
 710   }
 711
 712   return date_format;
 713 }
 714
 715
 716 icu::SimpleDateFormat* DateFormat::UnpackDateFormat(
 717     Isolate* isolate,
 718     Handle<JSObject> obj) {
 719   Handle<String> key =
 720       isolate->factory()->NewStringFromStaticChars("dateFormat");
 721   Maybe<bool> maybe = JSReceiver::HasOwnProperty(obj, key);
 722   CHECK(maybe.has_value);
 723   if (maybe.value) {
 724     return reinterpret_cast<icu::SimpleDateFormat*>(
 725         obj->GetInternalField(0));
 726   }
 727
 728   return NULL;
 729 }
 730
 731
 732 template<class T>
 733 void DeleteNativeObjectAt(const v8::WeakCallbackData<v8::Value, void>& data,
 734                           int index) {
 735   v8::Local<v8::Object> obj = v8::Handle<v8::Object>::Cast(data.GetValue());
 736   delete reinterpret_cast<T*>(obj->GetAlignedPointerFromInternalField(index));
 737 }
 738
 739
 740 static void DestroyGlobalHandle(
 741     const v8::WeakCallbackData<v8::Value, void>& data) {
 742   GlobalHandles::Destroy(reinterpret_cast<Object**>(data.GetParameter()));
 743 }
 744
 745
 746 void DateFormat::DeleteDateFormat(
 747     const v8::WeakCallbackData<v8::Value, void>& data) {
 748   DeleteNativeObjectAt<icu::SimpleDateFormat>(data, 0);
 749   DestroyGlobalHandle(data);
 750 }
 751
 752
 753 icu::DecimalFormat* NumberFormat::InitializeNumberFormat(
 754     Isolate* isolate,
 755     Handle<String> locale,
 756     Handle<JSObject> options,
 757     Handle<JSObject> resolved) {
 758   // Convert BCP47 into ICU locale format.
 759   UErrorCode status = U_ZERO_ERROR;
 760   icu::Locale icu_locale;
 761   char icu_result[ULOC_FULLNAME_CAPACITY];
 762   int icu_length = 0;
 763   v8::String::Utf8Value bcp47_locale(v8::Utils::ToLocal(locale));
 764   if (bcp47_locale.length() != 0) {
 765     uloc_forLanguageTag(*bcp47_locale, icu_result, ULOC_FULLNAME_CAPACITY,
 766                         &icu_length, &status);
 767     if (U_FAILURE(status) || icu_length == 0) {
 768       return NULL;
 769     }
 770     icu_locale = icu::Locale(icu_result);
 771   }
 772
 773   icu::DecimalFormat* number_format =
 774       CreateICUNumberFormat(isolate, icu_locale, options);
 775   if (!number_format) {
 776     // Remove extensions and try again.
 777     icu::Locale no_extension_locale(icu_locale.getBaseName());
 778     number_format = CreateICUNumberFormat(
 779         isolate, no_extension_locale, options);
 780
 781     // Set resolved settings (pattern, numbering system).
 782     SetResolvedNumberSettings(
 783         isolate, no_extension_locale, number_format, resolved);
 784   } else {
 785     SetResolvedNumberSettings(isolate, icu_locale, number_format, resolved);
 786   }
 787
 788   return number_format;
 789 }
 790
 791
 792 icu::DecimalFormat* NumberFormat::UnpackNumberFormat(
 793     Isolate* isolate,
 794     Handle<JSObject> obj) {
 795   Handle<String> key =
 796       isolate->factory()->NewStringFromStaticChars("numberFormat");
 797   Maybe<bool> maybe = JSReceiver::HasOwnProperty(obj, key);
 798   CHECK(maybe.has_value);
 799   if (maybe.value) {
 800     return reinterpret_cast<icu::DecimalFormat*>(obj->GetInternalField(0));
 801   }
 802
 803   return NULL;
 804 }
 805
 806
 807 void NumberFormat::DeleteNumberFormat(
 808     const v8::WeakCallbackData<v8::Value, void>& data) {
 809   DeleteNativeObjectAt<icu::DecimalFormat>(data, 0);
 810   DestroyGlobalHandle(data);
 811 }
 812
 813
 814 icu::Collator* Collator::InitializeCollator(
 815     Isolate* isolate,
 816     Handle<String> locale,
 817     Handle<JSObject> options,
 818     Handle<JSObject> resolved) {
 819   // Convert BCP47 into ICU locale format.
 820   UErrorCode status = U_ZERO_ERROR;
 821   icu::Locale icu_locale;
 822   char icu_result[ULOC_FULLNAME_CAPACITY];
 823   int icu_length = 0;
 824   v8::String::Utf8Value bcp47_locale(v8::Utils::ToLocal(locale));
 825   if (bcp47_locale.length() != 0) {
 826     uloc_forLanguageTag(*bcp47_locale, icu_result, ULOC_FULLNAME_CAPACITY,
 827                         &icu_length, &status);
 828     if (U_FAILURE(status) || icu_length == 0) {
 829       return NULL;
 830     }
 831     icu_locale = icu::Locale(icu_result);
 832   }
 833
 834   icu::Collator* collator = CreateICUCollator(isolate, icu_locale, options);
 835   if (!collator) {
 836     // Remove extensions and try again.
 837     icu::Locale no_extension_locale(icu_locale.getBaseName());
 838     collator = CreateICUCollator(isolate, no_extension_locale, options);
 839
 840     // Set resolved settings (pattern, numbering system).
 841     SetResolvedCollatorSettings(
 842         isolate, no_extension_locale, collator, resolved);
 843   } else {
 844     SetResolvedCollatorSettings(isolate, icu_locale, collator, resolved);
 845   }
 846
 847   return collator;
 848 }
 849
 850
 851 icu::Collator* Collator::UnpackCollator(Isolate* isolate,
 852                                         Handle<JSObject> obj) {
 853   Handle<String> key = isolate->factory()->NewStringFromStaticChars("collator");
 854   Maybe<bool> maybe = JSReceiver::HasOwnProperty(obj, key);
 855   CHECK(maybe.has_value);
 856   if (maybe.value) {
 857     return reinterpret_cast<icu::Collator*>(obj->GetInternalField(0));
 858   }
 859
 860   return NULL;
 861 }
 862
 863
 864 void Collator::DeleteCollator(
 865     const v8::WeakCallbackData<v8::Value, void>& data) {
 866   DeleteNativeObjectAt<icu::Collator>(data, 0);
 867   DestroyGlobalHandle(data);
 868 }
 869
 870
 871 icu::BreakIterator* BreakIterator::InitializeBreakIterator(
 872     Isolate* isolate,
 873     Handle<String> locale,
 874     Handle<JSObject> options,
 875     Handle<JSObject> resolved) {
 876   // Convert BCP47 into ICU locale format.
 877   UErrorCode status = U_ZERO_ERROR;
 878   icu::Locale icu_locale;
 879   char icu_result[ULOC_FULLNAME_CAPACITY];
 880   int icu_length = 0;
 881   v8::String::Utf8Value bcp47_locale(v8::Utils::ToLocal(locale));
 882   if (bcp47_locale.length() != 0) {
 883     uloc_forLanguageTag(*bcp47_locale, icu_result, ULOC_FULLNAME_CAPACITY,
 884                         &icu_length, &status);
 885     if (U_FAILURE(status) || icu_length == 0) {
 886       return NULL;
 887     }
 888     icu_locale = icu::Locale(icu_result);
 889   }
 890
 891   icu::BreakIterator* break_iterator = CreateICUBreakIterator(
 892       isolate, icu_locale, options);
 893   if (!break_iterator) {
 894     // Remove extensions and try again.
 895     icu::Locale no_extension_locale(icu_locale.getBaseName());
 896     break_iterator = CreateICUBreakIterator(
 897         isolate, no_extension_locale, options);
 898
 899     // Set resolved settings (locale).
 900     SetResolvedBreakIteratorSettings(
 901         isolate, no_extension_locale, break_iterator, resolved);
 902   } else {
 903     SetResolvedBreakIteratorSettings(
 904         isolate, icu_locale, break_iterator, resolved);
 905   }
 906
 907   return break_iterator;
 908 }
 909
 910
 911 icu::BreakIterator* BreakIterator::UnpackBreakIterator(Isolate* isolate,
 912                                                        Handle<JSObject> obj) {
 913   Handle<String> key =
 914       isolate->factory()->NewStringFromStaticChars("breakIterator");
 915   Maybe<bool> maybe = JSReceiver::HasOwnProperty(obj, key);
 916   CHECK(maybe.has_value);
 917   if (maybe.value) {
 918     return reinterpret_cast<icu::BreakIterator*>(obj->GetInternalField(0));
 919   }
 920
 921   return NULL;
 922 }
 923
 924
 925 void BreakIterator::DeleteBreakIterator(
 926     const v8::WeakCallbackData<v8::Value, void>& data) {
 927   DeleteNativeObjectAt<icu::BreakIterator>(data, 0);
 928   DeleteNativeObjectAt<icu::UnicodeString>(data, 1);
 929   DestroyGlobalHandle(data);
 930 }
 931
 932 } }  // namespace v8::internal