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   isolate->CountUsage(v8::Isolate::UseCounterFeature::kBreakIterator);
 635
 636   return break_iterator;
 637 }
 638
 639
 640 void SetResolvedBreakIteratorSettings(Isolate* isolate,
 641                                       const icu::Locale& icu_locale,
 642                                       icu::BreakIterator* break_iterator,
 643                                       Handle<JSObject> resolved) {
 644   Factory* factory = isolate->factory();
 645   UErrorCode status = U_ZERO_ERROR;
 646
 647   // Set the locale
 648   char result[ULOC_FULLNAME_CAPACITY];
 649   status = U_ZERO_ERROR;
 650   uloc_toLanguageTag(
 651       icu_locale.getName(), result, ULOC_FULLNAME_CAPACITY, FALSE, &status);
 652   if (U_SUCCESS(status)) {
 653     JSObject::SetProperty(resolved, factory->NewStringFromStaticChars("locale"),
 654                           factory->NewStringFromAsciiChecked(result),
 655                           SLOPPY).Assert();
 656   } else {
 657     // This would never happen, since we got the locale from ICU.
 658     JSObject::SetProperty(resolved, factory->NewStringFromStaticChars("locale"),
 659                           factory->NewStringFromStaticChars("und"),
 660                           SLOPPY).Assert();
 661   }
 662 }
 663
 664 }  // namespace
 665
 666
 667 // static
 668 Handle<ObjectTemplateInfo> I18N::GetTemplate(Isolate* isolate) {
 669   return GetEternal<1, i::EternalHandles::I18N_TEMPLATE_ONE>(isolate);
 670 }
 671
 672
 673 // static
 674 Handle<ObjectTemplateInfo> I18N::GetTemplate2(Isolate* isolate) {
 675   return GetEternal<2, i::EternalHandles::I18N_TEMPLATE_TWO>(isolate);
 676 }
 677
 678
 679 // static
 680 icu::SimpleDateFormat* DateFormat::InitializeDateTimeFormat(
 681     Isolate* isolate,
 682     Handle<String> locale,
 683     Handle<JSObject> options,
 684     Handle<JSObject> resolved) {
 685   // Convert BCP47 into ICU locale format.
 686   UErrorCode status = U_ZERO_ERROR;
 687   icu::Locale icu_locale;
 688   char icu_result[ULOC_FULLNAME_CAPACITY];
 689   int icu_length = 0;
 690   v8::String::Utf8Value bcp47_locale(v8::Utils::ToLocal(locale));
 691   if (bcp47_locale.length() != 0) {
 692     uloc_forLanguageTag(*bcp47_locale, icu_result, ULOC_FULLNAME_CAPACITY,
 693                         &icu_length, &status);
 694     if (U_FAILURE(status) || icu_length == 0) {
 695       return NULL;
 696     }
 697     icu_locale = icu::Locale(icu_result);
 698   }
 699
 700   icu::SimpleDateFormat* date_format = CreateICUDateFormat(
 701       isolate, icu_locale, options);
 702   if (!date_format) {
 703     // Remove extensions and try again.
 704     icu::Locale no_extension_locale(icu_locale.getBaseName());
 705     date_format = CreateICUDateFormat(isolate, no_extension_locale, options);
 706
 707     // Set resolved settings (pattern, numbering system, calendar).
 708     SetResolvedDateSettings(
 709         isolate, no_extension_locale, date_format, resolved);
 710   } else {
 711     SetResolvedDateSettings(isolate, icu_locale, date_format, resolved);
 712   }
 713
 714   return date_format;
 715 }
 716
 717
 718 icu::SimpleDateFormat* DateFormat::UnpackDateFormat(
 719     Isolate* isolate,
 720     Handle<JSObject> obj) {
 721   Handle<String> key =
 722       isolate->factory()->NewStringFromStaticChars("dateFormat");
 723   Maybe<bool> maybe = JSReceiver::HasOwnProperty(obj, key);
 724   CHECK(maybe.has_value);
 725   if (maybe.value) {
 726     return reinterpret_cast<icu::SimpleDateFormat*>(
 727         obj->GetInternalField(0));
 728   }
 729
 730   return NULL;
 731 }
 732
 733
 734 template<class T>
 735 void DeleteNativeObjectAt(const v8::WeakCallbackData<v8::Value, void>& data,
 736                           int index) {
 737   v8::Local<v8::Object> obj = v8::Handle<v8::Object>::Cast(data.GetValue());
 738   delete reinterpret_cast<T*>(obj->GetAlignedPointerFromInternalField(index));
 739 }
 740
 741
 742 static void DestroyGlobalHandle(
 743     const v8::WeakCallbackData<v8::Value, void>& data) {
 744   GlobalHandles::Destroy(reinterpret_cast<Object**>(data.GetParameter()));
 745 }
 746
 747
 748 void DateFormat::DeleteDateFormat(
 749     const v8::WeakCallbackData<v8::Value, void>& data) {
 750   DeleteNativeObjectAt<icu::SimpleDateFormat>(data, 0);
 751   DestroyGlobalHandle(data);
 752 }
 753
 754
 755 icu::DecimalFormat* NumberFormat::InitializeNumberFormat(
 756     Isolate* isolate,
 757     Handle<String> locale,
 758     Handle<JSObject> options,
 759     Handle<JSObject> resolved) {
 760   // Convert BCP47 into ICU locale format.
 761   UErrorCode status = U_ZERO_ERROR;
 762   icu::Locale icu_locale;
 763   char icu_result[ULOC_FULLNAME_CAPACITY];
 764   int icu_length = 0;
 765   v8::String::Utf8Value bcp47_locale(v8::Utils::ToLocal(locale));
 766   if (bcp47_locale.length() != 0) {
 767     uloc_forLanguageTag(*bcp47_locale, icu_result, ULOC_FULLNAME_CAPACITY,
 768                         &icu_length, &status);
 769     if (U_FAILURE(status) || icu_length == 0) {
 770       return NULL;
 771     }
 772     icu_locale = icu::Locale(icu_result);
 773   }
 774
 775   icu::DecimalFormat* number_format =
 776       CreateICUNumberFormat(isolate, icu_locale, options);
 777   if (!number_format) {
 778     // Remove extensions and try again.
 779     icu::Locale no_extension_locale(icu_locale.getBaseName());
 780     number_format = CreateICUNumberFormat(
 781         isolate, no_extension_locale, options);
 782
 783     // Set resolved settings (pattern, numbering system).
 784     SetResolvedNumberSettings(
 785         isolate, no_extension_locale, number_format, resolved);
 786   } else {
 787     SetResolvedNumberSettings(isolate, icu_locale, number_format, resolved);
 788   }
 789
 790   return number_format;
 791 }
 792
 793
 794 icu::DecimalFormat* NumberFormat::UnpackNumberFormat(
 795     Isolate* isolate,
 796     Handle<JSObject> obj) {
 797   Handle<String> key =
 798       isolate->factory()->NewStringFromStaticChars("numberFormat");
 799   Maybe<bool> maybe = JSReceiver::HasOwnProperty(obj, key);
 800   CHECK(maybe.has_value);
 801   if (maybe.value) {
 802     return reinterpret_cast<icu::DecimalFormat*>(obj->GetInternalField(0));
 803   }
 804
 805   return NULL;
 806 }
 807
 808
 809 void NumberFormat::DeleteNumberFormat(
 810     const v8::WeakCallbackData<v8::Value, void>& data) {
 811   DeleteNativeObjectAt<icu::DecimalFormat>(data, 0);
 812   DestroyGlobalHandle(data);
 813 }
 814
 815
 816 icu::Collator* Collator::InitializeCollator(
 817     Isolate* isolate,
 818     Handle<String> locale,
 819     Handle<JSObject> options,
 820     Handle<JSObject> resolved) {
 821   // Convert BCP47 into ICU locale format.
 822   UErrorCode status = U_ZERO_ERROR;
 823   icu::Locale icu_locale;
 824   char icu_result[ULOC_FULLNAME_CAPACITY];
 825   int icu_length = 0;
 826   v8::String::Utf8Value bcp47_locale(v8::Utils::ToLocal(locale));
 827   if (bcp47_locale.length() != 0) {
 828     uloc_forLanguageTag(*bcp47_locale, icu_result, ULOC_FULLNAME_CAPACITY,
 829                         &icu_length, &status);
 830     if (U_FAILURE(status) || icu_length == 0) {
 831       return NULL;
 832     }
 833     icu_locale = icu::Locale(icu_result);
 834   }
 835
 836   icu::Collator* collator = CreateICUCollator(isolate, icu_locale, options);
 837   if (!collator) {
 838     // Remove extensions and try again.
 839     icu::Locale no_extension_locale(icu_locale.getBaseName());
 840     collator = CreateICUCollator(isolate, no_extension_locale, options);
 841
 842     // Set resolved settings (pattern, numbering system).
 843     SetResolvedCollatorSettings(
 844         isolate, no_extension_locale, collator, resolved);
 845   } else {
 846     SetResolvedCollatorSettings(isolate, icu_locale, collator, resolved);
 847   }
 848
 849   return collator;
 850 }
 851
 852
 853 icu::Collator* Collator::UnpackCollator(Isolate* isolate,
 854                                         Handle<JSObject> obj) {
 855   Handle<String> key = isolate->factory()->NewStringFromStaticChars("collator");
 856   Maybe<bool> maybe = JSReceiver::HasOwnProperty(obj, key);
 857   CHECK(maybe.has_value);
 858   if (maybe.value) {
 859     return reinterpret_cast<icu::Collator*>(obj->GetInternalField(0));
 860   }
 861
 862   return NULL;
 863 }
 864
 865
 866 void Collator::DeleteCollator(
 867     const v8::WeakCallbackData<v8::Value, void>& data) {
 868   DeleteNativeObjectAt<icu::Collator>(data, 0);
 869   DestroyGlobalHandle(data);
 870 }
 871
 872
 873 icu::BreakIterator* BreakIterator::InitializeBreakIterator(
 874     Isolate* isolate,
 875     Handle<String> locale,
 876     Handle<JSObject> options,
 877     Handle<JSObject> resolved) {
 878   // Convert BCP47 into ICU locale format.
 879   UErrorCode status = U_ZERO_ERROR;
 880   icu::Locale icu_locale;
 881   char icu_result[ULOC_FULLNAME_CAPACITY];
 882   int icu_length = 0;
 883   v8::String::Utf8Value bcp47_locale(v8::Utils::ToLocal(locale));
 884   if (bcp47_locale.length() != 0) {
 885     uloc_forLanguageTag(*bcp47_locale, icu_result, ULOC_FULLNAME_CAPACITY,
 886                         &icu_length, &status);
 887     if (U_FAILURE(status) || icu_length == 0) {
 888       return NULL;
 889     }
 890     icu_locale = icu::Locale(icu_result);
 891   }
 892
 893   icu::BreakIterator* break_iterator = CreateICUBreakIterator(
 894       isolate, icu_locale, options);
 895   if (!break_iterator) {
 896     // Remove extensions and try again.
 897     icu::Locale no_extension_locale(icu_locale.getBaseName());
 898     break_iterator = CreateICUBreakIterator(
 899         isolate, no_extension_locale, options);
 900
 901     // Set resolved settings (locale).
 902     SetResolvedBreakIteratorSettings(
 903         isolate, no_extension_locale, break_iterator, resolved);
 904   } else {
 905     SetResolvedBreakIteratorSettings(
 906         isolate, icu_locale, break_iterator, resolved);
 907   }
 908
 909   return break_iterator;
 910 }
 911
 912
 913 icu::BreakIterator* BreakIterator::UnpackBreakIterator(Isolate* isolate,
 914                                                        Handle<JSObject> obj) {
 915   Handle<String> key =
 916       isolate->factory()->NewStringFromStaticChars("breakIterator");
 917   Maybe<bool> maybe = JSReceiver::HasOwnProperty(obj, key);
 918   CHECK(maybe.has_value);
 919   if (maybe.value) {
 920     return reinterpret_cast<icu::BreakIterator*>(obj->GetInternalField(0));
 921   }
 922
 923   return NULL;
 924 }
 925
 926
 927 void BreakIterator::DeleteBreakIterator(
 928     const v8::WeakCallbackData<v8::Value, void>& data) {
 929   DeleteNativeObjectAt<icu::BreakIterator>(data, 0);
 930   DeleteNativeObjectAt<icu::UnicodeString>(data, 1);
 931   DestroyGlobalHandle(data);
 932 }
 933
 934 } }  // namespace v8::internal