The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-

  * vim: set ts=8 sts=4 et sw=4 tw=99:

  * This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 /*

  * The Intl module specified by standard ECMA-402,

  * ECMAScript Internationalization API Specification.

  */

 #include "builtin/Intl.h"

 #include <string.h>

 #include "jsapi.h"

 #include "jsatom.h"

 #include "jscntxt.h"

 #include "jsobj.h"

 #if ENABLE_INTL_API

 #include "unicode/locid.h"

 #include "unicode/numsys.h"

 #include "unicode/ucal.h"

 #include "unicode/ucol.h"

 #include "unicode/udat.h"

 #include "unicode/udatpg.h"

 #include "unicode/uenum.h"

 #include "unicode/unum.h"

 #include "unicode/ustring.h"

 #endif

 #include "vm/DateTime.h"

 #include "vm/GlobalObject.h"

 #include "vm/Interpreter.h"

 #include "vm/Stack.h"

 #include "vm/StringBuffer.h"

 #include "jsobjinlines.h"

 #include "vm/ObjectImpl-inl.h"

 using namespace js;

 using mozilla::IsFinite;

 using mozilla::IsNegativeZero;

 #if ENABLE_INTL_API

 using icu::Locale;

 using icu::NumberingSystem;

 #endif

 /*

  * Pervasive note: ICU functions taking a UErrorCode in/out parameter always

  * test that parameter before doing anything, and will return immediately if

  * the value indicates that a failure occurred in a prior ICU call,

  * without doing anything else. See

  * http://userguide.icu-project.org/design#TOC-Error-Handling

  */

 /******************** ICU stubs ********************/

 #if !ENABLE_INTL_API

 /*

  * When the Internationalization API isn't enabled, we also shouldn't link

  * against ICU. However, we still want to compile this code in order to prevent

  * bit rot. The following stub implementations for ICU functions make this

  * possible. The functions using them should never be called, so they assert

  * and return error codes. Signatures adapted from ICU header files locid.h,

  * numsys.h, ucal.h, ucol.h, udat.h, udatpg.h, uenum.h, unum.h; see the ICU

  * directory for license.

  */

 static int32_t

 u_strlen(const UChar *s)

 {

     MOZ_ASSUME_UNREACHABLE("u_strlen: Intl API disabled");

 }

 struct UEnumeration;

 static int32_t

 uenum_count(UEnumeration *en, UErrorCode *status)

 {

     MOZ_ASSUME_UNREACHABLE("uenum_count: Intl API disabled");

 }

 static const char *

 uenum_next(UEnumeration *en, int32_t *resultLength, UErrorCode *status)

 {

     MOZ_ASSUME_UNREACHABLE("uenum_next: Intl API disabled");

 }

 static void

 uenum_close(UEnumeration *en)

 {

     MOZ_ASSUME_UNREACHABLE("uenum_close: Intl API disabled");

 }

 struct UCollator;

 enum UColAttribute {

      UCOL_ALTERNATE_HANDLING,

      UCOL_CASE_FIRST,

      UCOL_CASE_LEVEL,

      UCOL_NORMALIZATION_MODE,

      UCOL_STRENGTH,

      UCOL_NUMERIC_COLLATION,

 };

 enum UColAttributeValue {

   UCOL_DEFAULT = -1,

   UCOL_PRIMARY = 0,

   UCOL_SECONDARY = 1,

   UCOL_TERTIARY = 2,

   UCOL_OFF = 16,

   UCOL_ON = 17,

   UCOL_SHIFTED = 20,

   UCOL_LOWER_FIRST = 24,

   UCOL_UPPER_FIRST = 25,

 };

 enum UCollationResult {

   UCOL_EQUAL = 0,

   UCOL_GREATER = 1,

   UCOL_LESS = -1

 };

 static int32_t

 ucol_countAvailable(void)

 {

     MOZ_ASSUME_UNREACHABLE("ucol_countAvailable: Intl API disabled");

 }

 static const char *

 ucol_getAvailable(int32_t localeIndex)

 {

     MOZ_ASSUME_UNREACHABLE("ucol_getAvailable: Intl API disabled");

 }

 static UCollator *

 ucol_open(const char *loc, UErrorCode *status)

 {

     MOZ_ASSUME_UNREACHABLE("ucol_open: Intl API disabled");

 }

 static void

 ucol_setAttribute(UCollator *coll, UColAttribute attr, UColAttributeValue value, UErrorCode *status)

 {

     MOZ_ASSUME_UNREACHABLE("ucol_setAttribute: Intl API disabled");

 }

 static UCollationResult

 ucol_strcoll(const UCollator *coll, const UChar *source, int32_t sourceLength,

              const UChar *target, int32_t targetLength)

 {

     MOZ_ASSUME_UNREACHABLE("ucol_strcoll: Intl API disabled");

 }

 static void

 ucol_close(UCollator *coll)

 {

     MOZ_ASSUME_UNREACHABLE("ucol_close: Intl API disabled");

 }

 static UEnumeration *

 ucol_getKeywordValuesForLocale(const char *key, const char *locale, UBool commonlyUsed,

                                UErrorCode *status)

 {

     MOZ_ASSUME_UNREACHABLE("ucol_getKeywordValuesForLocale: Intl API disabled");

 }

 struct UParseError;

 struct UFieldPosition;

 typedef void *UNumberFormat;

 enum UNumberFormatStyle {

     UNUM_DECIMAL = 1,

     UNUM_CURRENCY,

     UNUM_PERCENT,

     UNUM_CURRENCY_ISO,

     UNUM_CURRENCY_PLURAL,

 };

 enum UNumberFormatRoundingMode {

     UNUM_ROUND_HALFUP,

 };

 enum UNumberFormatAttribute {

   UNUM_GROUPING_USED,

   UNUM_MIN_INTEGER_DIGITS,

   UNUM_MAX_FRACTION_DIGITS,

   UNUM_MIN_FRACTION_DIGITS,

   UNUM_ROUNDING_MODE,

   UNUM_SIGNIFICANT_DIGITS_USED,

   UNUM_MIN_SIGNIFICANT_DIGITS,

   UNUM_MAX_SIGNIFICANT_DIGITS,

 };

 enum UNumberFormatTextAttribute {

   UNUM_CURRENCY_CODE,

 };

 static int32_t

 unum_countAvailable(void)

 {

     MOZ_ASSUME_UNREACHABLE("unum_countAvailable: Intl API disabled");

 }

 static const char *

 unum_getAvailable(int32_t localeIndex)

 {

     MOZ_ASSUME_UNREACHABLE("unum_getAvailable: Intl API disabled");

 }

 static UNumberFormat *

 unum_open(UNumberFormatStyle style, const UChar *pattern, int32_t patternLength,

           const char *locale, UParseError *parseErr, UErrorCode *status)

 {

     MOZ_ASSUME_UNREACHABLE("unum_open: Intl API disabled");

 }

 static void

 unum_setAttribute(UNumberFormat *fmt, UNumberFormatAttribute  attr, int32_t newValue)

 {

     MOZ_ASSUME_UNREACHABLE("unum_setAttribute: Intl API disabled");

 }

 static int32_t

 unum_formatDouble(const UNumberFormat *fmt, double number, UChar *result,

                   int32_t resultLength, UFieldPosition *pos, UErrorCode *status)

 {

     MOZ_ASSUME_UNREACHABLE("unum_formatDouble: Intl API disabled");

 }

 static void

 unum_close(UNumberFormat *fmt)

 {

     MOZ_ASSUME_UNREACHABLE("unum_close: Intl API disabled");

 }

 static void

 unum_setTextAttribute(UNumberFormat *fmt, UNumberFormatTextAttribute tag, const UChar *newValue,

                       int32_t newValueLength, UErrorCode *status)

 {

     MOZ_ASSUME_UNREACHABLE("unum_setTextAttribute: Intl API disabled");

 }

 class Locale {

   public:

     Locale(const char *language, const char *country = 0, const char *variant = 0,

            const char *keywordsAndValues = 0);

 };

 Locale::Locale(const char *language, const char *country, const char *variant,

                const char *keywordsAndValues)

 {

     MOZ_ASSUME_UNREACHABLE("Locale::Locale: Intl API disabled");

 }

 class NumberingSystem {

   public:

     static NumberingSystem *createInstance(const Locale &inLocale, UErrorCode &status);

     const char *getName();

 };

 NumberingSystem *

 NumberingSystem::createInstance(const Locale &inLocale, UErrorCode &status)

 {

     MOZ_ASSUME_UNREACHABLE("NumberingSystem::createInstance: Intl API disabled");

 }

 const char *

 NumberingSystem::getName()

 {

     MOZ_ASSUME_UNREACHABLE("NumberingSystem::getName: Intl API disabled");

 }

 typedef void *UCalendar;

 enum UCalendarType {

   UCAL_TRADITIONAL,

   UCAL_DEFAULT = UCAL_TRADITIONAL,

   UCAL_GREGORIAN

 };

 static UCalendar *

 ucal_open(const UChar *zoneID, int32_t len, const char *locale,

           UCalendarType type, UErrorCode *status)

 {

     MOZ_ASSUME_UNREACHABLE("ucal_open: Intl API disabled");

 }

 static const char *

 ucal_getType(const UCalendar *cal, UErrorCode *status)

 {

     MOZ_ASSUME_UNREACHABLE("ucal_getType: Intl API disabled");

 }

 static UEnumeration *

 ucal_getKeywordValuesForLocale(const char *key, const char *locale,

                                UBool commonlyUsed, UErrorCode *status)

 {

     MOZ_ASSUME_UNREACHABLE("ucal_getKeywordValuesForLocale: Intl API disabled");

 }

 static void

 ucal_close(UCalendar *cal)

 {

     MOZ_ASSUME_UNREACHABLE("ucal_close: Intl API disabled");

 }

 typedef void *UDateTimePatternGenerator;

 static UDateTimePatternGenerator *

 udatpg_open(const char *locale, UErrorCode *pErrorCode)

 {

     MOZ_ASSUME_UNREACHABLE("udatpg_open: Intl API disabled");

 }

 static int32_t

 udatpg_getBestPattern(UDateTimePatternGenerator *dtpg, const UChar *skeleton,

                       int32_t length, UChar *bestPattern, int32_t capacity,

                       UErrorCode *pErrorCode)

 {

     MOZ_ASSUME_UNREACHABLE("udatpg_getBestPattern: Intl API disabled");

 }

 static void

 udatpg_close(UDateTimePatternGenerator *dtpg)

 {

     MOZ_ASSUME_UNREACHABLE("udatpg_close: Intl API disabled");

 }

 typedef void *UCalendar;

 typedef void *UDateFormat;

 enum UDateFormatStyle {

     UDAT_PATTERN = -2,

     UDAT_IGNORE = UDAT_PATTERN

 };

 static int32_t

 udat_countAvailable(void)

 {

     MOZ_ASSUME_UNREACHABLE("udat_countAvailable: Intl API disabled");

 }

 static const char *

 udat_getAvailable(int32_t localeIndex)

 {

     MOZ_ASSUME_UNREACHABLE("udat_getAvailable: Intl API disabled");

 }

 static UDateFormat *

 udat_open(UDateFormatStyle timeStyle, UDateFormatStyle dateStyle, const char *locale,

           const UChar *tzID, int32_t tzIDLength, const UChar *pattern,

           int32_t patternLength, UErrorCode *status)

 {

     MOZ_ASSUME_UNREACHABLE("udat_open: Intl API disabled");

 }

 static const UCalendar *

 udat_getCalendar(const UDateFormat *fmt)

 {

     MOZ_ASSUME_UNREACHABLE("udat_getCalendar: Intl API disabled");

 }

 static void

 ucal_setGregorianChange(UCalendar *cal, UDate date, UErrorCode *pErrorCode)

 {

     MOZ_ASSUME_UNREACHABLE("ucal_setGregorianChange: Intl API disabled");

 }

 static int32_t

 udat_format(const UDateFormat *format, UDate dateToFormat, UChar *result,

             int32_t resultLength, UFieldPosition *position, UErrorCode *status)

 {

     MOZ_ASSUME_UNREACHABLE("udat_format: Intl API disabled");

 }

 static void

 udat_close(UDateFormat *format)

 {

     MOZ_ASSUME_UNREACHABLE("udat_close: Intl API disabled");

 }

 #endif

 /******************** Common to Intl constructors ********************/

 static bool

 IntlInitialize(JSContext *cx, HandleObject obj, Handle<PropertyName*> initializer,

                HandleValue locales, HandleValue options)

 {

     RootedValue initializerValue(cx);

     if (!GlobalObject::getIntrinsicValue(cx, cx->global(), initializer, &initializerValue))

         return false;

     JS_ASSERT(initializerValue.isObject());

     JS_ASSERT(initializerValue.toObject().is<JSFunction>());

     InvokeArgs args(cx);

     if (!args.init(3))

         return false;

     args.setCallee(initializerValue);

     args.setThis(NullValue());

     args[0].setObject(*obj);

     args[1].set(locales);

     args[2].set(options);

     return Invoke(cx, args);

 }

 // CountAvailable and GetAvailable describe the signatures used for ICU API

 // to determine available locales for various functionality.

 typedef int32_t

 (* CountAvailable)(void);

 typedef const char *

 (* GetAvailable)(int32_t localeIndex);

 static bool

 intl_availableLocales(JSContext *cx, CountAvailable countAvailable,

                       GetAvailable getAvailable, MutableHandleValue result)

 {

     RootedObject locales(cx, NewObjectWithGivenProto(cx, &JSObject::class_, nullptr, nullptr));

     if (!locales)

         return false;

 #if ENABLE_INTL_API

     uint32_t count = countAvailable();

     RootedValue t(cx, BooleanValue(true));

     for (uint32_t i = 0; i < count; i++) {

         const char *locale = getAvailable(i);

         ScopedJSFreePtr<char> lang(JS_strdup(cx, locale));

         if (!lang)

             return false;

         char *p;

         while ((p = strchr(lang, '_')))

             *p = '-';

         RootedAtom a(cx, Atomize(cx, lang, strlen(lang)));

         if (!a)

             return false;

         if (!JSObject::defineProperty(cx, locales, a->asPropertyName(), t,

                                       JS_PropertyStub, JS_StrictPropertyStub, JSPROP_ENUMERATE))

         {

             return false;

         }

     }

 #endif

     result.setObject(*locales);

     return true;

 }

 /**

  * Returns the object holding the internal properties for obj.

  */

 static bool

 GetInternals(JSContext *cx, HandleObject obj, MutableHandleObject internals)

 {

     RootedValue getInternalsValue(cx);

     if (!GlobalObject::getIntrinsicValue(cx, cx->global(), cx->names().getInternals, &getInternalsValue))

         return false;

     JS_ASSERT(getInternalsValue.isObject());

     JS_ASSERT(getInternalsValue.toObject().is<JSFunction>());

     InvokeArgs args(cx);

     if (!args.init(1))

         return false;

     args.setCallee(getInternalsValue);

     args.setThis(NullValue());

     args[0].setObject(*obj);

     if (!Invoke(cx, args))

         return false;

     internals.set(&args.rval().toObject());

     return true;

 }

 static bool

 equal(const char *s1, const char *s2)

 {

     return !strcmp(s1, s2);

 }

 static bool

 equal(JSAutoByteString &s1, const char *s2)

 {

     return !strcmp(s1.ptr(), s2);

 }

 static const char *

 icuLocale(const char *locale)

 {

     if (equal(locale, "und"))

         return ""; // ICU root locale

     return locale;

 }

 // Simple RAII for ICU objects. MOZ_TYPE_SPECIFIC_SCOPED_POINTER_TEMPLATE

 // unfortunately doesn't work because of namespace incompatibilities

 // (TypeSpecificDelete cannot be in icu and mozilla at the same time)

 // and because ICU declares both UNumberFormat and UDateTimePatternGenerator

 // as void*.

 template <typename T>

 class ScopedICUObject

 {

     T *ptr_;

     void (* deleter_)(T*);

   public:

     ScopedICUObject(T *ptr, void (*deleter)(T*))

       : ptr_(ptr),

         deleter_(deleter)

     {}

     ~ScopedICUObject() {

         if (ptr_)

             deleter_(ptr_);

     }

     // In cases where an object should be deleted on abnormal exits,

     // but returned to the caller if everything goes well, call forget()

     // to transfer the object just before returning.

     T *forget() {

         T *tmp = ptr_;

         ptr_ = nullptr;

         return tmp;

     }

 };

 // As a small optimization (not important for correctness), this is the inline

 // capacity of a StringBuffer.

 static const size_t INITIAL_STRING_BUFFER_SIZE = 32;

 /******************** Collator ********************/

 static void collator_finalize(FreeOp *fop, JSObject *obj);

 static const uint32_t UCOLLATOR_SLOT = 0;

 static const uint32_t COLLATOR_SLOTS_COUNT = 1;

 static const Class CollatorClass = {

     js_Object_str,

     JSCLASS_HAS_RESERVED_SLOTS(COLLATOR_SLOTS_COUNT),

     JS_PropertyStub,         /* addProperty */

     JS_DeletePropertyStub,   /* delProperty */

     JS_PropertyStub,         /* getProperty */

     JS_StrictPropertyStub,   /* setProperty */

     JS_EnumerateStub,

     JS_ResolveStub,

     JS_ConvertStub,

     collator_finalize

 };

 #if JS_HAS_TOSOURCE

 static bool

 collator_toSource(JSContext *cx, unsigned argc, Value *vp)

 {

     CallArgs args = CallArgsFromVp(argc, vp);

     args.rval().setString(cx->names().Collator);

     return true;

 }

 #endif

 static const JSFunctionSpec collator_static_methods[] = {

     JS_SELF_HOSTED_FN("supportedLocalesOf", "Intl_Collator_supportedLocalesOf", 1, 0),

     JS_FS_END

 };

 static const JSFunctionSpec collator_methods[] = {

     JS_SELF_HOSTED_FN("resolvedOptions", "Intl_Collator_resolvedOptions", 0, 0),

 #if JS_HAS_TOSOURCE

     JS_FN(js_toSource_str, collator_toSource, 0, 0),

 #endif

     JS_FS_END

 };

 /**

  * Collator constructor.

  * Spec: ECMAScript Internationalization API Specification, 10.1

  */

 static bool

 Collator(JSContext *cx, CallArgs args, bool construct)

 {

     RootedObject obj(cx);

     if (!construct) {

         // 10.1.2.1 step 3

         JSObject *intl = cx->global()->getOrCreateIntlObject(cx);

         if (!intl)

             return false;

         RootedValue self(cx, args.thisv());

         if (!self.isUndefined() && (!self.isObject() || self.toObject() != *intl)) {

             // 10.1.2.1 step 4

             obj = ToObject(cx, self);

             if (!obj)

                 return false;

             // 10.1.2.1 step 5

             bool extensible;

             if (!JSObject::isExtensible(cx, obj, &extensible))

                 return false;

             if (!extensible)

                 return Throw(cx, obj, JSMSG_OBJECT_NOT_EXTENSIBLE);

         } else {

             // 10.1.2.1 step 3.a

             construct = true;

         }

     }

     if (construct) {

         // 10.1.3.1 paragraph 2

         RootedObject proto(cx, cx->global()->getOrCreateCollatorPrototype(cx));

         if (!proto)

             return false;

         obj = NewObjectWithGivenProto(cx, &CollatorClass, proto, cx->global());

         if (!obj)

             return false;

         obj->setReservedSlot(UCOLLATOR_SLOT, PrivateValue(nullptr));

     }

     // 10.1.2.1 steps 1 and 2; 10.1.3.1 steps 1 and 2

     RootedValue locales(cx, args.length() > 0 ? args[0] : UndefinedValue());

     RootedValue options(cx, args.length() > 1 ? args[1] : UndefinedValue());

     // 10.1.2.1 step 6; 10.1.3.1 step 3

     if (!IntlInitialize(cx, obj, cx->names().InitializeCollator, locales, options))

         return false;

     // 10.1.2.1 steps 3.a and 7

     args.rval().setObject(*obj);

     return true;

 }

 static bool

 Collator(JSContext *cx, unsigned argc, Value *vp)

 {

     CallArgs args = CallArgsFromVp(argc, vp);

     return Collator(cx, args, args.isConstructing());

 }

 bool

 js::intl_Collator(JSContext *cx, unsigned argc, Value *vp)

 {

     CallArgs args = CallArgsFromVp(argc, vp);

     JS_ASSERT(args.length() == 2);

     // intl_Collator is an intrinsic for self-hosted JavaScript, so it cannot

     // be used with "new", but it still has to be treated as a constructor.

     return Collator(cx, args, true);

 }

 static void

 collator_finalize(FreeOp *fop, JSObject *obj)

 {

     UCollator *coll = static_cast<UCollator*>(obj->getReservedSlot(UCOLLATOR_SLOT).toPrivate());

     if (coll)

         ucol_close(coll);

 }

 static JSObject *

 InitCollatorClass(JSContext *cx, HandleObject Intl, Handle<GlobalObject*> global)

 {

     RootedFunction ctor(cx, global->createConstructor(cx, &Collator, cx->names().Collator, 0));

     if (!ctor)

         return nullptr;

     RootedObject proto(cx, global->as<GlobalObject>().getOrCreateCollatorPrototype(cx));

     if (!proto)

         return nullptr;

     if (!LinkConstructorAndPrototype(cx, ctor, proto))

         return nullptr;

     // 10.2.2

     if (!JS_DefineFunctions(cx, ctor, collator_static_methods))

         return nullptr;

     // 10.3.2 and 10.3.3

     if (!JS_DefineFunctions(cx, proto, collator_methods))

         return nullptr;

     /*

      * Install the getter for Collator.prototype.compare, which returns a bound

      * comparison function for the specified Collator object (suitable for

      * passing to methods like Array.prototype.sort).

      */

     RootedValue getter(cx);

     if (!GlobalObject::getIntrinsicValue(cx, cx->global(), cx->names().CollatorCompareGet, &getter))

         return nullptr;

     if (!JSObject::defineProperty(cx, proto, cx->names().compare, UndefinedHandleValue,

                                   JS_DATA_TO_FUNC_PTR(JSPropertyOp, &getter.toObject()),

                                   nullptr, JSPROP_GETTER | JSPROP_SHARED))

     {

         return nullptr;

     }

     // 10.2.1 and 10.3

     if (!IntlInitialize(cx, proto, cx->names().InitializeCollator, UndefinedHandleValue,

                         UndefinedHandleValue))

     {

         return nullptr;

     }

     // 8.1

     RootedValue ctorValue(cx, ObjectValue(*ctor));

     if (!JSObject::defineProperty(cx, Intl, cx->names().Collator, ctorValue,

                                   JS_PropertyStub, JS_StrictPropertyStub, 0))

     {

         return nullptr;

     }

     return ctor;

 }

 bool

 GlobalObject::initCollatorProto(JSContext *cx, Handle<GlobalObject*> global)

 {

     RootedObject proto(cx, global->createBlankPrototype(cx, &CollatorClass));

     if (!proto)

         return false;

     proto->setReservedSlot(UCOLLATOR_SLOT, PrivateValue(nullptr));

     global->setReservedSlot(COLLATOR_PROTO, ObjectValue(*proto));

     return true;

 }

 bool

 js::intl_Collator_availableLocales(JSContext *cx, unsigned argc, Value *vp)

 {

     CallArgs args = CallArgsFromVp(argc, vp);

     JS_ASSERT(args.length() == 0);

     RootedValue result(cx);

     if (!intl_availableLocales(cx, ucol_countAvailable, ucol_getAvailable, &result))

         return false;

     args.rval().set(result);

     return true;

 }

 bool

 js::intl_availableCollations(JSContext *cx, unsigned argc, Value *vp)

 {

     CallArgs args = CallArgsFromVp(argc, vp);

     JS_ASSERT(args.length() == 1);

     JS_ASSERT(args[0].isString());

     JSAutoByteString locale(cx, args[0].toString());

     if (!locale)

         return false;

     UErrorCode status = U_ZERO_ERROR;

     UEnumeration *values = ucol_getKeywordValuesForLocale("co", locale.ptr(), false, &status);

     if (U_FAILURE(status)) {

         JS_ReportErrorNumber(cx, js_GetErrorMessage, nullptr, JSMSG_INTERNAL_INTL_ERROR);

         return false;

     }

     ScopedICUObject<UEnumeration> toClose(values, uenum_close);

     uint32_t count = uenum_count(values, &status);

     if (U_FAILURE(status)) {

         JS_ReportErrorNumber(cx, js_GetErrorMessage, nullptr, JSMSG_INTERNAL_INTL_ERROR);

         return false;

     }

     RootedObject collations(cx, NewDenseEmptyArray(cx));

     if (!collations)

         return false;

     uint32_t index = 0;

     for (uint32_t i = 0; i < count; i++) {

         const char *collation = uenum_next(values, nullptr, &status);

         if (U_FAILURE(status)) {

             JS_ReportErrorNumber(cx, js_GetErrorMessage, nullptr, JSMSG_INTERNAL_INTL_ERROR);

             return false;

         }

         // Per ECMA-402, 10.2.3, we don't include standard and search:

         // "The values 'standard' and 'search' must not be used as elements in

         // any [[sortLocaleData]][locale].co and [[searchLocaleData]][locale].co

         // array."

         if (equal(collation, "standard") || equal(collation, "search"))

             continue;

         // ICU returns old-style keyword values; map them to BCP 47 equivalents

         // (see http://bugs.icu-project.org/trac/ticket/9620).

         if (equal(collation, "dictionary"))

             collation = "dict";

         else if (equal(collation, "gb2312han"))

             collation = "gb2312";

         else if (equal(collation, "phonebook"))

             collation = "phonebk";

         else if (equal(collation, "traditional"))

             collation = "trad";

         RootedString jscollation(cx, JS_NewStringCopyZ(cx, collation));

         if (!jscollation)

             return false;

         RootedValue element(cx, StringValue(jscollation));

         if (!JSObject::defineElement(cx, collations, index++, element))

             return false;

     }

     args.rval().setObject(*collations);

     return true;

 }

 /**

  * Returns a new UCollator with the locale and collation options

  * of the given Collator.

  */

 static UCollator *

 NewUCollator(JSContext *cx, HandleObject collator)

 {

     RootedValue value(cx);

     RootedObject internals(cx);

     if (!GetInternals(cx, collator, &internals))

         return nullptr;

     if (!JSObject::getProperty(cx, internals, internals, cx->names().locale, &value))

         return nullptr;

     JSAutoByteString locale(cx, value.toString());

     if (!locale)

         return nullptr;

     // UCollator options with default values.

     UColAttributeValue uStrength = UCOL_DEFAULT;

     UColAttributeValue uCaseLevel = UCOL_OFF;

     UColAttributeValue uAlternate = UCOL_DEFAULT;

     UColAttributeValue uNumeric = UCOL_OFF;

     // Normalization is always on to meet the canonical equivalence requirement.

     UColAttributeValue uNormalization = UCOL_ON;

     UColAttributeValue uCaseFirst = UCOL_DEFAULT;

     if (!JSObject::getProperty(cx, internals, internals, cx->names().usage, &value))

         return nullptr;

     JSAutoByteString usage(cx, value.toString());

     if (!usage)

         return nullptr;

     if (equal(usage, "search")) {

         // ICU expects search as a Unicode locale extension on locale.

         // Unicode locale extensions must occur before private use extensions.

         const char *oldLocale = locale.ptr();

         const char *p;

         size_t index;

         size_t localeLen = strlen(oldLocale);

         if ((p = strstr(oldLocale, "-x-")))

             index = p - oldLocale;

         else

             index = localeLen;

         const char *insert;

         if ((p = strstr(oldLocale, "-u-")) && static_cast<size_t>(p - oldLocale) < index) {

             index = p - oldLocale + 2;

             insert = "-co-search";

         } else {

             insert = "-u-co-search";

         }

         size_t insertLen = strlen(insert);

         char *newLocale = cx->pod_malloc<char>(localeLen + insertLen + 1);

         if (!newLocale)

             return nullptr;

         memcpy(newLocale, oldLocale, index);

         memcpy(newLocale + index, insert, insertLen);

         memcpy(newLocale + index + insertLen, oldLocale + index, localeLen - index + 1); // '\0'

         locale.clear();

         locale.initBytes(newLocale);

     }

     // We don't need to look at the collation property - it can only be set

     // via the Unicode locale extension and is therefore already set on

     // locale.

     if (!JSObject::getProperty(cx, internals, internals, cx->names().sensitivity, &value))

         return nullptr;

     JSAutoByteString sensitivity(cx, value.toString());

     if (!sensitivity)

         return nullptr;

     if (equal(sensitivity, "base")) {

         uStrength = UCOL_PRIMARY;

     } else if (equal(sensitivity, "accent")) {

         uStrength = UCOL_SECONDARY;

     } else if (equal(sensitivity, "case")) {

         uStrength = UCOL_PRIMARY;

         uCaseLevel = UCOL_ON;

     } else {

         JS_ASSERT(equal(sensitivity, "variant"));

         uStrength = UCOL_TERTIARY;

     }

     if (!JSObject::getProperty(cx, internals, internals, cx->names().ignorePunctuation, &value))

         return nullptr;

     // According to the ICU team, UCOL_SHIFTED causes punctuation to be

     // ignored. Looking at Unicode Technical Report 35, Unicode Locale Data

     // Markup Language, "shifted" causes whitespace and punctuation to be

     // ignored - that's a bit more than asked for, but there's no way to get

     // less.

     if (value.toBoolean())

         uAlternate = UCOL_SHIFTED;

     if (!JSObject::getProperty(cx, internals, internals, cx->names().numeric, &value))

         return nullptr;

     if (!value.isUndefined() && value.toBoolean())

         uNumeric = UCOL_ON;

     if (!JSObject::getProperty(cx, internals, internals, cx->names().caseFirst, &value))

         return nullptr;

     if (!value.isUndefined()) {

         JSAutoByteString caseFirst(cx, value.toString());

         if (!caseFirst)

             return nullptr;

         if (equal(caseFirst, "upper"))

             uCaseFirst = UCOL_UPPER_FIRST;

         else if (equal(caseFirst, "lower"))

             uCaseFirst = UCOL_LOWER_FIRST;

         else

             JS_ASSERT(equal(caseFirst, "false"));

     }

     UErrorCode status = U_ZERO_ERROR;

     UCollator *coll = ucol_open(icuLocale(locale.ptr()), &status);

     if (U_FAILURE(status)) {

         JS_ReportErrorNumber(cx, js_GetErrorMessage, nullptr, JSMSG_INTERNAL_INTL_ERROR);

         return nullptr;

     }

     ucol_setAttribute(coll, UCOL_STRENGTH, uStrength, &status);

     ucol_setAttribute(coll, UCOL_CASE_LEVEL, uCaseLevel, &status);

     ucol_setAttribute(coll, UCOL_ALTERNATE_HANDLING, uAlternate, &status);

     ucol_setAttribute(coll, UCOL_NUMERIC_COLLATION, uNumeric, &status);

     ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, uNormalization, &status);

     ucol_setAttribute(coll, UCOL_CASE_FIRST, uCaseFirst, &status);

     if (U_FAILURE(status)) {

         ucol_close(coll);

         JS_ReportErrorNumber(cx, js_GetErrorMessage, nullptr, JSMSG_INTERNAL_INTL_ERROR);

         return nullptr;

     }

     return coll;

 }

 static bool

 intl_CompareStrings(JSContext *cx, UCollator *coll, HandleString str1, HandleString str2, MutableHandleValue result)

 {

     JS_ASSERT(str1);

     JS_ASSERT(str2);

     if (str1 == str2) {

         result.setInt32(0);

         return true;

     }

     size_t length1 = str1->length();

     const jschar *chars1 = str1->getChars(cx);

     if (!chars1)

         return false;

     size_t length2 = str2->length();

     const jschar *chars2 = str2->getChars(cx);

     if (!chars2)

         return false;

     UCollationResult uresult = ucol_strcoll(coll, JSCharToUChar(chars1),

                                             length1, JSCharToUChar(chars2),

                                             length2);

     int32_t res;

     switch (uresult) {

         case UCOL_LESS: res = -1; break;

         case UCOL_EQUAL: res = 0; break;

         case UCOL_GREATER: res = 1; break;

         default: MOZ_ASSUME_UNREACHABLE("ucol_strcoll returned bad UCollationResult");

     }

     result.setInt32(res);

     return true;

 }

 bool

 js::intl_CompareStrings(JSContext *cx, unsigned argc, Value *vp)

 {

     CallArgs args = CallArgsFromVp(argc, vp);

     JS_ASSERT(args.length() == 3);

     JS_ASSERT(args[0].isObject());

     JS_ASSERT(args[1].isString());

     JS_ASSERT(args[2].isString());

     RootedObject collator(cx, &args[0].toObject());

     // Obtain a UCollator object, cached if possible.

     // XXX Does this handle Collator instances from other globals correctly?

     bool isCollatorInstance = collator->getClass() == &CollatorClass;

     UCollator *coll;

     if (isCollatorInstance) {

         coll = static_cast<UCollator *>(collator->getReservedSlot(UCOLLATOR_SLOT).toPrivate());

         if (!coll) {

             coll = NewUCollator(cx, collator);

             if (!coll)

                 return false;

             collator->setReservedSlot(UCOLLATOR_SLOT, PrivateValue(coll));

         }

     } else {

         // There's no good place to cache the ICU collator for an object

         // that has been initialized as a Collator but is not a Collator

         // instance. One possibility might be to add a Collator instance as an

         // internal property to each such object.

         coll = NewUCollator(cx, collator);

         if (!coll)

             return false;

     }

     // Use the UCollator to actually compare the strings.

     RootedString str1(cx, args[1].toString());

     RootedString str2(cx, args[2].toString());

     RootedValue result(cx);

     bool success = intl_CompareStrings(cx, coll, str1, str2, &result);

     if (!isCollatorInstance)

         ucol_close(coll);

     if (!success)

         return false;

     args.rval().set(result);

     return true;

 }

 /******************** NumberFormat ********************/

 static void numberFormat_finalize(FreeOp *fop, JSObject *obj);

 static const uint32_t UNUMBER_FORMAT_SLOT = 0;

 static const uint32_t NUMBER_FORMAT_SLOTS_COUNT = 1;

 static const Class NumberFormatClass = {

     js_Object_str,

     JSCLASS_HAS_RESERVED_SLOTS(NUMBER_FORMAT_SLOTS_COUNT),

     JS_PropertyStub,         /* addProperty */

     JS_DeletePropertyStub,   /* delProperty */

     JS_PropertyStub,         /* getProperty */

     JS_StrictPropertyStub,   /* setProperty */

     JS_EnumerateStub,

     JS_ResolveStub,

     JS_ConvertStub,

     numberFormat_finalize

 };

 #if JS_HAS_TOSOURCE

 static bool

 numberFormat_toSource(JSContext *cx, unsigned argc, Value *vp)

 {

     CallArgs args = CallArgsFromVp(argc, vp);

     args.rval().setString(cx->names().NumberFormat);

     return true;

 }

 #endif

 static const JSFunctionSpec numberFormat_static_methods[] = {

     JS_SELF_HOSTED_FN("supportedLocalesOf", "Intl_NumberFormat_supportedLocalesOf", 1, 0),

     JS_FS_END

 };

 static const JSFunctionSpec numberFormat_methods[] = {

     JS_SELF_HOSTED_FN("resolvedOptions", "Intl_NumberFormat_resolvedOptions", 0, 0),

 #if JS_HAS_TOSOURCE

     JS_FN(js_toSource_str, numberFormat_toSource, 0, 0),

 #endif

     JS_FS_END

 };

 /**

  * NumberFormat constructor.

  * Spec: ECMAScript Internationalization API Specification, 11.1

  */

 static bool

 NumberFormat(JSContext *cx, CallArgs args, bool construct)

 {

     RootedObject obj(cx);

     if (!construct) {

         // 11.1.2.1 step 3

         JSObject *intl = cx->global()->getOrCreateIntlObject(cx);

         if (!intl)

             return false;

         RootedValue self(cx, args.thisv());

         if (!self.isUndefined() && (!self.isObject() || self.toObject() != *intl)) {

             // 11.1.2.1 step 4

             obj = ToObject(cx, self);

             if (!obj)

                 return false;

             // 11.1.2.1 step 5

             bool extensible;

             if (!JSObject::isExtensible(cx, obj, &extensible))

                 return false;

             if (!extensible)

                 return Throw(cx, obj, JSMSG_OBJECT_NOT_EXTENSIBLE);

         } else {

             // 11.1.2.1 step 3.a

             construct = true;

         }

     }

     if (construct) {

         // 11.1.3.1 paragraph 2

         RootedObject proto(cx, cx->global()->getOrCreateNumberFormatPrototype(cx));

         if (!proto)

             return false;

         obj = NewObjectWithGivenProto(cx, &NumberFormatClass, proto, cx->global());

         if (!obj)

             return false;

         obj->setReservedSlot(UNUMBER_FORMAT_SLOT, PrivateValue(nullptr));

     }

     // 11.1.2.1 steps 1 and 2; 11.1.3.1 steps 1 and 2

     RootedValue locales(cx, args.length() > 0 ? args[0] : UndefinedValue());

     RootedValue options(cx, args.length() > 1 ? args[1] : UndefinedValue());

     // 11.1.2.1 step 6; 11.1.3.1 step 3

     if (!IntlInitialize(cx, obj, cx->names().InitializeNumberFormat, locales, options))

         return false;

     // 11.1.2.1 steps 3.a and 7

     args.rval().setObject(*obj);

     return true;

 }

 static bool

 NumberFormat(JSContext *cx, unsigned argc, Value *vp)

 {

     CallArgs args = CallArgsFromVp(argc, vp);

     return NumberFormat(cx, args, args.isConstructing());

 }

 bool

 js::intl_NumberFormat(JSContext *cx, unsigned argc, Value *vp)

 {

     CallArgs args = CallArgsFromVp(argc, vp);

     JS_ASSERT(args.length() == 2);

     // intl_NumberFormat is an intrinsic for self-hosted JavaScript, so it

     // cannot be used with "new", but it still has to be treated as a

     // constructor.

     return NumberFormat(cx, args, true);

 }

 static void

 numberFormat_finalize(FreeOp *fop, JSObject *obj)

 {

     UNumberFormat *nf =

         static_cast<UNumberFormat*>(obj->getReservedSlot(UNUMBER_FORMAT_SLOT).toPrivate());

     if (nf)

         unum_close(nf);

 }

 static JSObject *

 InitNumberFormatClass(JSContext *cx, HandleObject Intl, Handle<GlobalObject*> global)

 {

     RootedFunction ctor(cx, global->createConstructor(cx, &NumberFormat, cx->names().NumberFormat, 0));

     if (!ctor)

         return nullptr;

     RootedObject proto(cx, global->as<GlobalObject>().getOrCreateNumberFormatPrototype(cx));

     if (!proto)

         return nullptr;

     if (!LinkConstructorAndPrototype(cx, ctor, proto))

         return nullptr;

     // 11.2.2

     if (!JS_DefineFunctions(cx, ctor, numberFormat_static_methods))

         return nullptr;

     // 11.3.2 and 11.3.3

     if (!JS_DefineFunctions(cx, proto, numberFormat_methods))

         return nullptr;

     /*

      * Install the getter for NumberFormat.prototype.format, which returns a

      * bound formatting function for the specified NumberFormat object (suitable

      * for passing to methods like Array.prototype.map).

      */

     RootedValue getter(cx);

     if (!GlobalObject::getIntrinsicValue(cx, cx->global(), cx->names().NumberFormatFormatGet, &getter))

         return nullptr;

     if (!JSObject::defineProperty(cx, proto, cx->names().format, UndefinedHandleValue,

                                   JS_DATA_TO_FUNC_PTR(JSPropertyOp, &getter.toObject()),

                                   nullptr, JSPROP_GETTER | JSPROP_SHARED))

     {

         return nullptr;

     }

     // 11.2.1 and 11.3

     if (!IntlInitialize(cx, proto, cx->names().InitializeNumberFormat, UndefinedHandleValue,

                         UndefinedHandleValue))

     {

         return nullptr;

     }

     // 8.1

     RootedValue ctorValue(cx, ObjectValue(*ctor));

     if (!JSObject::defineProperty(cx, Intl, cx->names().NumberFormat, ctorValue,

                                   JS_PropertyStub, JS_StrictPropertyStub, 0))

     {

         return nullptr;

     }

     return ctor;

 }

 bool

 GlobalObject::initNumberFormatProto(JSContext *cx, Handle<GlobalObject*> global)

 {

     RootedObject proto(cx, global->createBlankPrototype(cx, &NumberFormatClass));

     if (!proto)

         return false;

     proto->setReservedSlot(UNUMBER_FORMAT_SLOT, PrivateValue(nullptr));

     global->setReservedSlot(NUMBER_FORMAT_PROTO, ObjectValue(*proto));

     return true;

 }

 bool

 js::intl_NumberFormat_availableLocales(JSContext *cx, unsigned argc, Value *vp)

 {

     CallArgs args = CallArgsFromVp(argc, vp);

     JS_ASSERT(args.length() == 0);

     RootedValue result(cx);

     if (!intl_availableLocales(cx, unum_countAvailable, unum_getAvailable, &result))

         return false;

     args.rval().set(result);

     return true;

 }

 bool

 js::intl_numberingSystem(JSContext *cx, unsigned argc, Value *vp)

 {

     CallArgs args = CallArgsFromVp(argc, vp);

     JS_ASSERT(args.length() == 1);

     JS_ASSERT(args[0].isString());

     JSAutoByteString locale(cx, args[0].toString());

     if (!locale)

         return false;

     // There's no C API for numbering system, so use the C++ API and hope it

     // won't break. http://bugs.icu-project.org/trac/ticket/10039

     Locale ulocale(locale.ptr());

     UErrorCode status = U_ZERO_ERROR;

     NumberingSystem *numbers = NumberingSystem::createInstance(ulocale, status);

     if (U_FAILURE(status)) {

         JS_ReportErrorNumber(cx, js_GetErrorMessage, nullptr, JSMSG_INTERNAL_INTL_ERROR);

         return false;

     }

     const char *name = numbers->getName();

     RootedString jsname(cx, JS_NewStringCopyZ(cx, name));

     delete numbers;

     if (!jsname)

         return false;

     args.rval().setString(jsname);

     return true;

 }

 /**

  * Returns a new UNumberFormat with the locale and number formatting options

  * of the given NumberFormat.

  */

 static UNumberFormat *

 NewUNumberFormat(JSContext *cx, HandleObject numberFormat)

 {

     RootedValue value(cx);

     RootedObject internals(cx);

     if (!GetInternals(cx, numberFormat, &internals))

        return nullptr;

     if (!JSObject::getProperty(cx, internals, internals, cx->names().locale, &value))

         return nullptr;

     JSAutoByteString locale(cx, value.toString());

     if (!locale)

         return nullptr;

     // UNumberFormat options with default values

     UNumberFormatStyle uStyle = UNUM_DECIMAL;

     const UChar *uCurrency = nullptr;

     uint32_t uMinimumIntegerDigits = 1;

     uint32_t uMinimumFractionDigits = 0;

     uint32_t uMaximumFractionDigits = 3;

     int32_t uMinimumSignificantDigits = -1;

     int32_t uMaximumSignificantDigits = -1;

     bool uUseGrouping = true;

     // Sprinkle appropriate rooting flavor over things the GC might care about.

     RootedString currency(cx);

     // We don't need to look at numberingSystem - it can only be set via

     // the Unicode locale extension and is therefore already set on locale.

     if (!JSObject::getProperty(cx, internals, internals, cx->names().style, &value))

         return nullptr;

     JSAutoByteString style(cx, value.toString());

     if (!style)

         return nullptr;

     if (equal(style, "currency")) {

         if (!JSObject::getProperty(cx, internals, internals, cx->names().currency, &value))

             return nullptr;

         currency = value.toString();

         MOZ_ASSERT(currency->length() == 3, "IsWellFormedCurrencyCode permits only length-3 strings");

         // uCurrency remains owned by currency.

         uCurrency = JSCharToUChar(JS_GetStringCharsZ(cx, currency));

         if (!uCurrency)

             return nullptr;

         if (!JSObject::getProperty(cx, internals, internals, cx->names().currencyDisplay, &value))

             return nullptr;

         JSAutoByteString currencyDisplay(cx, value.toString());

         if (!currencyDisplay)

             return nullptr;

         if (equal(currencyDisplay, "code")) {

             uStyle = UNUM_CURRENCY_ISO;

         } else if (equal(currencyDisplay, "symbol")) {

             uStyle = UNUM_CURRENCY;

         } else {

             JS_ASSERT(equal(currencyDisplay, "name"));

             uStyle = UNUM_CURRENCY_PLURAL;

         }

     } else if (equal(style, "percent")) {

         uStyle = UNUM_PERCENT;

     } else {

         JS_ASSERT(equal(style, "decimal"));

         uStyle = UNUM_DECIMAL;

     }

     RootedId id(cx, NameToId(cx->names().minimumSignificantDigits));

     bool hasP;

     if (!JSObject::hasProperty(cx, internals, id, &hasP))

         return nullptr;

     if (hasP) {

         if (!JSObject::getProperty(cx, internals, internals, cx->names().minimumSignificantDigits,

                                    &value))

         {

             return nullptr;

         }

         uMinimumSignificantDigits = int32_t(value.toNumber());

         if (!JSObject::getProperty(cx, internals, internals, cx->names().maximumSignificantDigits,

                                    &value))

         {

             return nullptr;

         }

         uMaximumSignificantDigits = int32_t(value.toNumber());

     } else {

         if (!JSObject::getProperty(cx, internals, internals, cx->names().minimumIntegerDigits,

                                    &value))

         {

             return nullptr;

         }

         uMinimumIntegerDigits = int32_t(value.toNumber());

         if (!JSObject::getProperty(cx, internals, internals, cx->names().minimumFractionDigits,

                                    &value))

         {

             return nullptr;

         }

         uMinimumFractionDigits = int32_t(value.toNumber());

         if (!JSObject::getProperty(cx, internals, internals, cx->names().maximumFractionDigits,

                                    &value))

         {

             return nullptr;

         }

         uMaximumFractionDigits = int32_t(value.toNumber());

     }

     if (!JSObject::getProperty(cx, internals, internals, cx->names().useGrouping, &value))

         return nullptr;

     uUseGrouping = value.toBoolean();

     UErrorCode status = U_ZERO_ERROR;

     UNumberFormat *nf = unum_open(uStyle, nullptr, 0, icuLocale(locale.ptr()), nullptr, &status);

     if (U_FAILURE(status)) {

         JS_ReportErrorNumber(cx, js_GetErrorMessage, nullptr, JSMSG_INTERNAL_INTL_ERROR);

         return nullptr;

     }

     ScopedICUObject<UNumberFormat> toClose(nf, unum_close);

     if (uCurrency) {

         unum_setTextAttribute(nf, UNUM_CURRENCY_CODE, uCurrency, 3, &status);

         if (U_FAILURE(status)) {

             JS_ReportErrorNumber(cx, js_GetErrorMessage, nullptr, JSMSG_INTERNAL_INTL_ERROR);

             return nullptr;

         }

     }

     if (uMinimumSignificantDigits != -1) {

         unum_setAttribute(nf, UNUM_SIGNIFICANT_DIGITS_USED, true);

         unum_setAttribute(nf, UNUM_MIN_SIGNIFICANT_DIGITS, uMinimumSignificantDigits);

         unum_setAttribute(nf, UNUM_MAX_SIGNIFICANT_DIGITS, uMaximumSignificantDigits);

     } else {

         unum_setAttribute(nf, UNUM_MIN_INTEGER_DIGITS, uMinimumIntegerDigits);

         unum_setAttribute(nf, UNUM_MIN_FRACTION_DIGITS, uMinimumFractionDigits);

         unum_setAttribute(nf, UNUM_MAX_FRACTION_DIGITS, uMaximumFractionDigits);

     }

     unum_setAttribute(nf, UNUM_GROUPING_USED, uUseGrouping);

     unum_setAttribute(nf, UNUM_ROUNDING_MODE, UNUM_ROUND_HALFUP);

     return toClose.forget();

 }

 static bool

 intl_FormatNumber(JSContext *cx, UNumberFormat *nf, double x, MutableHandleValue result)

 {

     // FormatNumber doesn't consider -0.0 to be negative.

     if (IsNegativeZero(x))

         x = 0.0;

     StringBuffer chars(cx);

     if (!chars.resize(INITIAL_STRING_BUFFER_SIZE))

         return false;

     UErrorCode status = U_ZERO_ERROR;

     int size = unum_formatDouble(nf, x, JSCharToUChar(chars.begin()),

                                  INITIAL_STRING_BUFFER_SIZE, nullptr, &status);

     if (status == U_BUFFER_OVERFLOW_ERROR) {

         if (!chars.resize(size))

             return false;

         status = U_ZERO_ERROR;

         unum_formatDouble(nf, x, JSCharToUChar(chars.begin()),

                           size, nullptr, &status);

     }

     if (U_FAILURE(status)) {

         JS_ReportErrorNumber(cx, js_GetErrorMessage, nullptr, JSMSG_INTERNAL_INTL_ERROR);

         return false;

     }

     // Trim any unused characters.

     if (!chars.resize(size))

         return false;

     RootedString str(cx, chars.finishString());

     if (!str)

         return false;

     result.setString(str);

     return true;

 }

 bool

 js::intl_FormatNumber(JSContext *cx, unsigned argc, Value *vp)

 {

     CallArgs args = CallArgsFromVp(argc, vp);

     JS_ASSERT(args.length() == 2);

     JS_ASSERT(args[0].isObject());

     JS_ASSERT(args[1].isNumber());

     RootedObject numberFormat(cx, &args[0].toObject());

     // Obtain a UNumberFormat object, cached if possible.

     bool isNumberFormatInstance = numberFormat->getClass() == &NumberFormatClass;

     UNumberFormat *nf;

     if (isNumberFormatInstance) {

         nf = static_cast<UNumberFormat*>(numberFormat->getReservedSlot(UNUMBER_FORMAT_SLOT).toPrivate());

         if (!nf) {

             nf = NewUNumberFormat(cx, numberFormat);

             if (!nf)

                 return false;

             numberFormat->setReservedSlot(UNUMBER_FORMAT_SLOT, PrivateValue(nf));

         }

     } else {

         // There's no good place to cache the ICU number format for an object

         // that has been initialized as a NumberFormat but is not a

         // NumberFormat instance. One possibility might be to add a

         // NumberFormat instance as an internal property to each such object.

         nf = NewUNumberFormat(cx, numberFormat);

         if (!nf)

             return false;

     }

     // Use the UNumberFormat to actually format the number.

     RootedValue result(cx);

     bool success = intl_FormatNumber(cx, nf, args[1].toNumber(), &result);

     if (!isNumberFormatInstance)

         unum_close(nf);

     if (!success)

         return false;

     args.rval().set(result);

     return true;

 }

 /******************** DateTimeFormat ********************/

 static void dateTimeFormat_finalize(FreeOp *fop, JSObject *obj);

 static const uint32_t UDATE_FORMAT_SLOT = 0;

 static const uint32_t DATE_TIME_FORMAT_SLOTS_COUNT = 1;

 static const Class DateTimeFormatClass = {

     js_Object_str,

     JSCLASS_HAS_RESERVED_SLOTS(DATE_TIME_FORMAT_SLOTS_COUNT),

     JS_PropertyStub,         /* addProperty */

     JS_DeletePropertyStub,   /* delProperty */

     JS_PropertyStub,         /* getProperty */

     JS_StrictPropertyStub,   /* setProperty */

     JS_EnumerateStub,

     JS_ResolveStub,

     JS_ConvertStub,

     dateTimeFormat_finalize

 };

 #if JS_HAS_TOSOURCE

 static bool

 dateTimeFormat_toSource(JSContext *cx, unsigned argc, Value *vp)

 {

     CallArgs args = CallArgsFromVp(argc, vp);

     args.rval().setString(cx->names().DateTimeFormat);

     return true;

 }

 #endif

 static const JSFunctionSpec dateTimeFormat_static_methods[] = {

     JS_SELF_HOSTED_FN("supportedLocalesOf", "Intl_DateTimeFormat_supportedLocalesOf", 1, 0),

     JS_FS_END

 };

 static const JSFunctionSpec dateTimeFormat_methods[] = {

     JS_SELF_HOSTED_FN("resolvedOptions", "Intl_DateTimeFormat_resolvedOptions", 0, 0),

 #if JS_HAS_TOSOURCE

     JS_FN(js_toSource_str, dateTimeFormat_toSource, 0, 0),

 #endif

     JS_FS_END

 };

 /**

  * DateTimeFormat constructor.

  * Spec: ECMAScript Internationalization API Specification, 12.1

  */

 static bool

 DateTimeFormat(JSContext *cx, CallArgs args, bool construct)

 {

     RootedObject obj(cx);

     if (!construct) {

         // 12.1.2.1 step 3

         JSObject *intl = cx->global()->getOrCreateIntlObject(cx);

         if (!intl)

             return false;

         RootedValue self(cx, args.thisv());

         if (!self.isUndefined() && (!self.isObject() || self.toObject() != *intl)) {

             // 12.1.2.1 step 4

             obj = ToObject(cx, self);

             if (!obj)

                 return false;

             // 12.1.2.1 step 5

             bool extensible;

             if (!JSObject::isExtensible(cx, obj, &extensible))

                 return false;

             if (!extensible)

                 return Throw(cx, obj, JSMSG_OBJECT_NOT_EXTENSIBLE);

         } else {

             // 12.1.2.1 step 3.a

             construct = true;

         }

     }

     if (construct) {

         // 12.1.3.1 paragraph 2

         RootedObject proto(cx, cx->global()->getOrCreateDateTimeFormatPrototype(cx));

         if (!proto)

             return false;

         obj = NewObjectWithGivenProto(cx, &DateTimeFormatClass, proto, cx->global());

         if (!obj)

             return false;

         obj->setReservedSlot(UDATE_FORMAT_SLOT, PrivateValue(nullptr));

     }

     // 12.1.2.1 steps 1 and 2; 12.1.3.1 steps 1 and 2

     RootedValue locales(cx, args.length() > 0 ? args[0] : UndefinedValue());

     RootedValue options(cx, args.length() > 1 ? args[1] : UndefinedValue());

     // 12.1.2.1 step 6; 12.1.3.1 step 3

     if (!IntlInitialize(cx, obj, cx->names().InitializeDateTimeFormat, locales, options))

         return false;

     // 12.1.2.1 steps 3.a and 7

     args.rval().setObject(*obj);

     return true;

 }

 static bool

 DateTimeFormat(JSContext *cx, unsigned argc, Value *vp)

 {

     CallArgs args = CallArgsFromVp(argc, vp);

     return DateTimeFormat(cx, args, args.isConstructing());

 }

 bool

 js::intl_DateTimeFormat(JSContext *cx, unsigned argc, Value *vp)

 {

     CallArgs args = CallArgsFromVp(argc, vp);

     JS_ASSERT(args.length() == 2);

     // intl_DateTimeFormat is an intrinsic for self-hosted JavaScript, so it

     // cannot be used with "new", but it still has to be treated as a

     // constructor.

     return DateTimeFormat(cx, args, true);

 }

 static void

 dateTimeFormat_finalize(FreeOp *fop, JSObject *obj)

 {

     UDateFormat *df = static_cast<UDateFormat*>(obj->getReservedSlot(UDATE_FORMAT_SLOT).toPrivate());

     if (df)

         udat_close(df);

 }

 static JSObject *

 InitDateTimeFormatClass(JSContext *cx, HandleObject Intl, Handle<GlobalObject*> global)

 {

     RootedFunction ctor(cx, global->createConstructor(cx, &DateTimeFormat, cx->names().DateTimeFormat, 0));

     if (!ctor)

         return nullptr;

     RootedObject proto(cx, global->as<GlobalObject>().getOrCreateDateTimeFormatPrototype(cx));

     if (!proto)

         return nullptr;

     if (!LinkConstructorAndPrototype(cx, ctor, proto))

         return nullptr;

     // 12.2.2

     if (!JS_DefineFunctions(cx, ctor, dateTimeFormat_static_methods))

         return nullptr;

     // 12.3.2 and 12.3.3

     if (!JS_DefineFunctions(cx, proto, dateTimeFormat_methods))

         return nullptr;

     /*

      * Install the getter for DateTimeFormat.prototype.format, which returns a

      * bound formatting function for the specified DateTimeFormat object

      * (suitable for passing to methods like Array.prototype.map).

      */

     RootedValue getter(cx);

     if (!GlobalObject::getIntrinsicValue(cx, cx->global(), cx->names().DateTimeFormatFormatGet, &getter))

         return nullptr;

     if (!JSObject::defineProperty(cx, proto, cx->names().format, UndefinedHandleValue,

                                   JS_DATA_TO_FUNC_PTR(JSPropertyOp, &getter.toObject()),

                                   nullptr, JSPROP_GETTER | JSPROP_SHARED))

     {

         return nullptr;

     }

     // 12.2.1 and 12.3

     if (!IntlInitialize(cx, proto, cx->names().InitializeDateTimeFormat, UndefinedHandleValue,

                         UndefinedHandleValue))

     {

         return nullptr;

     }

     // 8.1

     RootedValue ctorValue(cx, ObjectValue(*ctor));

     if (!JSObject::defineProperty(cx, Intl, cx->names().DateTimeFormat, ctorValue,

                                   JS_PropertyStub, JS_StrictPropertyStub, 0))

     {

         return nullptr;

     }

     return ctor;

 }

 bool

 GlobalObject::initDateTimeFormatProto(JSContext *cx, Handle<GlobalObject*> global)

 {

     RootedObject proto(cx, global->createBlankPrototype(cx, &DateTimeFormatClass));

     if (!proto)

         return false;

     proto->setReservedSlot(UDATE_FORMAT_SLOT, PrivateValue(nullptr));

     global->setReservedSlot(DATE_TIME_FORMAT_PROTO, ObjectValue(*proto));

     return true;

 }

 bool

 js::intl_DateTimeFormat_availableLocales(JSContext *cx, unsigned argc, Value *vp)

 {

     CallArgs args = CallArgsFromVp(argc, vp);

     JS_ASSERT(args.length() == 0);

     RootedValue result(cx);

     if (!intl_availableLocales(cx, udat_countAvailable, udat_getAvailable, &result))

         return false;

     args.rval().set(result);

     return true;

 }

 // ICU returns old-style keyword values; map them to BCP 47 equivalents

 // (see http://bugs.icu-project.org/trac/ticket/9620).

 static const char *

 bcp47CalendarName(const char *icuName)

 {

     if (equal(icuName, "ethiopic-amete-alem"))

         return "ethioaa";

     if (equal(icuName, "gregorian"))

         return "gregory";

     if (equal(icuName, "islamic-civil"))

         return "islamicc";

     return icuName;

 }

 bool

 js::intl_availableCalendars(JSContext *cx, unsigned argc, Value *vp)

 {

     CallArgs args = CallArgsFromVp(argc, vp);

     JS_ASSERT(args.length() == 1);

     JS_ASSERT(args[0].isString());

     JSAutoByteString locale(cx, args[0].toString());

     if (!locale)

         return false;

     RootedObject calendars(cx, NewDenseEmptyArray(cx));

     if (!calendars)

         return false;

     uint32_t index = 0;

     // We need the default calendar for the locale as the first result.

     UErrorCode status = U_ZERO_ERROR;

     UCalendar *cal = ucal_open(nullptr, 0, locale.ptr(), UCAL_DEFAULT, &status);

     const char *calendar = ucal_getType(cal, &status);

     if (U_FAILURE(status)) {

         JS_ReportErrorNumber(cx, js_GetErrorMessage, nullptr, JSMSG_INTERNAL_INTL_ERROR);

         return false;

     }

     ucal_close(cal);

     RootedString jscalendar(cx, JS_NewStringCopyZ(cx, bcp47CalendarName(calendar)));

     if (!jscalendar)

         return false;

     RootedValue element(cx, StringValue(jscalendar));

     if (!JSObject::defineElement(cx, calendars, index++, element))

         return false;

     // Now get the calendars that "would make a difference", i.e., not the default.

     UEnumeration *values = ucal_getKeywordValuesForLocale("ca", locale.ptr(), false, &status);

     if (U_FAILURE(status)) {

         JS_ReportErrorNumber(cx, js_GetErrorMessage, nullptr, JSMSG_INTERNAL_INTL_ERROR);

         return false;

     }

     ScopedICUObject<UEnumeration> toClose(values, uenum_close);

     uint32_t count = uenum_count(values, &status);

     if (U_FAILURE(status)) {

         JS_ReportErrorNumber(cx, js_GetErrorMessage, nullptr, JSMSG_INTERNAL_INTL_ERROR);

         return false;

     }

     for (; count > 0; count--) {

         calendar = uenum_next(values, nullptr, &status);

         if (U_FAILURE(status)) {

             JS_ReportErrorNumber(cx, js_GetErrorMessage, nullptr, JSMSG_INTERNAL_INTL_ERROR);

             return false;

         }

         jscalendar = JS_NewStringCopyZ(cx, bcp47CalendarName(calendar));

         if (!jscalendar)

             return false;

         element = StringValue(jscalendar);

         if (!JSObject::defineElement(cx, calendars, index++, element))

             return false;

     }

     args.rval().setObject(*calendars);

     return true;

 }

 bool

 js::intl_patternForSkeleton(JSContext *cx, unsigned argc, Value *vp)

 {

     CallArgs args = CallArgsFromVp(argc, vp);

     JS_ASSERT(args.length() == 2);

     JS_ASSERT(args[0].isString());

     JS_ASSERT(args[1].isString());

     JSAutoByteString locale(cx, args[0].toString());

     if (!locale)

         return false;

     RootedString jsskeleton(cx, args[1].toString());

     const jschar *skeleton = JS_GetStringCharsZ(cx, jsskeleton);

     if (!skeleton)

         return false;

     uint32_t skeletonLen = u_strlen(JSCharToUChar(skeleton));

     UErrorCode status = U_ZERO_ERROR;

     UDateTimePatternGenerator *gen = udatpg_open(icuLocale(locale.ptr()), &status);

     if (U_FAILURE(status)) {

         JS_ReportErrorNumber(cx, js_GetErrorMessage, nullptr, JSMSG_INTERNAL_INTL_ERROR);

         return false;

     }

     ScopedICUObject<UDateTimePatternGenerator> toClose(gen, udatpg_close);

     int32_t size = udatpg_getBestPattern(gen, JSCharToUChar(skeleton),

                                          skeletonLen, nullptr, 0, &status);

     if (U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR) {

         JS_ReportErrorNumber(cx, js_GetErrorMessage, nullptr, JSMSG_INTERNAL_INTL_ERROR);

         return false;

     }

     ScopedJSFreePtr<UChar> pattern(cx->pod_malloc<UChar>(size + 1));

     if (!pattern)

         return false;

     pattern[size] = '\0';

     status = U_ZERO_ERROR;

     udatpg_getBestPattern(gen, JSCharToUChar(skeleton),

                           skeletonLen, pattern, size, &status);

     if (U_FAILURE(status)) {

         JS_ReportErrorNumber(cx, js_GetErrorMessage, nullptr, JSMSG_INTERNAL_INTL_ERROR);

         return false;

     }

     RootedString str(cx, JS_NewUCStringCopyZ(cx, reinterpret_cast<jschar*>(pattern.get())));

     if (!str)

         return false;

     args.rval().setString(str);

     return true;

 }

 /**

  * Returns a new UDateFormat with the locale and date-time formatting options

  * of the given DateTimeFormat.

  */

 static UDateFormat *

 NewUDateFormat(JSContext *cx, HandleObject dateTimeFormat)

 {

     RootedValue value(cx);

     RootedObject internals(cx);

     if (!GetInternals(cx, dateTimeFormat, &internals))

        return nullptr;

     if (!JSObject::getProperty(cx, internals, internals, cx->names().locale, &value)) {

         return nullptr;

     }

     JSAutoByteString locale(cx, value.toString());

     if (!locale)

         return nullptr;

     // UDateFormat options with default values.

     const UChar *uTimeZone = nullptr;

     uint32_t uTimeZoneLength = 0;

     const UChar *uPattern = nullptr;

     uint32_t uPatternLength = 0;

     // We don't need to look at calendar and numberingSystem - they can only be

     // set via the Unicode locale extension and are therefore already set on

     // locale.

     RootedId id(cx, NameToId(cx->names().timeZone));

     bool hasP;

     if (!JSObject::hasProperty(cx, internals, id, &hasP))

         return nullptr;

     if (hasP) {

         if (!JSObject::getProperty(cx, internals, internals, cx->names().timeZone, &value))

             return nullptr;

         if (!value.isUndefined()) {

             uTimeZone = JSCharToUChar(JS_GetStringCharsZ(cx, value.toString()));

             if (!uTimeZone)

                 return nullptr;

             uTimeZoneLength = u_strlen(uTimeZone);

         }

     }

     if (!JSObject::getProperty(cx, internals, internals, cx->names().pattern, &value))

         return nullptr;

     uPattern = JSCharToUChar(JS_GetStringCharsZ(cx, value.toString()));

     if (!uPattern)

         return nullptr;

     uPatternLength = u_strlen(uPattern);

     UErrorCode status = U_ZERO_ERROR;

     // If building with ICU headers before 50.1, use UDAT_IGNORE instead of

     // UDAT_PATTERN.

     UDateFormat *df =

         udat_open(UDAT_PATTERN, UDAT_PATTERN, icuLocale(locale.ptr()), uTimeZone, uTimeZoneLength,

                   uPattern, uPatternLength, &status);

     if (U_FAILURE(status)) {

         JS_ReportErrorNumber(cx, js_GetErrorMessage, nullptr, JSMSG_INTERNAL_INTL_ERROR);

         return nullptr;

     }

     // ECMAScript requires the Gregorian calendar to be used from the beginning

     // of ECMAScript time.

     UCalendar *cal = const_cast<UCalendar*>(udat_getCalendar(df));

     ucal_setGregorianChange(cal, StartOfTime, &status);

     // An error here means the calendar is not Gregorian, so we don't care.

     return df;

 }

 static bool

 intl_FormatDateTime(JSContext *cx, UDateFormat *df, double x, MutableHandleValue result)

 {

     if (!IsFinite(x)) {

         JS_ReportErrorNumber(cx, js_GetErrorMessage, nullptr, JSMSG_DATE_NOT_FINITE);

         return false;

     }

     StringBuffer chars(cx);

     if (!chars.resize(INITIAL_STRING_BUFFER_SIZE))

         return false;

     UErrorCode status = U_ZERO_ERROR;

     int size = udat_format(df, x, JSCharToUChar(chars.begin()), INITIAL_STRING_BUFFER_SIZE, nullptr, &status);

     if (status == U_BUFFER_OVERFLOW_ERROR) {

         if (!chars.resize(size))

             return false;

         status = U_ZERO_ERROR;

         udat_format(df, x, JSCharToUChar(chars.begin()), size, nullptr, &status);

     }

     if (U_FAILURE(status)) {

         JS_ReportErrorNumber(cx, js_GetErrorMessage, nullptr, JSMSG_INTERNAL_INTL_ERROR);

         return false;

     }

     // Trim any unused characters.

     if (!chars.resize(size))

         return false;

     RootedString str(cx, chars.finishString());

     if (!str)

         return false;

     result.setString(str);

     return true;

 }

 bool

 js::intl_FormatDateTime(JSContext *cx, unsigned argc, Value *vp)

 {

     CallArgs args = CallArgsFromVp(argc, vp);

     JS_ASSERT(args.length() == 2);

     JS_ASSERT(args[0].isObject());

     JS_ASSERT(args[1].isNumber());

     RootedObject dateTimeFormat(cx, &args[0].toObject());

     // Obtain a UDateFormat object, cached if possible.

     bool isDateTimeFormatInstance = dateTimeFormat->getClass() == &DateTimeFormatClass;

     UDateFormat *df;

     if (isDateTimeFormatInstance) {

         df = static_cast<UDateFormat*>(dateTimeFormat->getReservedSlot(UDATE_FORMAT_SLOT).toPrivate());

         if (!df) {

             df = NewUDateFormat(cx, dateTimeFormat);

             if (!df)

                 return false;

             dateTimeFormat->setReservedSlot(UDATE_FORMAT_SLOT, PrivateValue(df));

         }

     } else {

         // There's no good place to cache the ICU date-time format for an object

         // that has been initialized as a DateTimeFormat but is not a

         // DateTimeFormat instance. One possibility might be to add a

         // DateTimeFormat instance as an internal property to each such object.

         df = NewUDateFormat(cx, dateTimeFormat);

         if (!df)

             return false;

     }

     // Use the UDateFormat to actually format the time stamp.

     RootedValue result(cx);

     bool success = intl_FormatDateTime(cx, df, args[1].toNumber(), &result);

     if (!isDateTimeFormatInstance)

         udat_close(df);

     if (!success)

         return false;

     args.rval().set(result);

     return true;

 }

 /******************** Intl ********************/

 const Class js::IntlClass = {

     js_Object_str,

     JSCLASS_HAS_CACHED_PROTO(JSProto_Intl),

     JS_PropertyStub,         /* addProperty */

     JS_DeletePropertyStub,   /* delProperty */

     JS_PropertyStub,         /* getProperty */

     JS_StrictPropertyStub,   /* setProperty */

     JS_EnumerateStub,

     JS_ResolveStub,

     JS_ConvertStub

 };

 #if JS_HAS_TOSOURCE

 static bool

 intl_toSource(JSContext *cx, unsigned argc, Value *vp)

 {

     CallArgs args = CallArgsFromVp(argc, vp);

     args.rval().setString(cx->names().Intl);

     return true;

 }

 #endif

 static const JSFunctionSpec intl_static_methods[] = {

 #if JS_HAS_TOSOURCE

     JS_FN(js_toSource_str,  intl_toSource,        0, 0),

 #endif

     JS_FS_END

 };

 /**

  * Initializes the Intl Object and its standard built-in properties.

  * Spec: ECMAScript Internationalization API Specification, 8.0, 8.1

  */

 JSObject *

 js_InitIntlClass(JSContext *cx, HandleObject obj)

 {

     JS_ASSERT(obj->is<GlobalObject>());

     Rooted<GlobalObject*> global(cx, &obj->as<GlobalObject>());

     // The constructors above need to be able to determine whether they've been

     // called with this being "the standard built-in Intl object". The global

     // object reserves slots to track standard built-in objects, but doesn't

     // normally keep references to non-constructors. This makes sure there is one.

     RootedObject Intl(cx, global->getOrCreateIntlObject(cx));

     if (!Intl)

         return nullptr;

     RootedValue IntlValue(cx, ObjectValue(*Intl));

     if (!JSObject::defineProperty(cx, global, cx->names().Intl, IntlValue,

                                   JS_PropertyStub, JS_StrictPropertyStub, 0))

     {

         return nullptr;

     }

     if (!JS_DefineFunctions(cx, Intl, intl_static_methods))

         return nullptr;

     // Skip initialization of the Intl constructors during initialization of the

     // self-hosting global as we may get here before self-hosted code is compiled,

     // and no core code refers to the Intl classes.

     if (!cx->runtime()->isSelfHostingGlobal(cx->global())) {

         if (!InitCollatorClass(cx, Intl, global))

             return nullptr;

         if (!InitNumberFormatClass(cx, Intl, global))

             return nullptr;

         if (!InitDateTimeFormatClass(cx, Intl, global))

             return nullptr;

     }

     global->setConstructor(JSProto_Intl, ObjectValue(*Intl));

     return Intl;

 }

 bool

 GlobalObject::initIntlObject(JSContext *cx, Handle<GlobalObject*> global)

 {

     RootedObject Intl(cx);

     Intl = NewObjectWithGivenProto(cx, &IntlClass, global->getOrCreateObjectPrototype(cx),

                                    global, SingletonObject);

     if (!Intl)

         return false;

     global->setConstructor(JSProto_Intl, ObjectValue(*Intl));

     return true;

 }