corysanin/tubestation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bug 1960024: Remove checks for JS_HAS_INTL_API and MOZ_ICU4X. r=platform-i18n-reviewers,nordzilla

Browse Source 
`JS_HAS_INTL_API` and `MOZ_ICU4X` are always set unless building js-standalone
packages. And because "intl/lwbrk" isn't used for js-standalone packages, both
options (`JS_HAS_INTL_API` and `MOZ_ICU4X`) are guaranteed to be defined.

Differential Revision: https://phabricator.services.mozilla.com/D245272
This commit is contained in:
André Bargull
2025-04-14 07:28:46 +00:00
parent 403888012a
commit f717d8d9cc
5 changed files with 37 additions and 101 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
intl/lwbrk/LineBreaker.cpp
View File

@@ -5,28 +5,25 @@
#include "mozilla/intl/LineBreaker.h" #include "mozilla/intl/LineBreaker.h"
#include "ICU4XDataProvider.h"
#include "ICU4XLineBreakIteratorLatin1.hpp"
#include "ICU4XLineBreakIteratorUtf16.hpp"
#include "ICU4XLineSegmenter.h"
#include "jisx4051class.h" #include "jisx4051class.h"
#include "LineBreakCache.h" #include "LineBreakCache.h"
#include "nsComplexBreaker.h" #include "nsComplexBreaker.h"
#include "nsTArray.h" #include "nsTArray.h"
#include "nsUnicodeProperties.h" #include "nsUnicodeProperties.h"
#include "nsThreadUtils.h"
#include "mozilla/ArrayUtils.h" #include "mozilla/ArrayUtils.h"
#include "mozilla/CheckedInt.h"
#include "mozilla/ClearOnShutdown.h"
#include "mozilla/intl/ICU4XGeckoDataProvider.h"
#include "mozilla/intl/Segmenter.h" #include "mozilla/intl/Segmenter.h"
#include "mozilla/intl/UnicodeProperties.h" #include "mozilla/intl/UnicodeProperties.h"
#include "mozilla/StaticPrefs_intl.h"
#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API) #include <mutex>
# include "ICU4XDataProvider.h"
# include "ICU4XLineBreakIteratorLatin1.hpp"
# include "ICU4XLineBreakIteratorUtf16.hpp"
# include "ICU4XLineSegmenter.h"
# include "mozilla/CheckedInt.h"
# include "mozilla/ClearOnShutdown.h"
# include "mozilla/intl/ICU4XGeckoDataProvider.h"
# include "mozilla/StaticPrefs_intl.h"
# include "nsThreadUtils.h"
# include <mutex>
#endif
using namespace mozilla; using namespace mozilla;
using namespace mozilla::intl; using namespace mozilla::intl;
@@ -1000,7 +997,6 @@ static bool SuppressBreakForKeepAll(uint32_t aPrev, uint32_t aCh) {
affectedByKeepAll(GetLineBreakClass(aCh)); affectedByKeepAll(GetLineBreakClass(aCh));
} }
#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
static capi::ICU4XLineBreakStrictness ConvertLineBreakRuleToICU4X( static capi::ICU4XLineBreakStrictness ConvertLineBreakRuleToICU4X(
LineBreakRule aLevel) { LineBreakRule aLevel) {
switch (aLevel) { switch (aLevel) {
@@ -1094,12 +1090,10 @@ static capi::ICU4XLineSegmenter* GetLineSegmenter(bool aUseDefault,
MOZ_ASSERT(result.is_ok); MOZ_ASSERT(result.is_ok);
return result.ok; return result.ok;
} }
#endif
void LineBreaker::ComputeBreakPositions( void LineBreaker::ComputeBreakPositions(
const char16_t* aChars, uint32_t aLength, WordBreakRule aWordBreak, const char16_t* aChars, uint32_t aLength, WordBreakRule aWordBreak,
LineBreakRule aLevel, bool aIsChineseOrJapanese, uint8_t* aBreakBefore) { LineBreakRule aLevel, bool aIsChineseOrJapanese, uint8_t* aBreakBefore) {
#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
if (StaticPrefs::intl_icu4x_segmenter_enabled()) { if (StaticPrefs::intl_icu4x_segmenter_enabled()) {
if (aLength == 1) { if (aLength == 1) {
// Although UAX#14 LB2 rule requires never breaking at the start of text // Although UAX#14 LB2 rule requires never breaking at the start of text
@@ -1178,7 +1172,6 @@ void LineBreaker::ComputeBreakPositions(
return; return;
} }
#endif
uint32_t cur; uint32_t cur;
int8_t lastClass = CLASS_NONE; int8_t lastClass = CLASS_NONE;
@@ -1309,7 +1302,6 @@ void LineBreaker::ComputeBreakPositions(const uint8_t* aChars, uint32_t aLength,
LineBreakRule aLevel, LineBreakRule aLevel,
bool aIsChineseOrJapanese, bool aIsChineseOrJapanese,
uint8_t* aBreakBefore) { uint8_t* aBreakBefore) {
#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
if (StaticPrefs::intl_icu4x_segmenter_enabled()) { if (StaticPrefs::intl_icu4x_segmenter_enabled()) {
if (aLength == 1) { if (aLength == 1) {
// Although UAX#14 LB2 rule requires never breaking at the start of text // Although UAX#14 LB2 rule requires never breaking at the start of text
@@ -1348,7 +1340,6 @@ void LineBreaker::ComputeBreakPositions(const uint8_t* aChars, uint32_t aLength,
} }
return; return;
} }
#endif
uint32_t cur; uint32_t cur;
int8_t lastClass = CLASS_NONE; int8_t lastClass = CLASS_NONE;

59
intl/lwbrk/Segmenter.cpp
View File

@@ -8,25 +8,22 @@
#include "mozilla/intl/Segmenter.h" #include "mozilla/intl/Segmenter.h"
#include "ICU4XDataProvider.h"
#include "ICU4XGraphemeClusterSegmenter.h"
#include "ICU4XLineSegmenter.h"
#include "ICU4XSentenceSegmenter.h"
#include "ICU4XWordSegmenter.h"
#include "mozilla/ClearOnShutdown.h"
#include "mozilla/intl/ICU4XGeckoDataProvider.h"
#include "mozilla/intl/LineBreaker.h" #include "mozilla/intl/LineBreaker.h"
#include "mozilla/intl/WordBreaker.h" #include "mozilla/intl/WordBreaker.h"
#include "mozilla/intl/UnicodeProperties.h" #include "mozilla/intl/UnicodeProperties.h"
#include "mozilla/StaticPrefs_intl.h" #include "mozilla/StaticPrefs_intl.h"
#include "nsUnicodeProperties.h" #include "nsUnicodeProperties.h"
#include "nsCharTraits.h" #include "nsCharTraits.h"
#include "nsThreadUtils.h"
#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API) #include <mutex>
# include "ICU4XDataProvider.h"
# include "ICU4XGraphemeClusterSegmenter.h"
# include "ICU4XLineSegmenter.h"
# include "ICU4XSentenceSegmenter.h"
# include "ICU4XWordSegmenter.h"
# include "mozilla/ClearOnShutdown.h"
# include "mozilla/intl/ICU4XGeckoDataProvider.h"
# include "nsThreadUtils.h"
# include <mutex>
#endif
using namespace mozilla::unicode; using namespace mozilla::unicode;
@@ -45,7 +42,6 @@ Maybe<uint32_t> SegmentIteratorUtf16::Seek(uint32_t aPos) {
LineBreakIteratorUtf16::LineBreakIteratorUtf16(Span<const char16_t> aText, LineBreakIteratorUtf16::LineBreakIteratorUtf16(Span<const char16_t> aText,
const LineBreakOptions& aOptions) const LineBreakOptions& aOptions)
: SegmentIteratorUtf16(aText), mOptions(aOptions) { : SegmentIteratorUtf16(aText), mOptions(aOptions) {
#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
if (!StaticPrefs::intl_icu4x_segmenter_enabled()) { if (!StaticPrefs::intl_icu4x_segmenter_enabled()) {
return; return;
} }
@@ -55,22 +51,18 @@ LineBreakIteratorUtf16::LineBreakIteratorUtf16(Span<const char16_t> aText,
mSegmenter = result.ok; mSegmenter = result.ok;
mIterator = capi::ICU4XLineSegmenter_segment_utf16( mIterator = capi::ICU4XLineSegmenter_segment_utf16(
mSegmenter, mText.Elements(), mText.Length()); mSegmenter, mText.Elements(), mText.Length());
#endif
} }
LineBreakIteratorUtf16::~LineBreakIteratorUtf16() { LineBreakIteratorUtf16::~LineBreakIteratorUtf16() {
#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
if (mIterator) { if (mIterator) {
capi::ICU4XLineBreakIteratorUtf16_destroy(mIterator); capi::ICU4XLineBreakIteratorUtf16_destroy(mIterator);
} }
if (mSegmenter) { if (mSegmenter) {
capi::ICU4XLineSegmenter_destroy(mSegmenter); capi::ICU4XLineSegmenter_destroy(mSegmenter);
} }
#endif
} }
Maybe<uint32_t> LineBreakIteratorUtf16::Next() { Maybe<uint32_t> LineBreakIteratorUtf16::Next() {
#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
if (mIterator) { if (mIterator) {
const int32_t nextPos = capi::ICU4XLineBreakIteratorUtf16_next(mIterator); const int32_t nextPos = capi::ICU4XLineBreakIteratorUtf16_next(mIterator);
if (nextPos < 0) { if (nextPos < 0) {
@@ -82,7 +74,6 @@ Maybe<uint32_t> LineBreakIteratorUtf16::Next() {
mPos = nextPos; mPos = nextPos;
return Some(mPos); return Some(mPos);
} }
#endif
const int32_t nextPos = const int32_t nextPos =
LineBreaker::Next(mText.Elements(), mText.Length(), mPos); LineBreaker::Next(mText.Elements(), mText.Length(), mPos);
if (nextPos == NS_LINEBREAKER_NEED_MORE_TEXT) { if (nextPos == NS_LINEBREAKER_NEED_MORE_TEXT) {
@@ -93,7 +84,6 @@ Maybe<uint32_t> LineBreakIteratorUtf16::Next() {
} }
Maybe<uint32_t> LineBreakIteratorUtf16::Seek(uint32_t aPos) { Maybe<uint32_t> LineBreakIteratorUtf16::Seek(uint32_t aPos) {
#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
if (mIterator) { if (mIterator) {
if (mPos >= aPos) { if (mPos >= aPos) {
return Next(); return Next();
@@ -113,13 +103,11 @@ Maybe<uint32_t> LineBreakIteratorUtf16::Seek(uint32_t aPos) {
return Next(); return Next();
} }
#endif
return SegmentIteratorUtf16::Seek(aPos); return SegmentIteratorUtf16::Seek(aPos);
} }
WordBreakIteratorUtf16::WordBreakIteratorUtf16(Span<const char16_t> aText) WordBreakIteratorUtf16::WordBreakIteratorUtf16(Span<const char16_t> aText)
: SegmentIteratorUtf16(aText) { : SegmentIteratorUtf16(aText) {
#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
if (!StaticPrefs::intl_icu4x_segmenter_enabled()) { if (!StaticPrefs::intl_icu4x_segmenter_enabled()) {
return; return;
} }
@@ -129,24 +117,20 @@ WordBreakIteratorUtf16::WordBreakIteratorUtf16(Span<const char16_t> aText)
mSegmenter = result.ok; mSegmenter = result.ok;
mIterator = capi::ICU4XWordSegmenter_segment_utf16( mIterator = capi::ICU4XWordSegmenter_segment_utf16(
mSegmenter, mText.Elements(), mText.Length()); mSegmenter, mText.Elements(), mText.Length());
#endif
} }
WordBreakIteratorUtf16::~WordBreakIteratorUtf16() { WordBreakIteratorUtf16::~WordBreakIteratorUtf16() {
#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
if (mIterator) { if (mIterator) {
capi::ICU4XWordBreakIteratorUtf16_destroy(mIterator); capi::ICU4XWordBreakIteratorUtf16_destroy(mIterator);
} }
if (mSegmenter) { if (mSegmenter) {
capi::ICU4XWordSegmenter_destroy(mSegmenter); capi::ICU4XWordSegmenter_destroy(mSegmenter);
} }
#endif
} }
void WordBreakIteratorUtf16::Reset(Span<const char16_t> aText) { void WordBreakIteratorUtf16::Reset(Span<const char16_t> aText) {
mPos = 0; mPos = 0;
mText = aText; mText = aText;
#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
if (mIterator) { if (mIterator) {
capi::ICU4XWordBreakIteratorUtf16_destroy(mIterator); capi::ICU4XWordBreakIteratorUtf16_destroy(mIterator);
mIterator = nullptr; mIterator = nullptr;
@@ -156,11 +140,9 @@ void WordBreakIteratorUtf16::Reset(Span<const char16_t> aText) {
} }
mIterator = capi::ICU4XWordSegmenter_segment_utf16( mIterator = capi::ICU4XWordSegmenter_segment_utf16(
mSegmenter, mText.Elements(), mText.Length()); mSegmenter, mText.Elements(), mText.Length());
#endif
} }
Maybe<uint32_t> WordBreakIteratorUtf16::Next() { Maybe<uint32_t> WordBreakIteratorUtf16::Next() {
#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
if (mIterator) { if (mIterator) {
const int32_t nextPos = capi::ICU4XWordBreakIteratorUtf16_next(mIterator); const int32_t nextPos = capi::ICU4XWordBreakIteratorUtf16_next(mIterator);
if (nextPos < 0) { if (nextPos < 0) {
@@ -172,7 +154,6 @@ Maybe<uint32_t> WordBreakIteratorUtf16::Next() {
mPos = nextPos; mPos = nextPos;
return Some(mPos); return Some(mPos);
} }
#endif
const int32_t nextPos = const int32_t nextPos =
WordBreaker::Next(mText.Elements(), mText.Length(), mPos); WordBreaker::Next(mText.Elements(), mText.Length(), mPos);
if (nextPos == NS_WORDBREAKER_NEED_MORE_TEXT) { if (nextPos == NS_WORDBREAKER_NEED_MORE_TEXT) {
@@ -183,7 +164,6 @@ Maybe<uint32_t> WordBreakIteratorUtf16::Next() {
} }
Maybe<uint32_t> WordBreakIteratorUtf16::Seek(uint32_t aPos) { Maybe<uint32_t> WordBreakIteratorUtf16::Seek(uint32_t aPos) {
#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
if (mIterator) { if (mIterator) {
if (mPos >= aPos) { if (mPos >= aPos) {
return Next(); return Next();
@@ -203,19 +183,15 @@ Maybe<uint32_t> WordBreakIteratorUtf16::Seek(uint32_t aPos) {
return Next(); return Next();
} }
#endif
return SegmentIteratorUtf16::Seek(aPos); return SegmentIteratorUtf16::Seek(aPos);
} }
#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
capi::ICU4XGraphemeClusterSegmenter* capi::ICU4XGraphemeClusterSegmenter*
GraphemeClusterBreakIteratorUtf16::sSegmenter = nullptr; GraphemeClusterBreakIteratorUtf16::sSegmenter = nullptr;
#endif
GraphemeClusterBreakIteratorUtf16::GraphemeClusterBreakIteratorUtf16( GraphemeClusterBreakIteratorUtf16::GraphemeClusterBreakIteratorUtf16(
Span<const char16_t> aText) Span<const char16_t> aText)
: SegmentIteratorUtf16(aText) { : SegmentIteratorUtf16(aText) {
#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
if (!StaticPrefs::intl_icu4x_segmenter_enabled()) { if (!StaticPrefs::intl_icu4x_segmenter_enabled()) {
return; return;
} }
@@ -239,15 +215,12 @@ GraphemeClusterBreakIteratorUtf16::GraphemeClusterBreakIteratorUtf16(
MOZ_RELEASE_ASSERT(sSegmenter); MOZ_RELEASE_ASSERT(sSegmenter);
mIterator = capi::ICU4XGraphemeClusterSegmenter_segment_utf16( mIterator = capi::ICU4XGraphemeClusterSegmenter_segment_utf16(
sSegmenter, mText.Elements(), mText.Length()); sSegmenter, mText.Elements(), mText.Length());
#endif
} }
GraphemeClusterBreakIteratorUtf16::~GraphemeClusterBreakIteratorUtf16() { GraphemeClusterBreakIteratorUtf16::~GraphemeClusterBreakIteratorUtf16() {
#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
if (mIterator) { if (mIterator) {
capi::ICU4XGraphemeClusterBreakIteratorUtf16_destroy(mIterator); capi::ICU4XGraphemeClusterBreakIteratorUtf16_destroy(mIterator);
} }
#endif
} }
enum HSType { enum HSType {
@@ -266,7 +239,6 @@ static HSType GetHangulSyllableType(uint32_t aCh) {
Maybe<uint32_t> GraphemeClusterBreakIteratorUtf16::Next() { Maybe<uint32_t> GraphemeClusterBreakIteratorUtf16::Next() {
const auto len = mText.Length(); const auto len = mText.Length();
#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
if (mIterator) { if (mIterator) {
const int32_t nextPos = const int32_t nextPos =
capi::ICU4XGraphemeClusterBreakIteratorUtf16_next(mIterator); capi::ICU4XGraphemeClusterBreakIteratorUtf16_next(mIterator);
@@ -279,7 +251,6 @@ Maybe<uint32_t> GraphemeClusterBreakIteratorUtf16::Next() {
mPos = nextPos; mPos = nextPos;
return Some(mPos); return Some(mPos);
} }
#endif
if (mPos >= len) { if (mPos >= len) {
// The iterator has already reached the end. // The iterator has already reached the end.
return Nothing(); return Nothing();
@@ -401,7 +372,6 @@ Maybe<uint32_t> GraphemeClusterBreakIteratorUtf16::Next() {
} }
Maybe<uint32_t> GraphemeClusterBreakIteratorUtf16::Seek(uint32_t aPos) { Maybe<uint32_t> GraphemeClusterBreakIteratorUtf16::Seek(uint32_t aPos) {
#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
if (mIterator) { if (mIterator) {
if (mPos >= aPos) { if (mPos >= aPos) {
return Next(); return Next();
@@ -422,7 +392,6 @@ Maybe<uint32_t> GraphemeClusterBreakIteratorUtf16::Seek(uint32_t aPos) {
return Next(); return Next();
} }
#endif
return SegmentIteratorUtf16::Seek(aPos); return SegmentIteratorUtf16::Seek(aPos);
} }
@@ -462,7 +431,6 @@ Maybe<uint32_t> GraphemeClusterBreakReverseIteratorUtf16::Seek(uint32_t aPos) {
return Next(); return Next();
} }
#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
SentenceBreakIteratorUtf16::SentenceBreakIteratorUtf16( SentenceBreakIteratorUtf16::SentenceBreakIteratorUtf16(
Span<const char16_t> aText) Span<const char16_t> aText)
: SegmentIteratorUtf16(aText) { : SegmentIteratorUtf16(aText) {
@@ -523,16 +491,9 @@ Maybe<uint32_t> SentenceBreakIteratorUtf16::Next() {
mPos = nextPos; mPos = nextPos;
return Some(mPos); return Some(mPos);
} }
#endif
Result<UniquePtr<Segmenter>, ICUError> Segmenter::TryCreate( Result<UniquePtr<Segmenter>, ICUError> Segmenter::TryCreate(
Span<const char> aLocale, const SegmenterOptions& aOptions) { Span<const char> aLocale, const SegmenterOptions& aOptions) {
#if !defined(MOZ_ICU4X) || !defined(JS_HAS_INTL_API)
if (aOptions.mGranularity == SegmenterGranularity::Sentence) {
// Grapheme and Sentence iterator are not yet implemented.
return Err(ICUError::InternalError);
}
#endif
return MakeUnique<Segmenter>(aLocale, aOptions); return MakeUnique<Segmenter>(aLocale, aOptions);
} }
@@ -542,11 +503,9 @@ UniquePtr<SegmentIteratorUtf16> Segmenter::Segment(
case SegmenterGranularity::Grapheme: case SegmenterGranularity::Grapheme:
return MakeUnique<GraphemeClusterBreakIteratorUtf16>(aText); return MakeUnique<GraphemeClusterBreakIteratorUtf16>(aText);
case SegmenterGranularity::Sentence: case SegmenterGranularity::Sentence:
#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
if (StaticPrefs::intl_icu4x_segmenter_enabled()) { if (StaticPrefs::intl_icu4x_segmenter_enabled()) {
return MakeUnique<SentenceBreakIteratorUtf16>(aText); return MakeUnique<SentenceBreakIteratorUtf16>(aText);
} }
#endif
MOZ_ASSERT_UNREACHABLE("Unimplemented yet!"); MOZ_ASSERT_UNREACHABLE("Unimplemented yet!");
return nullptr; return nullptr;
case SegmenterGranularity::Word: case SegmenterGranularity::Word:

10
intl/lwbrk/Segmenter.h
View File

@@ -15,7 +15,6 @@
#include "mozilla/Span.h" #include "mozilla/Span.h"
#include "mozilla/UniquePtr.h" #include "mozilla/UniquePtr.h"
#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
namespace capi { namespace capi {
struct ICU4XLineSegmenter; struct ICU4XLineSegmenter;
struct ICU4XLineBreakIteratorUtf16; struct ICU4XLineBreakIteratorUtf16;
@@ -26,7 +25,6 @@ struct ICU4XGraphemeClusterBreakIteratorUtf16;
struct ICU4XSentenceSegmenter; struct ICU4XSentenceSegmenter;
struct ICU4XSentenceBreakIteratorUtf16; struct ICU4XSentenceBreakIteratorUtf16;
} // namespace capi } // namespace capi
#endif
namespace mozilla::intl { namespace mozilla::intl {
@@ -125,10 +123,8 @@ class LineBreakIteratorUtf16 final : public SegmentIteratorUtf16 {
private: private:
LineBreakOptions mOptions; LineBreakOptions mOptions;
#ifdef MOZ_ICU4X
capi::ICU4XLineSegmenter* mSegmenter = nullptr; capi::ICU4XLineSegmenter* mSegmenter = nullptr;
capi::ICU4XLineBreakIteratorUtf16* mIterator = nullptr; capi::ICU4XLineBreakIteratorUtf16* mIterator = nullptr;
#endif
}; };
/** /**
@@ -143,11 +139,9 @@ class WordBreakIteratorUtf16 final : public SegmentIteratorUtf16 {
Maybe<uint32_t> Next() override; Maybe<uint32_t> Next() override;
Maybe<uint32_t> Seek(uint32_t aPos) override; Maybe<uint32_t> Seek(uint32_t aPos) override;
#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
private: private:
capi::ICU4XWordSegmenter* mSegmenter = nullptr; capi::ICU4XWordSegmenter* mSegmenter = nullptr;
capi::ICU4XWordBreakIteratorUtf16* mIterator = nullptr; capi::ICU4XWordBreakIteratorUtf16* mIterator = nullptr;
#endif
}; };
/** /**
@@ -161,11 +155,9 @@ class GraphemeClusterBreakIteratorUtf16 final : public SegmentIteratorUtf16 {
Maybe<uint32_t> Next() override; Maybe<uint32_t> Next() override;
Maybe<uint32_t> Seek(uint32_t aPos) override; Maybe<uint32_t> Seek(uint32_t aPos) override;
#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
private: private:
static capi::ICU4XGraphemeClusterSegmenter* sSegmenter; static capi::ICU4XGraphemeClusterSegmenter* sSegmenter;
capi::ICU4XGraphemeClusterBreakIteratorUtf16* mIterator = nullptr; capi::ICU4XGraphemeClusterBreakIteratorUtf16* mIterator = nullptr;
#endif
}; };
/** /**
@@ -183,7 +175,6 @@ class GraphemeClusterBreakReverseIteratorUtf16 final
Maybe<uint32_t> Seek(uint32_t aPos) override; Maybe<uint32_t> Seek(uint32_t aPos) override;
}; };
#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
/** /**
* Sentence break iterator for UTF-16 text. * Sentence break iterator for UTF-16 text.
*/ */
@@ -199,7 +190,6 @@ class SentenceBreakIteratorUtf16 final : public SegmentIteratorUtf16 {
capi::ICU4XSentenceSegmenter* mSegmenter = nullptr; capi::ICU4XSentenceSegmenter* mSegmenter = nullptr;
capi::ICU4XSentenceBreakIteratorUtf16* mIterator = nullptr; capi::ICU4XSentenceBreakIteratorUtf16* mIterator = nullptr;
}; };
#endif
/** /**
* This component is a Mozilla-focused API for working with segmenters in * This component is a Mozilla-focused API for working with segmenters in

22
intl/lwbrk/WordBreaker.cpp
View File

@@ -3,23 +3,21 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this * 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/. */ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "mozilla/CheckedInt.h"
#include "mozilla/intl/UnicodeProperties.h"
#include "mozilla/intl/WordBreaker.h" #include "mozilla/intl/WordBreaker.h"
#include "ICU4XDataProvider.h"
#include "ICU4XWordBreakIteratorUtf16.hpp"
#include "ICU4XWordSegmenter.hpp"
#include "mozilla/CheckedInt.h"
#include "mozilla/intl/ICU4XGeckoDataProvider.h"
#include "mozilla/intl/UnicodeProperties.h"
#include "mozilla/StaticPrefs_intl.h"
#include "mozilla/StaticPrefs_layout.h" #include "mozilla/StaticPrefs_layout.h"
#include "nsComplexBreaker.h" #include "nsComplexBreaker.h"
#include "nsTArray.h" #include "nsTArray.h"
#include "nsUnicharUtils.h"
#include "nsUnicodeProperties.h" #include "nsUnicodeProperties.h"
#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
# include "ICU4XDataProvider.h"
# include "ICU4XWordBreakIteratorUtf16.hpp"
# include "ICU4XWordSegmenter.hpp"
# include "mozilla/intl/ICU4XGeckoDataProvider.h"
# include "mozilla/StaticPrefs_intl.h"
# include "nsUnicharUtils.h"
#endif
using mozilla::intl::Script; using mozilla::intl::Script;
using mozilla::intl::UnicodeProperties; using mozilla::intl::UnicodeProperties;
using mozilla::intl::WordBreaker; using mozilla::intl::WordBreaker;
@@ -99,7 +97,6 @@ WordRange WordBreaker::FindWord(const nsAString& aText, uint32_t aPos,
WordRange range{0, len.value()}; WordRange range{0, len.value()};
#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
if (StaticPrefs::intl_icu4x_segmenter_enabled()) { if (StaticPrefs::intl_icu4x_segmenter_enabled()) {
auto result = auto result =
capi::ICU4XWordSegmenter_create_auto(mozilla::intl::GetDataProvider()); capi::ICU4XWordSegmenter_create_auto(mozilla::intl::GetDataProvider());
@@ -148,7 +145,6 @@ WordRange WordBreaker::FindWord(const nsAString& aText, uint32_t aPos,
return range; return range;
} }
#endif
WordBreakClass c = GetClass(aText[aPos]); WordBreakClass c = GetClass(aText[aPos]);

18
intl/lwbrk/moz.build
View File

@@ -44,14 +44,14 @@ else:
"rulebrk.c", "rulebrk.c",
] ]
if CONFIG["JS_HAS_INTL_API"] and CONFIG["MOZ_ICU4X"]: LOCAL_INCLUDES += [
LOCAL_INCLUDES += [ "/intl/icu_capi/bindings/cpp",
"/intl/icu_capi/bindings/cpp", ]
]
# Disable warnings when including C++ headers of ICU4X. # Disable warnings when including C++ headers of ICU4X.
# - https://github.com/rust-diplomat/diplomat/issues/277 # - https://github.com/rust-diplomat/diplomat/issues/277
CXXFLAGS += [ CXXFLAGS += [
"-Wno-mismatched-tags", "-Wno-mismatched-tags",
] ]
FINAL_LIBRARY = "xul" FINAL_LIBRARY = "xul"