[ tor-browser ].git.dasho

FluentBundle.cpp (16646B)
      1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
      2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
      3 /* This Source Code Form is subject to the terms of the Mozilla Public
      4 * License, v. 2.0. If a copy of the MPL was not distributed with this
      5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      6 
      7 #include "FluentBundle.h"
      8 #include "nsContentUtils.h"
      9 #include "mozilla/dom/ToJSValue.h"
     10 #include "mozilla/dom/UnionTypes.h"
     11 #include "mozilla/intl/NumberFormat.h"
     12 #include "mozilla/intl/DateTimeFormat.h"
     13 #include "mozilla/intl/DateTimePatternGenerator.h"
     14 #include "nsIInputStream.h"
     15 #include "nsStringFwd.h"
     16 #include "nsTArray.h"
     17 #include "js/PropertyAndElement.h"  // JS_DefineElement
     18 
     19 using namespace mozilla::dom;
     20 
     21 namespace mozilla {
     22 namespace intl {
     23 
     24 class SizeableUTF8Buffer {
     25 public:
     26  using CharType = char;
     27 
     28  bool reserve(size_t size) {
     29    mBuffer.reset(reinterpret_cast<CharType*>(malloc(size)));
     30    mCapacity = size;
     31    return true;
     32  }
     33 
     34  CharType* data() { return mBuffer.get(); }
     35 
     36  size_t capacity() const { return mCapacity; }
     37 
     38  void written(size_t amount) { mWritten = amount; }
     39 
     40  size_t mWritten = 0;
     41  size_t mCapacity = 0;
     42 
     43  struct FreePolicy {
     44    void operator()(const void* ptr) { free(const_cast<void*>(ptr)); }
     45  };
     46 
     47  UniquePtr<CharType[], FreePolicy> mBuffer;
     48 };
     49 
     50 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(FluentPattern, mParent)
     51 
     52 FluentPattern::FluentPattern(nsISupports* aParent, const nsACString& aId)
     53    : mId(aId), mParent(aParent) {
     54  MOZ_COUNT_CTOR(FluentPattern);
     55 }
     56 FluentPattern::FluentPattern(nsISupports* aParent, const nsACString& aId,
     57                             const nsACString& aAttrName)
     58    : mId(aId), mAttrName(aAttrName), mParent(aParent) {
     59  MOZ_COUNT_CTOR(FluentPattern);
     60 }
     61 
     62 JSObject* FluentPattern::WrapObject(JSContext* aCx,
     63                                    JS::Handle<JSObject*> aGivenProto) {
     64  return FluentPattern_Binding::Wrap(aCx, this, aGivenProto);
     65 }
     66 
     67 FluentPattern::~FluentPattern() { MOZ_COUNT_DTOR(FluentPattern); };
     68 
     69 /* FluentBundle */
     70 
     71 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(FluentBundle, mParent)
     72 
     73 FluentBundle::FluentBundle(nsISupports* aParent,
     74                           UniquePtr<ffi::FluentBundleRc> aRaw)
     75    : mParent(aParent), mRaw(std::move(aRaw)) {
     76  MOZ_COUNT_CTOR(FluentBundle);
     77 }
     78 
     79 already_AddRefed<FluentBundle> FluentBundle::Constructor(
     80    const dom::GlobalObject& aGlobal,
     81    const UTF8StringOrUTF8StringSequence& aLocales,
     82    const dom::FluentBundleOptions& aOptions, ErrorResult& aRv) {
     83  nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports());
     84  if (!global) {
     85    aRv.Throw(NS_ERROR_FAILURE);
     86    return nullptr;
     87  }
     88 
     89  bool useIsolating = aOptions.mUseIsolating;
     90 
     91  nsAutoCString pseudoStrategy;
     92  if (aOptions.mPseudoStrategy.WasPassed()) {
     93    pseudoStrategy = aOptions.mPseudoStrategy.Value();
     94  }
     95 
     96  UniquePtr<ffi::FluentBundleRc> raw;
     97 
     98  if (aLocales.IsUTF8String()) {
     99    const nsACString& locale = aLocales.GetAsUTF8String();
    100    raw.reset(
    101        ffi::fluent_bundle_new_single(&locale, useIsolating, &pseudoStrategy));
    102  } else {
    103    const auto& locales = aLocales.GetAsUTF8StringSequence();
    104    raw.reset(ffi::fluent_bundle_new(locales.Elements(), locales.Length(),
    105                                     useIsolating, &pseudoStrategy));
    106  }
    107 
    108  if (!raw) {
    109    aRv.ThrowInvalidStateError(
    110        "Failed to create the FluentBundle. Check the "
    111        "locales and pseudo strategy arguments.");
    112    return nullptr;
    113  }
    114 
    115  return do_AddRef(new FluentBundle(global, std::move(raw)));
    116 }
    117 
    118 JSObject* FluentBundle::WrapObject(JSContext* aCx,
    119                                   JS::Handle<JSObject*> aGivenProto) {
    120  return FluentBundle_Binding::Wrap(aCx, this, aGivenProto);
    121 }
    122 
    123 FluentBundle::~FluentBundle() { MOZ_COUNT_DTOR(FluentBundle); };
    124 
    125 void FluentBundle::GetLocales(nsTArray<nsCString>& aLocales) {
    126  fluent_bundle_get_locales(mRaw.get(), &aLocales);
    127 }
    128 
    129 void FluentBundle::AddResource(
    130    FluentResource& aResource,
    131    const dom::FluentBundleAddResourceOptions& aOptions) {
    132  bool allowOverrides = aOptions.mAllowOverrides;
    133  nsTArray<nsCString> errors;
    134 
    135  fluent_bundle_add_resource(mRaw.get(), aResource.Raw(), allowOverrides,
    136                             &errors);
    137 
    138  for (auto& err : errors) {
    139    nsContentUtils::LogSimpleConsoleError(NS_ConvertUTF8toUTF16(err), "L10n"_ns,
    140                                          false, true,
    141                                          nsIScriptError::warningFlag);
    142  }
    143 }
    144 
    145 bool FluentBundle::HasMessage(const nsACString& aId) {
    146  return fluent_bundle_has_message(mRaw.get(), &aId);
    147 }
    148 
    149 void FluentBundle::GetMessage(const nsACString& aId,
    150                              Nullable<FluentMessage>& aRetVal) {
    151  bool hasValue = false;
    152  nsTArray<nsCString> attributes;
    153  bool exists =
    154      fluent_bundle_get_message(mRaw.get(), &aId, &hasValue, &attributes);
    155  if (exists) {
    156    FluentMessage& msg = aRetVal.SetValue();
    157    if (hasValue) {
    158      msg.mValue = new FluentPattern(mParent, aId);
    159    }
    160    for (auto& name : attributes) {
    161      auto newEntry = msg.mAttributes.Entries().AppendElement(fallible);
    162      newEntry->mKey = name;
    163      newEntry->mValue = new FluentPattern(mParent, aId, name);
    164    }
    165  }
    166 }
    167 
    168 bool extendJSArrayWithErrors(JSContext* aCx, JS::Handle<JSObject*> aErrors,
    169                             nsTArray<nsCString>& aInput) {
    170  uint32_t length;
    171  if (NS_WARN_IF(!JS::GetArrayLength(aCx, aErrors, &length))) {
    172    return false;
    173  }
    174 
    175  for (auto& err : aInput) {
    176    JS::Rooted<JS::Value> jsval(aCx);
    177    if (!ToJSValue(aCx, NS_ConvertUTF8toUTF16(err), &jsval)) {
    178      return false;
    179    }
    180    if (!JS_DefineElement(aCx, aErrors, length++, jsval, JSPROP_ENUMERATE)) {
    181      return false;
    182    }
    183  }
    184  return true;
    185 }
    186 
    187 /* static */
    188 void FluentBundle::ConvertArgs(const L10nArgs& aArgs,
    189                               nsTArray<ffi::L10nArg>& aRetVal) {
    190  aRetVal.SetCapacity(aArgs.Entries().Length());
    191  for (const auto& entry : aArgs.Entries()) {
    192    if (!entry.mValue.IsNull()) {
    193      const auto& value = entry.mValue.Value();
    194 
    195      if (value.IsUTF8String()) {
    196        aRetVal.AppendElement(ffi::L10nArg{
    197            &entry.mKey,
    198            ffi::FluentArgument::String(&value.GetAsUTF8String())});
    199      } else {
    200        aRetVal.AppendElement(ffi::L10nArg{
    201            &entry.mKey, ffi::FluentArgument::Double_(value.GetAsDouble())});
    202      }
    203    }
    204  }
    205 }
    206 
    207 void FluentBundle::FormatPattern(JSContext* aCx, const FluentPattern& aPattern,
    208                                 const Nullable<L10nArgs>& aArgs,
    209                                 const Optional<JS::Handle<JSObject*>>& aErrors,
    210                                 nsACString& aRetVal, ErrorResult& aRv) {
    211  nsTArray<ffi::L10nArg> l10nArgs;
    212 
    213  if (!aArgs.IsNull()) {
    214    const L10nArgs& args = aArgs.Value();
    215    ConvertArgs(args, l10nArgs);
    216  }
    217 
    218  nsTArray<nsCString> errors;
    219  bool succeeded = fluent_bundle_format_pattern(mRaw.get(), &aPattern.mId,
    220                                                &aPattern.mAttrName, &l10nArgs,
    221                                                &aRetVal, &errors);
    222 
    223  if (!succeeded) {
    224    return aRv.ThrowInvalidStateError(
    225        "Failed to format the FluentPattern. Likely the "
    226        "pattern could not be retrieved from the bundle.");
    227  }
    228 
    229  if (aErrors.WasPassed()) {
    230    if (!extendJSArrayWithErrors(aCx, aErrors.Value(), errors)) {
    231      aRv.ThrowUnknownError("Failed to add errors to an error array.");
    232    }
    233  }
    234 }
    235 
    236 // FFI
    237 
    238 extern "C" {
    239 ffi::RawNumberFormatter* FluentBuiltInNumberFormatterCreate(
    240    const nsCString* aLocale, const ffi::FluentNumberOptionsRaw* aOptions) {
    241  NumberFormatOptions options;
    242  switch (aOptions->style) {
    243    case ffi::FluentNumberStyleRaw::Decimal:
    244      break;
    245    case ffi::FluentNumberStyleRaw::Currency: {
    246      std::string currency = aOptions->currency.get();
    247      switch (aOptions->currency_display) {
    248        case ffi::FluentNumberCurrencyDisplayStyleRaw::Symbol:
    249          options.mCurrency = Some(std::make_pair(
    250              currency, NumberFormatOptions::CurrencyDisplay::Symbol));
    251          break;
    252        case ffi::FluentNumberCurrencyDisplayStyleRaw::Code:
    253          options.mCurrency = Some(std::make_pair(
    254              currency, NumberFormatOptions::CurrencyDisplay::Code));
    255          break;
    256        case ffi::FluentNumberCurrencyDisplayStyleRaw::Name:
    257          options.mCurrency = Some(std::make_pair(
    258              currency, NumberFormatOptions::CurrencyDisplay::Name));
    259          break;
    260        default:
    261          MOZ_ASSERT_UNREACHABLE();
    262          break;
    263      }
    264    } break;
    265    case ffi::FluentNumberStyleRaw::Percent:
    266      options.mPercent = true;
    267      break;
    268    default:
    269      MOZ_ASSERT_UNREACHABLE();
    270      break;
    271  }
    272 
    273  options.mGrouping = aOptions->use_grouping
    274                          ? NumberFormatOptions::Grouping::Auto
    275                          : NumberFormatOptions::Grouping::Never;
    276  options.mMinIntegerDigits = Some(aOptions->minimum_integer_digits);
    277 
    278  if (aOptions->minimum_significant_digits >= 0 ||
    279      aOptions->maximum_significant_digits >= 0) {
    280    options.mSignificantDigits =
    281        Some(std::make_pair(aOptions->minimum_significant_digits,
    282                            aOptions->maximum_significant_digits));
    283  } else {
    284    options.mFractionDigits = Some(std::make_pair(
    285        aOptions->minimum_fraction_digits, aOptions->maximum_fraction_digits));
    286  }
    287 
    288  Result<UniquePtr<NumberFormat>, ICUError> result =
    289      NumberFormat::TryCreate(aLocale->get(), options);
    290 
    291  MOZ_ASSERT(result.isOk());
    292 
    293  if (result.isOk()) {
    294    return reinterpret_cast<ffi::RawNumberFormatter*>(
    295        result.unwrap().release());
    296  }
    297 
    298  return nullptr;
    299 }
    300 
    301 uint8_t* FluentBuiltInNumberFormatterFormat(
    302    const ffi::RawNumberFormatter* aFormatter, double input, size_t* aOutCount,
    303    size_t* aOutCapacity) {
    304  const NumberFormat* nf = reinterpret_cast<const NumberFormat*>(aFormatter);
    305 
    306  SizeableUTF8Buffer buffer;
    307  if (nf->format(input, buffer).isOk()) {
    308    *aOutCount = buffer.mWritten;
    309    *aOutCapacity = buffer.mCapacity;
    310    return reinterpret_cast<uint8_t*>(buffer.mBuffer.release());
    311  }
    312 
    313  return nullptr;
    314 }
    315 
    316 void FluentBuiltInNumberFormatterDestroy(ffi::RawNumberFormatter* aFormatter) {
    317  delete reinterpret_cast<NumberFormat*>(aFormatter);
    318 }
    319 
    320 /* DateTime */
    321 
    322 static Maybe<DateTimeFormat::Style> GetStyle(ffi::FluentDateTimeStyle aStyle) {
    323  switch (aStyle) {
    324    case ffi::FluentDateTimeStyle::Full:
    325      return Some(DateTimeFormat::Style::Full);
    326    case ffi::FluentDateTimeStyle::Long:
    327      return Some(DateTimeFormat::Style::Long);
    328    case ffi::FluentDateTimeStyle::Medium:
    329      return Some(DateTimeFormat::Style::Medium);
    330    case ffi::FluentDateTimeStyle::Short:
    331      return Some(DateTimeFormat::Style::Short);
    332    case ffi::FluentDateTimeStyle::None:
    333      return Nothing();
    334  }
    335  MOZ_ASSERT_UNREACHABLE();
    336  return Nothing();
    337 }
    338 
    339 static Maybe<DateTimeFormat::Text> GetText(
    340    ffi::FluentDateTimeTextComponent aText) {
    341  switch (aText) {
    342    case ffi::FluentDateTimeTextComponent::Long:
    343      return Some(DateTimeFormat::Text::Long);
    344    case ffi::FluentDateTimeTextComponent::Short:
    345      return Some(DateTimeFormat::Text::Short);
    346    case ffi::FluentDateTimeTextComponent::Narrow:
    347      return Some(DateTimeFormat::Text::Narrow);
    348    case ffi::FluentDateTimeTextComponent::None:
    349      return Nothing();
    350  }
    351  MOZ_ASSERT_UNREACHABLE();
    352  return Nothing();
    353 }
    354 
    355 static Maybe<DateTimeFormat::Month> GetMonth(
    356    ffi::FluentDateTimeMonthComponent aMonth) {
    357  switch (aMonth) {
    358    case ffi::FluentDateTimeMonthComponent::Numeric:
    359      return Some(DateTimeFormat::Month::Numeric);
    360    case ffi::FluentDateTimeMonthComponent::TwoDigit:
    361      return Some(DateTimeFormat::Month::TwoDigit);
    362    case ffi::FluentDateTimeMonthComponent::Long:
    363      return Some(DateTimeFormat::Month::Long);
    364    case ffi::FluentDateTimeMonthComponent::Short:
    365      return Some(DateTimeFormat::Month::Short);
    366    case ffi::FluentDateTimeMonthComponent::Narrow:
    367      return Some(DateTimeFormat::Month::Narrow);
    368    case ffi::FluentDateTimeMonthComponent::None:
    369      return Nothing();
    370  }
    371  MOZ_ASSERT_UNREACHABLE();
    372  return Nothing();
    373 }
    374 
    375 static Maybe<DateTimeFormat::Numeric> GetNumeric(
    376    ffi::FluentDateTimeNumericComponent aNumeric) {
    377  switch (aNumeric) {
    378    case ffi::FluentDateTimeNumericComponent::Numeric:
    379      return Some(DateTimeFormat::Numeric::Numeric);
    380    case ffi::FluentDateTimeNumericComponent::TwoDigit:
    381      return Some(DateTimeFormat::Numeric::TwoDigit);
    382    case ffi::FluentDateTimeNumericComponent::None:
    383      return Nothing();
    384  }
    385  MOZ_ASSERT_UNREACHABLE();
    386  return Nothing();
    387 }
    388 
    389 static Maybe<DateTimeFormat::TimeZoneName> GetTimeZoneName(
    390    ffi::FluentDateTimeTimeZoneNameComponent aTimeZoneName) {
    391  switch (aTimeZoneName) {
    392    case ffi::FluentDateTimeTimeZoneNameComponent::Long:
    393      return Some(DateTimeFormat::TimeZoneName::Long);
    394    case ffi::FluentDateTimeTimeZoneNameComponent::Short:
    395      return Some(DateTimeFormat::TimeZoneName::Short);
    396    case ffi::FluentDateTimeTimeZoneNameComponent::None:
    397      return Nothing();
    398  }
    399  MOZ_ASSERT_UNREACHABLE();
    400  return Nothing();
    401 }
    402 
    403 static Maybe<DateTimeFormat::HourCycle> GetHourCycle(
    404    ffi::FluentDateTimeHourCycle aHourCycle) {
    405  switch (aHourCycle) {
    406    case ffi::FluentDateTimeHourCycle::H24:
    407      return Some(DateTimeFormat::HourCycle::H24);
    408    case ffi::FluentDateTimeHourCycle::H23:
    409      return Some(DateTimeFormat::HourCycle::H23);
    410    case ffi::FluentDateTimeHourCycle::H12:
    411      return Some(DateTimeFormat::HourCycle::H12);
    412    case ffi::FluentDateTimeHourCycle::H11:
    413      return Some(DateTimeFormat::HourCycle::H11);
    414    case ffi::FluentDateTimeHourCycle::None:
    415      return Nothing();
    416  }
    417  MOZ_ASSERT_UNREACHABLE();
    418  return Nothing();
    419 }
    420 
    421 static Maybe<DateTimeFormat::ComponentsBag> GetComponentsBag(
    422    ffi::FluentDateTimeOptions aOptions) {
    423  if (GetStyle(aOptions.date_style) || GetStyle(aOptions.time_style)) {
    424    return Nothing();
    425  }
    426 
    427  DateTimeFormat::ComponentsBag components;
    428  components.era = GetText(aOptions.era);
    429  components.year = GetNumeric(aOptions.year);
    430  components.month = GetMonth(aOptions.month);
    431  components.day = GetNumeric(aOptions.day);
    432  components.weekday = GetText(aOptions.weekday);
    433  components.hour = GetNumeric(aOptions.hour);
    434  components.minute = GetNumeric(aOptions.minute);
    435  components.second = GetNumeric(aOptions.second);
    436  components.timeZoneName = GetTimeZoneName(aOptions.time_zone_name);
    437  components.hourCycle = GetHourCycle(aOptions.hour_cycle);
    438 
    439  if (!components.era && !components.year && !components.month &&
    440      !components.day && !components.weekday && !components.hour &&
    441      !components.minute && !components.second && !components.timeZoneName) {
    442    return Nothing();
    443  }
    444 
    445  return Some(components);
    446 }
    447 
    448 ffi::RawDateTimeFormatter* FluentBuiltInDateTimeFormatterCreate(
    449    const nsCString* aLocale, ffi::FluentDateTimeOptions aOptions) {
    450  auto genResult = DateTimePatternGenerator::TryCreate(aLocale->get());
    451  if (genResult.isErr()) {
    452    MOZ_ASSERT_UNREACHABLE("There was an error in DateTimeFormat");
    453    return nullptr;
    454  }
    455  UniquePtr<DateTimePatternGenerator> dateTimePatternGenerator =
    456      genResult.unwrap();
    457 
    458  if (auto components = GetComponentsBag(aOptions)) {
    459    auto result = DateTimeFormat::TryCreateFromComponents(
    460        Span(*aLocale), *components, dateTimePatternGenerator.get());
    461    if (result.isErr()) {
    462      MOZ_ASSERT_UNREACHABLE("There was an error in DateTimeFormat");
    463      return nullptr;
    464    }
    465 
    466    return reinterpret_cast<ffi::RawDateTimeFormatter*>(
    467        result.unwrap().release());
    468  }
    469 
    470  DateTimeFormat::StyleBag style;
    471  style.date = GetStyle(aOptions.date_style);
    472  style.time = GetStyle(aOptions.time_style);
    473 
    474  auto result = DateTimeFormat::TryCreateFromStyle(
    475      Span(*aLocale), style, dateTimePatternGenerator.get());
    476 
    477  if (result.isErr()) {
    478    MOZ_ASSERT_UNREACHABLE("There was an error in DateTimeFormat");
    479    return nullptr;
    480  }
    481 
    482  return reinterpret_cast<ffi::RawDateTimeFormatter*>(
    483      result.unwrap().release());
    484 }
    485 
    486 uint8_t* FluentBuiltInDateTimeFormatterFormat(
    487    const ffi::RawDateTimeFormatter* aFormatter, double aUnixEpoch,
    488    uint32_t* aOutCount) {
    489  const auto* dtFormat = reinterpret_cast<const DateTimeFormat*>(aFormatter);
    490 
    491  SizeableUTF8Buffer buffer;
    492  dtFormat->TryFormat(aUnixEpoch, buffer).unwrap();
    493 
    494  *aOutCount = buffer.mWritten;
    495 
    496  return reinterpret_cast<uint8_t*>(buffer.mBuffer.release());
    497 }
    498 
    499 void FluentBuiltInDateTimeFormatterDestroy(
    500    ffi::RawDateTimeFormatter* aFormatter) {
    501  delete reinterpret_cast<const DateTimeFormat*>(aFormatter);
    502 }
    503 }
    504 
    505 }  // namespace intl
    506 }  // namespace mozilla
	tor-browser The Tor Browser
	git clone https://git.dasho.dev/tor-browser.git
	Log \| Files \| Refs \| README \| LICENSE