From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- js/src/builtin/intl/Segmenter.h | 329 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 329 insertions(+) create mode 100644 js/src/builtin/intl/Segmenter.h (limited to 'js/src/builtin/intl/Segmenter.h') diff --git a/js/src/builtin/intl/Segmenter.h b/js/src/builtin/intl/Segmenter.h new file mode 100644 index 0000000000..1567a3f774 --- /dev/null +++ b/js/src/builtin/intl/Segmenter.h @@ -0,0 +1,329 @@ +/* -*- 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/. */ + +#ifndef builtin_intl_Segmenter_h +#define builtin_intl_Segmenter_h + +#include + +#include "builtin/SelfHostingDefines.h" +#include "js/Class.h" +#include "js/Value.h" +#include "vm/NativeObject.h" + +struct JS_PUBLIC_API JSContext; +class JSString; + +namespace JS { +class GCContext; +} + +namespace js { + +enum class SegmenterGranularity : int8_t { Grapheme, Word, Sentence }; + +class SegmenterObject : public NativeObject { + public: + static const JSClass class_; + static const JSClass& protoClass_; + + static constexpr uint32_t INTERNALS_SLOT = 0; + static constexpr uint32_t LOCALE_SLOT = 1; + static constexpr uint32_t GRANULARITY_SLOT = 2; + static constexpr uint32_t SEGMENTER_SLOT = 3; + static constexpr uint32_t SLOT_COUNT = 4; + + static_assert(INTERNALS_SLOT == INTL_INTERNALS_OBJECT_SLOT, + "INTERNALS_SLOT must match self-hosting define for internals " + "object slot"); + + JSString* getLocale() const { + const auto& slot = getFixedSlot(LOCALE_SLOT); + if (slot.isUndefined()) { + return nullptr; + } + return slot.toString(); + } + + void setLocale(JSString* locale) { + setFixedSlot(LOCALE_SLOT, StringValue(locale)); + } + + SegmenterGranularity getGranularity() const { + const auto& slot = getFixedSlot(GRANULARITY_SLOT); + if (slot.isUndefined()) { + return SegmenterGranularity::Grapheme; + } + return static_cast(slot.toInt32()); + } + + void setGranularity(SegmenterGranularity granularity) { + setFixedSlot(GRANULARITY_SLOT, + Int32Value(static_cast(granularity))); + } + + void* getSegmenter() const { + const auto& slot = getFixedSlot(SEGMENTER_SLOT); + if (slot.isUndefined()) { + return nullptr; + } + return slot.toPrivate(); + } + + void setSegmenter(void* brk) { + setFixedSlot(SEGMENTER_SLOT, PrivateValue(brk)); + } + + private: + static const ClassSpec classSpec_; + static const JSClassOps classOps_; + + static void finalize(JS::GCContext* gcx, JSObject* obj); +}; + +class SegmentsObject : public NativeObject { + public: + static const JSClass class_; + + static constexpr uint32_t SEGMENTER_SLOT = 0; + static constexpr uint32_t STRING_SLOT = 1; + static constexpr uint32_t STRING_CHARS_SLOT = 2; + static constexpr uint32_t INDEX_SLOT = 3; + static constexpr uint32_t GRANULARITY_SLOT = 4; + static constexpr uint32_t BREAK_ITERATOR_SLOT = 5; + static constexpr uint32_t SLOT_COUNT = 6; + + static_assert(STRING_SLOT == INTL_SEGMENTS_STRING_SLOT, + "STRING_SLOT must match self-hosting define for string slot"); + + SegmenterObject* getSegmenter() const { + const auto& slot = getFixedSlot(SEGMENTER_SLOT); + if (slot.isUndefined()) { + return nullptr; + } + return &slot.toObject().as(); + } + + void setSegmenter(SegmenterObject* segmenter) { + setFixedSlot(SEGMENTER_SLOT, ObjectValue(*segmenter)); + } + + JSString* getString() const { + const auto& slot = getFixedSlot(STRING_SLOT); + if (slot.isUndefined()) { + return nullptr; + } + return slot.toString(); + } + + void setString(JSString* str) { setFixedSlot(STRING_SLOT, StringValue(str)); } + + bool hasStringChars() const { + return !getFixedSlot(STRING_CHARS_SLOT).isUndefined(); + } + + void* getStringChars() const { + const auto& slot = getFixedSlot(STRING_CHARS_SLOT); + if (slot.isUndefined()) { + return nullptr; + } + return slot.toPrivate(); + } + + void setLatin1Chars(JS::Latin1Char* chars) { + setFixedSlot(STRING_CHARS_SLOT, PrivateValue(chars)); + } + + void setTwoByteChars(char16_t* chars) { + setFixedSlot(STRING_CHARS_SLOT, PrivateValue(chars)); + } + + int32_t getIndex() const { + const auto& slot = getFixedSlot(INDEX_SLOT); + if (slot.isUndefined()) { + return 0; + } + return slot.toInt32(); + } + + void setIndex(int32_t index) { setFixedSlot(INDEX_SLOT, Int32Value(index)); } + + SegmenterGranularity getGranularity() const { + const auto& slot = getFixedSlot(GRANULARITY_SLOT); + if (slot.isUndefined()) { + return SegmenterGranularity::Grapheme; + } + return static_cast(slot.toInt32()); + } + + void setGranularity(SegmenterGranularity granularity) { + setFixedSlot(GRANULARITY_SLOT, + Int32Value(static_cast(granularity))); + } + + void* getBreakIterator() const { + const auto& slot = getFixedSlot(BREAK_ITERATOR_SLOT); + if (slot.isUndefined()) { + return nullptr; + } + return slot.toPrivate(); + } + + void setBreakIterator(void* brk) { + setFixedSlot(BREAK_ITERATOR_SLOT, PrivateValue(brk)); + } + + private: + static const JSClassOps classOps_; + + static void finalize(JS::GCContext* gcx, JSObject* obj); +}; + +class SegmentIteratorObject : public NativeObject { + public: + static const JSClass class_; + + static constexpr uint32_t SEGMENTER_SLOT = 0; + static constexpr uint32_t STRING_SLOT = 1; + static constexpr uint32_t STRING_CHARS_SLOT = 2; + static constexpr uint32_t INDEX_SLOT = 3; + static constexpr uint32_t GRANULARITY_SLOT = 4; + static constexpr uint32_t BREAK_ITERATOR_SLOT = 5; + static constexpr uint32_t SLOT_COUNT = 6; + + static_assert(STRING_SLOT == INTL_SEGMENT_ITERATOR_STRING_SLOT, + "STRING_SLOT must match self-hosting define for string slot"); + + static_assert(INDEX_SLOT == INTL_SEGMENT_ITERATOR_INDEX_SLOT, + "INDEX_SLOT must match self-hosting define for index slot"); + + SegmenterObject* getSegmenter() const { + const auto& slot = getFixedSlot(SEGMENTER_SLOT); + if (slot.isUndefined()) { + return nullptr; + } + return &slot.toObject().as(); + } + + void setSegmenter(SegmenterObject* segmenter) { + setFixedSlot(SEGMENTER_SLOT, ObjectOrNullValue(segmenter)); + } + + JSString* getString() const { + const auto& slot = getFixedSlot(STRING_SLOT); + if (slot.isUndefined()) { + return nullptr; + } + return slot.toString(); + } + + void setString(JSString* str) { setFixedSlot(STRING_SLOT, StringValue(str)); } + + bool hasStringChars() const { + return !getFixedSlot(STRING_CHARS_SLOT).isUndefined(); + } + + void* getStringChars() const { + const auto& slot = getFixedSlot(STRING_CHARS_SLOT); + if (slot.isUndefined()) { + return nullptr; + } + return slot.toPrivate(); + } + + void setLatin1Chars(JS::Latin1Char* chars) { + setFixedSlot(STRING_CHARS_SLOT, PrivateValue(chars)); + } + + void setTwoByteChars(char16_t* chars) { + setFixedSlot(STRING_CHARS_SLOT, PrivateValue(chars)); + } + + int32_t getIndex() const { + const auto& slot = getFixedSlot(INDEX_SLOT); + if (slot.isUndefined()) { + return 0; + } + return slot.toInt32(); + } + + void setIndex(int32_t index) { setFixedSlot(INDEX_SLOT, Int32Value(index)); } + + SegmenterGranularity getGranularity() const { + const auto& slot = getFixedSlot(GRANULARITY_SLOT); + if (slot.isUndefined()) { + return SegmenterGranularity::Grapheme; + } + return static_cast(slot.toInt32()); + } + + void setGranularity(SegmenterGranularity granularity) { + setFixedSlot(GRANULARITY_SLOT, + Int32Value(static_cast(granularity))); + } + + void* getBreakIterator() const { + const auto& slot = getFixedSlot(BREAK_ITERATOR_SLOT); + if (slot.isUndefined()) { + return nullptr; + } + return slot.toPrivate(); + } + + void setBreakIterator(void* brk) { + setFixedSlot(BREAK_ITERATOR_SLOT, PrivateValue(brk)); + } + + private: + static const JSClassOps classOps_; + + static void finalize(JS::GCContext* gcx, JSObject* obj); +}; + +/** + * Create a new Segments object. + * + * Usage: segment = intl_CreateSegmentsObject(segmenter, string) + */ +[[nodiscard]] extern bool intl_CreateSegmentsObject(JSContext* cx, + unsigned argc, Value* vp); + +/** + * Create a new Segment Iterator object. + * + * Usage: iterator = intl_CreateSegmentIterator(segments) + */ +[[nodiscard]] extern bool intl_CreateSegmentIterator(JSContext* cx, + unsigned argc, Value* vp); + +/** + * Find the next and the preceding segment boundaries for the given index. The + * index must be a valid string index within the segmenter string. + * + * Return a three-element array object `[startIndex, endIndex, wordLike]`, where + * `wordLike` is either a boolean or undefined for non-word segmenters. + * + * Usage: boundaries = intl_FindSegmentBoundaries(segments, index) + */ +[[nodiscard]] extern bool intl_FindSegmentBoundaries(JSContext* cx, + unsigned argc, Value* vp); + +/** + * Find the next segment boundaries starting from the current iterator index. + * The iterator mustn't have been completed. + * + * Return a three-element array object `[startIndex, endIndex, wordLike]`, where + * `wordLike` is either a boolean or undefined for non-word segmenters. + * + * Usage: boundaries = intl_FindNextSegmentBoundaries(iterator) + */ +[[nodiscard]] extern bool intl_FindNextSegmentBoundaries(JSContext* cx, + unsigned argc, + Value* vp); + +} // namespace js + +#endif /* builtin_intl_Segmenter_h */ -- cgit v1.2.3