mozjs_sys 0.67.1

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 * vim: set ts=8 sts=2 et sw=2 tw=80:
 * 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/. */

/* Intl.Collator implementation. */

#include "builtin/intl/Collator.h"

#include "mozilla/Assertions.h"

#include "jsapi.h"

#include "builtin/intl/CommonFunctions.h"
#include "builtin/intl/ICUStubs.h"
#include "builtin/intl/ScopedICUObject.h"
#include "builtin/intl/SharedIntlData.h"
#include "gc/FreeOp.h"
#include "js/CharacterEncoding.h"
#include "js/PropertySpec.h"
#include "js/StableStringChars.h"
#include "js/TypeDecls.h"
#include "vm/GlobalObject.h"
#include "vm/JSContext.h"
#include "vm/Runtime.h"
#include "vm/StringType.h"

#include "vm/JSObject-inl.h"

using namespace js;

using JS::AutoStableStringChars;

using js::intl::GetAvailableLocales;
using js::intl::IcuLocale;
using js::intl::ReportInternalError;
using js::intl::SharedIntlData;
using js::intl::StringsAreEqual;

const ClassOps CollatorObject::classOps_ = {nullptr, /* addProperty */
                                            nullptr, /* delProperty */
                                            nullptr, /* enumerate */
                                            nullptr, /* newEnumerate */
                                            nullptr, /* resolve */
                                            nullptr, /* mayResolve */
                                            CollatorObject::finalize};

const Class CollatorObject::class_ = {
    js_Object_str,
    JSCLASS_HAS_RESERVED_SLOTS(CollatorObject::SLOT_COUNT) |
        JSCLASS_FOREGROUND_FINALIZE,
    &CollatorObject::classOps_};

static bool collator_toSource(JSContext* cx, unsigned argc, Value* vp) {
  CallArgs args = CallArgsFromVp(argc, vp);
  args.rval().setString(cx->names().Collator);
  return true;
}

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),
    JS_FN(js_toSource_str, collator_toSource, 0, 0), JS_FS_END};

static const JSPropertySpec collator_properties[] = {
    JS_SELF_HOSTED_GET("compare", "Intl_Collator_compare_get", 0),
    JS_STRING_SYM_PS(toStringTag, "Object", JSPROP_READONLY), JS_PS_END};

/**
 * 10.1.2 Intl.Collator([ locales [, options]])
 *
 * ES2017 Intl draft rev 94045d234762ad107a3d09bb6f7381a65f1a2f9b
 */
static bool Collator(JSContext* cx, const CallArgs& args) {
  // Step 1 (Handled by OrdinaryCreateFromConstructor fallback code).

  // Steps 2-5 (Inlined 9.1.14, OrdinaryCreateFromConstructor).
  RootedObject proto(cx);
  if (!GetPrototypeFromBuiltinConstructor(cx, args, JSProto_Null, &proto)) {
    return false;
  }

  if (!proto) {
    proto = GlobalObject::getOrCreateCollatorPrototype(cx, cx->global());
    if (!proto) {
      return false;
    }
  }

  Rooted<CollatorObject*> collator(
      cx, NewObjectWithGivenProto<CollatorObject>(cx, proto));
  if (!collator) {
    return false;
  }

  collator->setReservedSlot(CollatorObject::INTERNALS_SLOT, NullValue());
  collator->setReservedSlot(CollatorObject::UCOLLATOR_SLOT,
                            PrivateValue(nullptr));

  HandleValue locales = args.get(0);
  HandleValue options = args.get(1);

  // Step 6.
  if (!intl::InitializeObject(cx, collator, cx->names().InitializeCollator,
                              locales, options)) {
    return false;
  }

  args.rval().setObject(*collator);
  return true;
}

static bool Collator(JSContext* cx, unsigned argc, Value* vp) {
  CallArgs args = CallArgsFromVp(argc, vp);
  return Collator(cx, args);
}

bool js::intl_Collator(JSContext* cx, unsigned argc, Value* vp) {
  CallArgs args = CallArgsFromVp(argc, vp);
  MOZ_ASSERT(args.length() == 2);
  MOZ_ASSERT(!args.isConstructing());

  return Collator(cx, args);
}

void js::CollatorObject::finalize(FreeOp* fop, JSObject* obj) {
  MOZ_ASSERT(fop->onMainThread());

  const Value& slot =
      obj->as<CollatorObject>().getReservedSlot(CollatorObject::UCOLLATOR_SLOT);
  if (UCollator* coll = static_cast<UCollator*>(slot.toPrivate())) {
    ucol_close(coll);
  }
}

JSObject* js::CreateCollatorPrototype(JSContext* cx, HandleObject Intl,
                                      Handle<GlobalObject*> global) {
  RootedFunction ctor(cx, GlobalObject::createConstructor(
                              cx, &Collator, cx->names().Collator, 0));
  if (!ctor) {
    return nullptr;
  }

  RootedObject proto(
      cx, GlobalObject::createBlankPrototype<PlainObject>(cx, global));
  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.5
  if (!JS_DefineFunctions(cx, proto, collator_methods)) {
    return nullptr;
  }

  // 10.3.2 and 10.3.3
  if (!JS_DefineProperties(cx, proto, collator_properties)) {
    return nullptr;
  }

  // 8.1
  RootedValue ctorValue(cx, ObjectValue(*ctor));
  if (!DefineDataProperty(cx, Intl, cx->names().Collator, ctorValue, 0)) {
    return nullptr;
  }

  return proto;
}

bool js::intl_Collator_availableLocales(JSContext* cx, unsigned argc,
                                        Value* vp) {
  CallArgs args = CallArgsFromVp(argc, vp);
  MOZ_ASSERT(args.length() == 0);

  RootedValue result(cx);
  if (!GetAvailableLocales(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);
  MOZ_ASSERT(args.length() == 1);
  MOZ_ASSERT(args[0].isString());

  UniqueChars locale = intl::EncodeLocale(cx, args[0].toString());
  if (!locale) {
    return false;
  }
  UErrorCode status = U_ZERO_ERROR;
  UEnumeration* values =
      ucol_getKeywordValuesForLocale("co", locale.get(), false, &status);
  if (U_FAILURE(status)) {
    ReportInternalError(cx);
    return false;
  }
  ScopedICUObject<UEnumeration, uenum_close> toClose(values);

  uint32_t count = uenum_count(values, &status);
  if (U_FAILURE(status)) {
    ReportInternalError(cx);
    return false;
  }

  RootedObject collations(cx, NewDenseEmptyArray(cx));
  if (!collations) {
    return false;
  }

  uint32_t index = 0;

  // The first element of the collations array must be |null| per
  // ES2017 Intl, 10.2.3 Internal Slots.
  if (!DefineDataElement(cx, collations, index++, NullHandleValue)) {
    return false;
  }

  RootedValue element(cx);
  for (uint32_t i = 0; i < count; i++) {
    const char* collation = uenum_next(values, nullptr, &status);
    if (U_FAILURE(status)) {
      ReportInternalError(cx);
      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 (StringsAreEqual(collation, "standard") ||
        StringsAreEqual(collation, "search")) {
      continue;
    }

    // ICU returns old-style keyword values; map them to BCP 47 equivalents.
    collation = uloc_toUnicodeLocaleType("co", collation);
    if (!collation) {
      ReportInternalError(cx);
      return false;
    }

    JSString* jscollation = NewStringCopyZ<CanGC>(cx, collation);
    if (!jscollation) {
      return false;
    }
    element = StringValue(jscollation);
    if (!DefineDataElement(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,
                               Handle<CollatorObject*> collator) {
  RootedValue value(cx);

  RootedObject internals(cx, intl::GetInternalsObject(cx, collator));
  if (!internals) {
    return nullptr;
  }

  if (!GetProperty(cx, internals, internals, cx->names().locale, &value)) {
    return nullptr;
  }
  UniqueChars locale = intl::EncodeLocale(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 (!GetProperty(cx, internals, internals, cx->names().usage, &value)) {
    return nullptr;
  }

  {
    JSLinearString* usage = value.toString()->ensureLinear(cx);
    if (!usage) {
      return nullptr;
    }
    if (StringEqualsAscii(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.get();
      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 = JS::UniqueChars(newLocale);
    } else {
      MOZ_ASSERT(StringEqualsAscii(usage, "sort"));
    }
  }

  // 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 (!GetProperty(cx, internals, internals, cx->names().sensitivity, &value)) {
    return nullptr;
  }

  {
    JSLinearString* sensitivity = value.toString()->ensureLinear(cx);
    if (!sensitivity) {
      return nullptr;
    }
    if (StringEqualsAscii(sensitivity, "base")) {
      uStrength = UCOL_PRIMARY;
    } else if (StringEqualsAscii(sensitivity, "accent")) {
      uStrength = UCOL_SECONDARY;
    } else if (StringEqualsAscii(sensitivity, "case")) {
      uStrength = UCOL_PRIMARY;
      uCaseLevel = UCOL_ON;
    } else {
      MOZ_ASSERT(StringEqualsAscii(sensitivity, "variant"));
      uStrength = UCOL_TERTIARY;
    }
  }

  if (!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 (!GetProperty(cx, internals, internals, cx->names().numeric, &value)) {
    return nullptr;
  }
  if (!value.isUndefined() && value.toBoolean()) {
    uNumeric = UCOL_ON;
  }

  if (!GetProperty(cx, internals, internals, cx->names().caseFirst, &value)) {
    return nullptr;
  }
  if (!value.isUndefined()) {
    JSLinearString* caseFirst = value.toString()->ensureLinear(cx);
    if (!caseFirst) {
      return nullptr;
    }
    if (StringEqualsAscii(caseFirst, "upper")) {
      uCaseFirst = UCOL_UPPER_FIRST;
    } else if (StringEqualsAscii(caseFirst, "lower")) {
      uCaseFirst = UCOL_LOWER_FIRST;
    } else {
      MOZ_ASSERT(StringEqualsAscii(caseFirst, "false"));
      uCaseFirst = UCOL_OFF;
    }
  }

  UErrorCode status = U_ZERO_ERROR;
  UCollator* coll = ucol_open(IcuLocale(locale.get()), &status);
  if (U_FAILURE(status)) {
    ReportInternalError(cx);
    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);
    ReportInternalError(cx);
    return nullptr;
  }

  return coll;
}

static bool intl_CompareStrings(JSContext* cx, UCollator* coll,
                                HandleString str1, HandleString str2,
                                MutableHandleValue result) {
  MOZ_ASSERT(str1);
  MOZ_ASSERT(str2);

  if (str1 == str2) {
    result.setInt32(0);
    return true;
  }

  AutoStableStringChars stableChars1(cx);
  if (!stableChars1.initTwoByte(cx, str1)) {
    return false;
  }

  AutoStableStringChars stableChars2(cx);
  if (!stableChars2.initTwoByte(cx, str2)) {
    return false;
  }

  mozilla::Range<const char16_t> chars1 = stableChars1.twoByteRange();
  mozilla::Range<const char16_t> chars2 = stableChars2.twoByteRange();

  UCollationResult uresult =
      ucol_strcoll(coll, chars1.begin().get(), chars1.length(),
                   chars2.begin().get(), chars2.length());
  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_CRASH("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);
  MOZ_ASSERT(args.length() == 3);
  MOZ_ASSERT(args[0].isObject());
  MOZ_ASSERT(args[1].isString());
  MOZ_ASSERT(args[2].isString());

  Rooted<CollatorObject*> collator(cx,
                                   &args[0].toObject().as<CollatorObject>());

  // Obtain a cached UCollator object.
  void* priv =
      collator->getReservedSlot(CollatorObject::UCOLLATOR_SLOT).toPrivate();
  UCollator* coll = static_cast<UCollator*>(priv);
  if (!coll) {
    coll = NewUCollator(cx, collator);
    if (!coll) {
      return false;
    }
    collator->setReservedSlot(CollatorObject::UCOLLATOR_SLOT,
                              PrivateValue(coll));
  }

  // Use the UCollator to actually compare the strings.
  RootedString str1(cx, args[1].toString());
  RootedString str2(cx, args[2].toString());
  return intl_CompareStrings(cx, coll, str1, str2, args.rval());
}

bool js::intl_isUpperCaseFirst(JSContext* cx, unsigned argc, Value* vp) {
  CallArgs args = CallArgsFromVp(argc, vp);
  MOZ_ASSERT(args.length() == 1);
  MOZ_ASSERT(args[0].isString());

  SharedIntlData& sharedIntlData = cx->runtime()->sharedIntlData.ref();

  RootedString locale(cx, args[0].toString());
  bool isUpperFirst;
  if (!sharedIntlData.isUpperCaseFirst(cx, locale, &isUpperFirst)) {
    return false;
  }

  args.rval().setBoolean(isUpperFirst);
  return true;
}