1489 lines
49 KiB
C++
1489 lines
49 KiB
C++
/* -*- 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/. */
|
|
|
|
#ifndef vm_String_h
|
|
#define vm_String_h
|
|
|
|
#include "mozilla/MemoryReporting.h"
|
|
#include "mozilla/PodOperations.h"
|
|
#include "mozilla/Range.h"
|
|
#include "mozilla/Maybe.h"
|
|
|
|
#include "jsapi.h"
|
|
#include "jsfriendapi.h"
|
|
#include "jsstr.h"
|
|
|
|
#include "gc/Barrier.h"
|
|
#include "gc/Heap.h"
|
|
#include "gc/Marking.h"
|
|
#include "gc/Rooting.h"
|
|
#include "js/CharacterEncoding.h"
|
|
#include "js/GCAPI.h"
|
|
#include "js/RootingAPI.h"
|
|
|
|
class JSDependentString;
|
|
class JSExtensibleString;
|
|
class JSExternalString;
|
|
class JSInlineString;
|
|
class JSRope;
|
|
|
|
namespace js {
|
|
|
|
class AutoStableStringChars;
|
|
class StaticStrings;
|
|
class PropertyName;
|
|
|
|
/* The buffer length required to contain any unsigned 32-bit integer. */
|
|
static const size_t UINT32_CHAR_BUFFER_LENGTH = sizeof("4294967295") - 1;
|
|
|
|
} /* namespace js */
|
|
|
|
/*
|
|
* JavaScript strings
|
|
*
|
|
* Conceptually, a JS string is just an array of chars and a length. This array
|
|
* of chars may or may not be null-terminated and, if it is, the null character
|
|
* is not included in the length.
|
|
*
|
|
* To improve performance of common operations, the following optimizations are
|
|
* made which affect the engine's representation of strings:
|
|
*
|
|
* - The plain vanilla representation is a "flat" string which consists of a
|
|
* string header in the GC heap and a malloc'd null terminated char array.
|
|
*
|
|
* - To avoid copying a substring of an existing "base" string , a "dependent"
|
|
* string (JSDependentString) can be created which points into the base
|
|
* string's char array.
|
|
*
|
|
* - To avoid O(n^2) char buffer copying, a "rope" node (JSRope) can be created
|
|
* to represent a delayed string concatenation. Concatenation (called
|
|
* flattening) is performed if and when a linear char array is requested. In
|
|
* general, ropes form a binary dag whose internal nodes are JSRope string
|
|
* headers with no associated char array and whose leaf nodes are either flat
|
|
* or dependent strings.
|
|
*
|
|
* - To avoid copying the leftmost string when flattening, we may produce an
|
|
* "extensible" string, which tracks not only its actual length but also its
|
|
* buffer's overall size. If such an "extensible" string appears as the
|
|
* leftmost string in a subsequent flatten, and its buffer has enough unused
|
|
* space, we can simply flatten the rest of the ropes into its buffer,
|
|
* leaving its text in place. We then transfer ownership of its buffer to the
|
|
* flattened rope, and mutate the donor extensible string into a dependent
|
|
* string referencing its original buffer.
|
|
*
|
|
* (The term "extensible" does not imply that we ever 'realloc' the buffer.
|
|
* Extensible strings may have dependent strings pointing into them, and the
|
|
* JSAPI hands out pointers to flat strings' buffers, so resizing with
|
|
* 'realloc' is generally not possible.)
|
|
*
|
|
* - To avoid allocating small char arrays, short strings can be stored inline
|
|
* in the string header (JSInlineString). These come in two flavours:
|
|
* JSThinInlineString, which is the same size as JSString; and
|
|
* JSFatInlineString, which has a larger header and so can fit more chars.
|
|
*
|
|
* - To avoid comparing O(n) string equality comparison, strings can be
|
|
* canonicalized to "atoms" (JSAtom) such that there is a single atom with a
|
|
* given (length,chars).
|
|
*
|
|
* - To avoid copying all strings created through the JSAPI, an "external"
|
|
* string (JSExternalString) can be created whose chars are managed by the
|
|
* JSAPI client.
|
|
*
|
|
* - To avoid using two bytes per character for every string, string characters
|
|
* are stored as Latin1 instead of TwoByte if all characters are representable
|
|
* in Latin1.
|
|
*
|
|
* Although all strings share the same basic memory layout, we can conceptually
|
|
* arrange them into a hierarchy of operations/invariants and represent this
|
|
* hierarchy in C++ with classes:
|
|
*
|
|
* C++ type operations+fields / invariants+properties
|
|
* ========================== =========================================
|
|
* JSString (abstract) get(Latin1|TwoByte)CharsZ, get(Latin1|TwoByte)Chars, length / -
|
|
* | \
|
|
* | JSRope leftChild, rightChild / -
|
|
* |
|
|
* JSLinearString (abstract) latin1Chars, twoByteChars / might be null-terminated
|
|
* | \
|
|
* | JSDependentString base / -
|
|
* |
|
|
* JSFlatString - / null terminated
|
|
* | |
|
|
* | +-- JSExternalString - / char array memory managed by embedding
|
|
* | |
|
|
* | +-- JSExtensibleString tracks total buffer capacity (including current text)
|
|
* | |
|
|
* | +-- JSUndependedString original dependent base / -
|
|
* | |
|
|
* | +-- JSInlineString (abstract) - / chars stored in header
|
|
* | |
|
|
* | +-- JSThinInlineString - / header is normal
|
|
* | |
|
|
* | +-- JSFatInlineString - / header is fat
|
|
* |
|
|
* JSAtom (abstract) - / string equality === pointer equality
|
|
* | |
|
|
* | +-- js::NormalAtom - JSFlatString + atom hash code
|
|
* | |
|
|
* | +-- js::FatInlineAtom - JSFatInlineString + atom hash code
|
|
* |
|
|
* js::PropertyName - / chars don't contain an index (uint32_t)
|
|
*
|
|
* Classes marked with (abstract) above are not literally C++ Abstract Base
|
|
* Classes (since there are no virtual functions, pure or not, in this
|
|
* hierarchy), but have the same meaning: there are no strings with this type as
|
|
* its most-derived type.
|
|
*
|
|
* Atoms can additionally be permanent, i.e. unable to be collected, and can
|
|
* be combined with other string types to create additional most-derived types
|
|
* that satisfy the invariants of more than one of the abovementioned
|
|
* most-derived types. Furthermore, each atom stores a hash number (based on its
|
|
* chars). This hash number is used as key in the atoms table and when the atom
|
|
* is used as key in a JS Map/Set.
|
|
*
|
|
* Derived string types can be queried from ancestor types via isX() and
|
|
* retrieved with asX() debug-only-checked casts.
|
|
*
|
|
* The ensureX() operations mutate 'this' in place to effectively the type to be
|
|
* at least X (e.g., ensureLinear will change a JSRope to be a JSFlatString).
|
|
*/
|
|
|
|
class JSString : public js::gc::TenuredCell
|
|
{
|
|
protected:
|
|
static const size_t NUM_INLINE_CHARS_LATIN1 = 2 * sizeof(void*) / sizeof(JS::Latin1Char);
|
|
static const size_t NUM_INLINE_CHARS_TWO_BYTE = 2 * sizeof(void*) / sizeof(char16_t);
|
|
|
|
/* Fields only apply to string types commented on the right. */
|
|
struct Data
|
|
{
|
|
union {
|
|
struct {
|
|
uint32_t flags; /* JSString */
|
|
uint32_t length; /* JSString */
|
|
};
|
|
uintptr_t flattenData; /* JSRope (temporary while flattening) */
|
|
} u1;
|
|
union {
|
|
union {
|
|
/* JS(Fat)InlineString */
|
|
JS::Latin1Char inlineStorageLatin1[NUM_INLINE_CHARS_LATIN1];
|
|
char16_t inlineStorageTwoByte[NUM_INLINE_CHARS_TWO_BYTE];
|
|
};
|
|
struct {
|
|
union {
|
|
const JS::Latin1Char* nonInlineCharsLatin1; /* JSLinearString, except JS(Fat)InlineString */
|
|
const char16_t* nonInlineCharsTwoByte;/* JSLinearString, except JS(Fat)InlineString */
|
|
JSString* left; /* JSRope */
|
|
} u2;
|
|
union {
|
|
JSLinearString* base; /* JS(Dependent|Undepended)String */
|
|
JSString* right; /* JSRope */
|
|
size_t capacity; /* JSFlatString (extensible) */
|
|
const JSStringFinalizer* externalFinalizer;/* JSExternalString */
|
|
} u3;
|
|
} s;
|
|
};
|
|
} d;
|
|
|
|
public:
|
|
/* Flags exposed only for jits */
|
|
|
|
/*
|
|
* The Flags Word
|
|
*
|
|
* The flags word stores both the string's type and its character encoding.
|
|
*
|
|
* If LATIN1_CHARS_BIT is set, the string's characters are stored as Latin1
|
|
* instead of TwoByte. This flag can also be set for ropes, if both the
|
|
* left and right nodes are Latin1. Flattening will result in a Latin1
|
|
* string in this case.
|
|
*
|
|
* The other flags store the string's type. Instead of using a dense index
|
|
* to represent the most-derived type, string types are encoded to allow
|
|
* single-op tests for hot queries (isRope, isDependent, isFlat, isAtom)
|
|
* which, in view of subtyping, would require slower
|
|
* (isX() || isY() || isZ()).
|
|
*
|
|
* The string type encoding can be summarized as follows. The "instance
|
|
* encoding" entry for a type specifies the flag bits used to create a
|
|
* string instance of that type. Abstract types have no instances and thus
|
|
* have no such entry. The "subtype predicate" entry for a type specifies
|
|
* the predicate used to query whether a JSString instance is subtype
|
|
* (reflexively) of that type.
|
|
*
|
|
* String Instance Subtype
|
|
* type encoding predicate
|
|
* ------------------------------------
|
|
* Rope 000000 000000
|
|
* Linear - !000000
|
|
* HasBase - xxxx1x
|
|
* Dependent 000010 000010
|
|
* Flat - xxxxx1
|
|
* Undepended 000011 000011
|
|
* Extensible 010001 010001
|
|
* Inline 000101 xxx1xx
|
|
* FatInline 010101 x1x1xx
|
|
* External 100001 100001
|
|
* Atom 001001 xx1xxx
|
|
* PermanentAtom 101001 1x1xxx
|
|
* InlineAtom - xx11xx
|
|
* FatInlineAtom - x111xx
|
|
*
|
|
* Note that the first 4 flag bits (from right to left in the previous table)
|
|
* have the following meaning and can be used for some hot queries:
|
|
*
|
|
* Bit 0: IsFlat
|
|
* Bit 1: HasBase (Dependent, Undepended)
|
|
* Bit 2: IsInline (Inline, FatInline)
|
|
* Bit 3: IsAtom (Atom, PermanentAtom)
|
|
*
|
|
* "HasBase" here refers to the two string types that have a 'base' field:
|
|
* JSDependentString and JSUndependedString.
|
|
* A JSUndependedString is a JSDependentString which has been 'fixed' (by ensureFixed)
|
|
* to be null-terminated. In such cases, the string must keep marking its base since
|
|
* there may be any number of *other* JSDependentStrings transitively depending on it.
|
|
*
|
|
*/
|
|
|
|
static const uint32_t FLAT_BIT = JS_BIT(0);
|
|
static const uint32_t HAS_BASE_BIT = JS_BIT(1);
|
|
static const uint32_t INLINE_CHARS_BIT = JS_BIT(2);
|
|
static const uint32_t ATOM_BIT = JS_BIT(3);
|
|
|
|
static const uint32_t ROPE_FLAGS = 0;
|
|
static const uint32_t DEPENDENT_FLAGS = HAS_BASE_BIT;
|
|
static const uint32_t UNDEPENDED_FLAGS = FLAT_BIT | HAS_BASE_BIT;
|
|
static const uint32_t EXTENSIBLE_FLAGS = FLAT_BIT | JS_BIT(4);
|
|
static const uint32_t EXTERNAL_FLAGS = FLAT_BIT | JS_BIT(5);
|
|
|
|
static const uint32_t FAT_INLINE_MASK = INLINE_CHARS_BIT | JS_BIT(4);
|
|
static const uint32_t PERMANENT_ATOM_MASK = ATOM_BIT | JS_BIT(5);
|
|
|
|
/* Initial flags for thin inline and fat inline strings. */
|
|
static const uint32_t INIT_THIN_INLINE_FLAGS = FLAT_BIT | INLINE_CHARS_BIT;
|
|
static const uint32_t INIT_FAT_INLINE_FLAGS = FLAT_BIT | FAT_INLINE_MASK;
|
|
|
|
static const uint32_t TYPE_FLAGS_MASK = JS_BIT(6) - 1;
|
|
|
|
static const uint32_t LATIN1_CHARS_BIT = JS_BIT(6);
|
|
|
|
static const uint32_t MAX_LENGTH = js::MaxStringLength;
|
|
|
|
static const JS::Latin1Char MAX_LATIN1_CHAR = 0xff;
|
|
|
|
/*
|
|
* Helper function to validate that a string of a given length is
|
|
* representable by a JSString. An allocation overflow is reported if false
|
|
* is returned.
|
|
*/
|
|
static inline bool validateLength(js::ExclusiveContext* maybecx, size_t length);
|
|
|
|
static void staticAsserts() {
|
|
static_assert(JSString::MAX_LENGTH < UINT32_MAX, "Length must fit in 32 bits");
|
|
static_assert(sizeof(JSString) ==
|
|
(offsetof(JSString, d.inlineStorageLatin1) +
|
|
NUM_INLINE_CHARS_LATIN1 * sizeof(char)),
|
|
"Inline Latin1 chars must fit in a JSString");
|
|
static_assert(sizeof(JSString) ==
|
|
(offsetof(JSString, d.inlineStorageTwoByte) +
|
|
NUM_INLINE_CHARS_TWO_BYTE * sizeof(char16_t)),
|
|
"Inline char16_t chars must fit in a JSString");
|
|
|
|
/* Ensure js::shadow::String has the same layout. */
|
|
using js::shadow::String;
|
|
static_assert(offsetof(JSString, d.u1.length) == offsetof(String, length),
|
|
"shadow::String length offset must match JSString");
|
|
static_assert(offsetof(JSString, d.u1.flags) == offsetof(String, flags),
|
|
"shadow::String flags offset must match JSString");
|
|
static_assert(offsetof(JSString, d.s.u2.nonInlineCharsLatin1) == offsetof(String, nonInlineCharsLatin1),
|
|
"shadow::String nonInlineChars offset must match JSString");
|
|
static_assert(offsetof(JSString, d.s.u2.nonInlineCharsTwoByte) == offsetof(String, nonInlineCharsTwoByte),
|
|
"shadow::String nonInlineChars offset must match JSString");
|
|
static_assert(offsetof(JSString, d.inlineStorageLatin1) == offsetof(String, inlineStorageLatin1),
|
|
"shadow::String inlineStorage offset must match JSString");
|
|
static_assert(offsetof(JSString, d.inlineStorageTwoByte) == offsetof(String, inlineStorageTwoByte),
|
|
"shadow::String inlineStorage offset must match JSString");
|
|
static_assert(INLINE_CHARS_BIT == String::INLINE_CHARS_BIT,
|
|
"shadow::String::INLINE_CHARS_BIT must match JSString::INLINE_CHARS_BIT");
|
|
static_assert(LATIN1_CHARS_BIT == String::LATIN1_CHARS_BIT,
|
|
"shadow::String::LATIN1_CHARS_BIT must match JSString::LATIN1_CHARS_BIT");
|
|
static_assert(TYPE_FLAGS_MASK == String::TYPE_FLAGS_MASK,
|
|
"shadow::String::TYPE_FLAGS_MASK must match JSString::TYPE_FLAGS_MASK");
|
|
static_assert(ROPE_FLAGS == String::ROPE_FLAGS,
|
|
"shadow::String::ROPE_FLAGS must match JSString::ROPE_FLAGS");
|
|
}
|
|
|
|
/* Avoid lame compile errors in JSRope::flatten */
|
|
friend class JSRope;
|
|
|
|
protected:
|
|
template <typename CharT>
|
|
MOZ_ALWAYS_INLINE
|
|
void setNonInlineChars(const CharT* chars);
|
|
|
|
public:
|
|
/* All strings have length. */
|
|
|
|
MOZ_ALWAYS_INLINE
|
|
size_t length() const {
|
|
return d.u1.length;
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE
|
|
bool empty() const {
|
|
return d.u1.length == 0;
|
|
}
|
|
|
|
inline bool getChar(js::ExclusiveContext* cx, size_t index, char16_t* code);
|
|
|
|
/* Strings have either Latin1 or TwoByte chars. */
|
|
bool hasLatin1Chars() const {
|
|
return d.u1.flags & LATIN1_CHARS_BIT;
|
|
}
|
|
bool hasTwoByteChars() const {
|
|
return !(d.u1.flags & LATIN1_CHARS_BIT);
|
|
}
|
|
|
|
/* Fallible conversions to more-derived string types. */
|
|
|
|
inline JSLinearString* ensureLinear(js::ExclusiveContext* cx);
|
|
inline JSFlatString* ensureFlat(js::ExclusiveContext* cx);
|
|
|
|
static bool ensureLinear(js::ExclusiveContext* cx, JSString* str) {
|
|
return str->ensureLinear(cx) != nullptr;
|
|
}
|
|
|
|
/* Type query and debug-checked casts */
|
|
|
|
MOZ_ALWAYS_INLINE
|
|
bool isRope() const {
|
|
return (d.u1.flags & TYPE_FLAGS_MASK) == ROPE_FLAGS;
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE
|
|
JSRope& asRope() const {
|
|
MOZ_ASSERT(isRope());
|
|
return *(JSRope*)this;
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE
|
|
bool isLinear() const {
|
|
return !isRope();
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE
|
|
JSLinearString& asLinear() const {
|
|
MOZ_ASSERT(JSString::isLinear());
|
|
return *(JSLinearString*)this;
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE
|
|
bool isDependent() const {
|
|
return (d.u1.flags & TYPE_FLAGS_MASK) == DEPENDENT_FLAGS;
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE
|
|
JSDependentString& asDependent() const {
|
|
MOZ_ASSERT(isDependent());
|
|
return *(JSDependentString*)this;
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE
|
|
bool isFlat() const {
|
|
return d.u1.flags & FLAT_BIT;
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE
|
|
JSFlatString& asFlat() const {
|
|
MOZ_ASSERT(isFlat());
|
|
return *(JSFlatString*)this;
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE
|
|
bool isExtensible() const {
|
|
return (d.u1.flags & TYPE_FLAGS_MASK) == EXTENSIBLE_FLAGS;
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE
|
|
JSExtensibleString& asExtensible() const {
|
|
MOZ_ASSERT(isExtensible());
|
|
return *(JSExtensibleString*)this;
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE
|
|
bool isInline() const {
|
|
return d.u1.flags & INLINE_CHARS_BIT;
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE
|
|
JSInlineString& asInline() const {
|
|
MOZ_ASSERT(isInline());
|
|
return *(JSInlineString*)this;
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE
|
|
bool isFatInline() const {
|
|
return (d.u1.flags & FAT_INLINE_MASK) == FAT_INLINE_MASK;
|
|
}
|
|
|
|
/* For hot code, prefer other type queries. */
|
|
bool isExternal() const {
|
|
return (d.u1.flags & TYPE_FLAGS_MASK) == EXTERNAL_FLAGS;
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE
|
|
JSExternalString& asExternal() const {
|
|
MOZ_ASSERT(isExternal());
|
|
return *(JSExternalString*)this;
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE
|
|
bool isUndepended() const {
|
|
return (d.u1.flags & TYPE_FLAGS_MASK) == UNDEPENDED_FLAGS;
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE
|
|
bool isAtom() const {
|
|
return d.u1.flags & ATOM_BIT;
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE
|
|
bool isPermanentAtom() const {
|
|
return (d.u1.flags & PERMANENT_ATOM_MASK) == PERMANENT_ATOM_MASK;
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE
|
|
JSAtom& asAtom() const {
|
|
MOZ_ASSERT(isAtom());
|
|
return *(JSAtom*)this;
|
|
}
|
|
|
|
/* Only called by the GC for dependent or undepended strings. */
|
|
|
|
inline bool hasBase() const {
|
|
return d.u1.flags & HAS_BASE_BIT;
|
|
}
|
|
|
|
inline JSLinearString* base() const;
|
|
|
|
void traceBase(JSTracer* trc);
|
|
|
|
/* Only called by the GC for strings with the AllocKind::STRING kind. */
|
|
|
|
inline void finalize(js::FreeOp* fop);
|
|
|
|
/* Gets the number of bytes that the chars take on the heap. */
|
|
|
|
size_t sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf);
|
|
|
|
/* Offsets for direct field from jit code. */
|
|
|
|
static size_t offsetOfLength() {
|
|
return offsetof(JSString, d.u1.length);
|
|
}
|
|
static size_t offsetOfFlags() {
|
|
return offsetof(JSString, d.u1.flags);
|
|
}
|
|
|
|
static size_t offsetOfNonInlineChars() {
|
|
static_assert(offsetof(JSString, d.s.u2.nonInlineCharsTwoByte) ==
|
|
offsetof(JSString, d.s.u2.nonInlineCharsLatin1),
|
|
"nonInlineCharsTwoByte and nonInlineCharsLatin1 must have same offset");
|
|
return offsetof(JSString, d.s.u2.nonInlineCharsTwoByte);
|
|
}
|
|
|
|
static inline js::ThingRootKind rootKind() { return js::THING_ROOT_STRING; }
|
|
|
|
#ifdef DEBUG
|
|
void dump();
|
|
void dumpCharsNoNewline(FILE* fp=stderr);
|
|
void dumpRepresentation(FILE* fp, int indent) const;
|
|
void dumpRepresentationHeader(FILE* fp, int indent, const char* subclass) const;
|
|
|
|
template <typename CharT>
|
|
static void dumpChars(const CharT* s, size_t len, FILE* fp=stderr);
|
|
|
|
bool equals(const char* s);
|
|
#endif
|
|
|
|
void traceChildren(JSTracer* trc);
|
|
|
|
static MOZ_ALWAYS_INLINE void readBarrier(JSString* thing) {
|
|
if (thing->isPermanentAtom())
|
|
return;
|
|
|
|
TenuredCell::readBarrier(thing);
|
|
}
|
|
|
|
static MOZ_ALWAYS_INLINE void writeBarrierPre(JSString* thing) {
|
|
if (isNullLike(thing) || thing->isPermanentAtom())
|
|
return;
|
|
|
|
TenuredCell::writeBarrierPre(thing);
|
|
}
|
|
|
|
private:
|
|
JSString() = delete;
|
|
JSString(const JSString& other) = delete;
|
|
void operator=(const JSString& other) = delete;
|
|
};
|
|
|
|
class JSRope : public JSString
|
|
{
|
|
template <typename CharT>
|
|
bool copyCharsInternal(js::ExclusiveContext* cx, js::ScopedJSFreePtr<CharT>& out,
|
|
bool nullTerminate) const;
|
|
|
|
enum UsingBarrier { WithIncrementalBarrier, NoBarrier };
|
|
|
|
template<UsingBarrier b, typename CharT>
|
|
JSFlatString* flattenInternal(js::ExclusiveContext* cx);
|
|
|
|
template<UsingBarrier b>
|
|
JSFlatString* flattenInternal(js::ExclusiveContext* cx);
|
|
|
|
friend class JSString;
|
|
JSFlatString* flatten(js::ExclusiveContext* cx);
|
|
|
|
void init(js::ExclusiveContext* cx, JSString* left, JSString* right, size_t length);
|
|
|
|
public:
|
|
template <js::AllowGC allowGC>
|
|
static inline JSRope* new_(js::ExclusiveContext* cx,
|
|
typename js::MaybeRooted<JSString*, allowGC>::HandleType left,
|
|
typename js::MaybeRooted<JSString*, allowGC>::HandleType right,
|
|
size_t length);
|
|
|
|
bool copyLatin1Chars(js::ExclusiveContext* cx,
|
|
js::ScopedJSFreePtr<JS::Latin1Char>& out) const;
|
|
bool copyTwoByteChars(js::ExclusiveContext* cx, js::ScopedJSFreePtr<char16_t>& out) const;
|
|
|
|
bool copyLatin1CharsZ(js::ExclusiveContext* cx,
|
|
js::ScopedJSFreePtr<JS::Latin1Char>& out) const;
|
|
bool copyTwoByteCharsZ(js::ExclusiveContext* cx, js::ScopedJSFreePtr<char16_t>& out) const;
|
|
|
|
template <typename CharT>
|
|
bool copyChars(js::ExclusiveContext* cx, js::ScopedJSFreePtr<CharT>& out) const;
|
|
|
|
JSString* leftChild() const {
|
|
MOZ_ASSERT(isRope());
|
|
return d.s.u2.left;
|
|
}
|
|
|
|
JSString* rightChild() const {
|
|
MOZ_ASSERT(isRope());
|
|
return d.s.u3.right;
|
|
}
|
|
|
|
void traceChildren(JSTracer* trc);
|
|
|
|
static size_t offsetOfLeft() {
|
|
return offsetof(JSRope, d.s.u2.left);
|
|
}
|
|
static size_t offsetOfRight() {
|
|
return offsetof(JSRope, d.s.u3.right);
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
void dumpRepresentation(FILE* fp, int indent) const;
|
|
#endif
|
|
};
|
|
|
|
static_assert(sizeof(JSRope) == sizeof(JSString),
|
|
"string subclasses must be binary-compatible with JSString");
|
|
|
|
class JSLinearString : public JSString
|
|
{
|
|
friend class JSString;
|
|
friend class js::AutoStableStringChars;
|
|
|
|
/* Vacuous and therefore unimplemented. */
|
|
JSLinearString* ensureLinear(JSContext* cx) = delete;
|
|
bool isLinear() const = delete;
|
|
JSLinearString& asLinear() const = delete;
|
|
|
|
protected:
|
|
/* Returns void pointer to latin1/twoByte chars, for finalizers. */
|
|
MOZ_ALWAYS_INLINE
|
|
void* nonInlineCharsRaw() const {
|
|
MOZ_ASSERT(!isInline());
|
|
static_assert(offsetof(JSLinearString, d.s.u2.nonInlineCharsTwoByte) ==
|
|
offsetof(JSLinearString, d.s.u2.nonInlineCharsLatin1),
|
|
"nonInlineCharsTwoByte and nonInlineCharsLatin1 must have same offset");
|
|
return (void*)d.s.u2.nonInlineCharsTwoByte;
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE const JS::Latin1Char* rawLatin1Chars() const;
|
|
MOZ_ALWAYS_INLINE const char16_t* rawTwoByteChars() const;
|
|
|
|
public:
|
|
template<typename CharT>
|
|
MOZ_ALWAYS_INLINE
|
|
const CharT* nonInlineChars(const JS::AutoCheckCannotGC& nogc) const;
|
|
|
|
MOZ_ALWAYS_INLINE
|
|
const JS::Latin1Char* nonInlineLatin1Chars(const JS::AutoCheckCannotGC& nogc) const {
|
|
MOZ_ASSERT(!isInline());
|
|
MOZ_ASSERT(hasLatin1Chars());
|
|
return d.s.u2.nonInlineCharsLatin1;
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE
|
|
const char16_t* nonInlineTwoByteChars(const JS::AutoCheckCannotGC& nogc) const {
|
|
MOZ_ASSERT(!isInline());
|
|
MOZ_ASSERT(hasTwoByteChars());
|
|
return d.s.u2.nonInlineCharsTwoByte;
|
|
}
|
|
|
|
template<typename CharT>
|
|
MOZ_ALWAYS_INLINE
|
|
const CharT* chars(const JS::AutoCheckCannotGC& nogc) const;
|
|
|
|
MOZ_ALWAYS_INLINE
|
|
const JS::Latin1Char* latin1Chars(const JS::AutoCheckCannotGC& nogc) const {
|
|
return rawLatin1Chars();
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE
|
|
const char16_t* twoByteChars(const JS::AutoCheckCannotGC& nogc) const {
|
|
return rawTwoByteChars();
|
|
}
|
|
|
|
mozilla::Range<const JS::Latin1Char> latin1Range(const JS::AutoCheckCannotGC& nogc) const {
|
|
MOZ_ASSERT(JSString::isLinear());
|
|
return mozilla::Range<const JS::Latin1Char>(latin1Chars(nogc), length());
|
|
}
|
|
|
|
mozilla::Range<const char16_t> twoByteRange(const JS::AutoCheckCannotGC& nogc) const {
|
|
MOZ_ASSERT(JSString::isLinear());
|
|
return mozilla::Range<const char16_t>(twoByteChars(nogc), length());
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE
|
|
char16_t latin1OrTwoByteChar(size_t index) const {
|
|
MOZ_ASSERT(JSString::isLinear());
|
|
MOZ_ASSERT(index < length());
|
|
JS::AutoCheckCannotGC nogc;
|
|
return hasLatin1Chars() ? latin1Chars(nogc)[index] : twoByteChars(nogc)[index];
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
void dumpRepresentationChars(FILE* fp, int indent) const;
|
|
#endif
|
|
};
|
|
|
|
static_assert(sizeof(JSLinearString) == sizeof(JSString),
|
|
"string subclasses must be binary-compatible with JSString");
|
|
|
|
class JSDependentString : public JSLinearString
|
|
{
|
|
friend class JSString;
|
|
JSFlatString* undepend(js::ExclusiveContext* cx);
|
|
|
|
template <typename CharT>
|
|
JSFlatString* undependInternal(js::ExclusiveContext* cx);
|
|
|
|
void init(js::ExclusiveContext* cx, JSLinearString* base, size_t start,
|
|
size_t length);
|
|
|
|
/* Vacuous and therefore unimplemented. */
|
|
bool isDependent() const = delete;
|
|
JSDependentString& asDependent() const = delete;
|
|
|
|
/* The offset of this string's chars in base->chars(). */
|
|
MOZ_ALWAYS_INLINE mozilla::Maybe<size_t> baseOffset() const {
|
|
MOZ_ASSERT(JSString::isDependent());
|
|
JS::AutoCheckCannotGC nogc;
|
|
if (MOZ_UNLIKELY(base()->isUndepended()))
|
|
return mozilla::Nothing();
|
|
size_t offset;
|
|
if (hasTwoByteChars())
|
|
offset = twoByteChars(nogc) - base()->twoByteChars(nogc);
|
|
else
|
|
offset = latin1Chars(nogc) - base()->latin1Chars(nogc);
|
|
MOZ_ASSERT(offset < base()->length());
|
|
return mozilla::Some(offset);
|
|
}
|
|
|
|
public:
|
|
static inline JSLinearString* new_(js::ExclusiveContext* cx, JSLinearString* base,
|
|
size_t start, size_t length);
|
|
|
|
inline static size_t offsetOfBase() {
|
|
return offsetof(JSDependentString, d.s.u3.base);
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
void dumpRepresentation(FILE* fp, int indent) const;
|
|
#endif
|
|
};
|
|
|
|
static_assert(sizeof(JSDependentString) == sizeof(JSString),
|
|
"string subclasses must be binary-compatible with JSString");
|
|
|
|
class JSFlatString : public JSLinearString
|
|
{
|
|
/* Vacuous and therefore unimplemented. */
|
|
JSFlatString* ensureFlat(JSContext* cx) = delete;
|
|
bool isFlat() const = delete;
|
|
JSFlatString& asFlat() const = delete;
|
|
|
|
template <typename CharT>
|
|
static bool isIndexSlow(const CharT* s, size_t length, uint32_t* indexp);
|
|
|
|
void init(const char16_t* chars, size_t length);
|
|
void init(const JS::Latin1Char* chars, size_t length);
|
|
|
|
public:
|
|
template <js::AllowGC allowGC, typename CharT>
|
|
static inline JSFlatString* new_(js::ExclusiveContext* cx,
|
|
const CharT* chars, size_t length);
|
|
|
|
/*
|
|
* Returns true if this string's characters store an unsigned 32-bit
|
|
* integer value, initializing *indexp to that value if so. (Thus if
|
|
* calling isIndex returns true, js::IndexToString(cx, *indexp) will be a
|
|
* string equal to this string.)
|
|
*/
|
|
inline bool isIndex(uint32_t* indexp) const {
|
|
MOZ_ASSERT(JSString::isFlat());
|
|
JS::AutoCheckCannotGC nogc;
|
|
if (hasLatin1Chars()) {
|
|
const JS::Latin1Char* s = latin1Chars(nogc);
|
|
return JS7_ISDEC(*s) && isIndexSlow(s, length(), indexp);
|
|
}
|
|
const char16_t* s = twoByteChars(nogc);
|
|
return JS7_ISDEC(*s) && isIndexSlow(s, length(), indexp);
|
|
}
|
|
|
|
/*
|
|
* Returns a property name represented by this string, or null on failure.
|
|
* You must verify that this is not an index per isIndex before calling
|
|
* this method.
|
|
*/
|
|
inline js::PropertyName* toPropertyName(JSContext* cx);
|
|
|
|
/*
|
|
* Once a JSFlatString sub-class has been added to the atom state, this
|
|
* operation changes the string to the JSAtom type, in place.
|
|
*/
|
|
MOZ_ALWAYS_INLINE JSAtom* morphAtomizedStringIntoAtom(js::HashNumber hash);
|
|
MOZ_ALWAYS_INLINE JSAtom* morphAtomizedStringIntoPermanentAtom(js::HashNumber hash);
|
|
|
|
inline void finalize(js::FreeOp* fop);
|
|
|
|
#ifdef DEBUG
|
|
void dumpRepresentation(FILE* fp, int indent) const;
|
|
#endif
|
|
};
|
|
|
|
static_assert(sizeof(JSFlatString) == sizeof(JSString),
|
|
"string subclasses must be binary-compatible with JSString");
|
|
|
|
class JSExtensibleString : public JSFlatString
|
|
{
|
|
/* Vacuous and therefore unimplemented. */
|
|
bool isExtensible() const = delete;
|
|
JSExtensibleString& asExtensible() const = delete;
|
|
|
|
public:
|
|
MOZ_ALWAYS_INLINE
|
|
size_t capacity() const {
|
|
MOZ_ASSERT(JSString::isExtensible());
|
|
return d.s.u3.capacity;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
void dumpRepresentation(FILE* fp, int indent) const;
|
|
#endif
|
|
};
|
|
|
|
static_assert(sizeof(JSExtensibleString) == sizeof(JSString),
|
|
"string subclasses must be binary-compatible with JSString");
|
|
|
|
class JSInlineString : public JSFlatString
|
|
{
|
|
public:
|
|
MOZ_ALWAYS_INLINE
|
|
const JS::Latin1Char* latin1Chars(const JS::AutoCheckCannotGC& nogc) const {
|
|
MOZ_ASSERT(JSString::isInline());
|
|
MOZ_ASSERT(hasLatin1Chars());
|
|
return d.inlineStorageLatin1;
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE
|
|
const char16_t* twoByteChars(const JS::AutoCheckCannotGC& nogc) const {
|
|
MOZ_ASSERT(JSString::isInline());
|
|
MOZ_ASSERT(hasTwoByteChars());
|
|
return d.inlineStorageTwoByte;
|
|
}
|
|
|
|
template<typename CharT>
|
|
static bool lengthFits(size_t length);
|
|
|
|
static size_t offsetOfInlineStorage() {
|
|
return offsetof(JSInlineString, d.inlineStorageTwoByte);
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
void dumpRepresentation(FILE* fp, int indent) const;
|
|
#endif
|
|
};
|
|
|
|
static_assert(sizeof(JSInlineString) == sizeof(JSString),
|
|
"string subclasses must be binary-compatible with JSString");
|
|
|
|
/*
|
|
* On 32-bit platforms, JSThinInlineString can store 7 Latin1 characters or 3
|
|
* TwoByte characters (excluding null terminator) inline. On 64-bit platforms,
|
|
* these numbers are 15 and 7, respectively.
|
|
*/
|
|
class JSThinInlineString : public JSInlineString
|
|
{
|
|
public:
|
|
static const size_t MAX_LENGTH_LATIN1 = NUM_INLINE_CHARS_LATIN1 - 1;
|
|
static const size_t MAX_LENGTH_TWO_BYTE = NUM_INLINE_CHARS_TWO_BYTE - 1;
|
|
|
|
template <js::AllowGC allowGC>
|
|
static inline JSThinInlineString* new_(js::ExclusiveContext* cx);
|
|
|
|
template <typename CharT>
|
|
inline CharT* init(size_t length);
|
|
|
|
template<typename CharT>
|
|
static bool lengthFits(size_t length);
|
|
};
|
|
|
|
static_assert(sizeof(JSThinInlineString) == sizeof(JSString),
|
|
"string subclasses must be binary-compatible with JSString");
|
|
|
|
/*
|
|
* On both 32-bit and 64-bit platforms, MAX_LENGTH_TWO_BYTE is 11 and
|
|
* MAX_LENGTH_LATIN1 is 23 (excluding null terminator). This is deliberate,
|
|
* in order to minimize potential performance differences between 32-bit and
|
|
* 64-bit platforms.
|
|
*
|
|
* There are still some differences due to NUM_INLINE_CHARS_* being different.
|
|
* E.g. TwoByte strings of length 4--7 will be JSFatInlineStrings on 32-bit
|
|
* platforms and JSThinInlineStrings on 64-bit platforms. But the more
|
|
* significant transition from inline strings to non-inline strings occurs at
|
|
* length 11 (for TwoByte strings) and 23 (Latin1 strings) on both 32-bit and
|
|
* 64-bit platforms.
|
|
*/
|
|
class JSFatInlineString : public JSInlineString
|
|
{
|
|
static const size_t INLINE_EXTENSION_CHARS_LATIN1 = 24 - NUM_INLINE_CHARS_LATIN1;
|
|
static const size_t INLINE_EXTENSION_CHARS_TWO_BYTE = 12 - NUM_INLINE_CHARS_TWO_BYTE;
|
|
|
|
protected: /* to fool clang into not warning this is unused */
|
|
union {
|
|
char inlineStorageExtensionLatin1[INLINE_EXTENSION_CHARS_LATIN1];
|
|
char16_t inlineStorageExtensionTwoByte[INLINE_EXTENSION_CHARS_TWO_BYTE];
|
|
};
|
|
|
|
public:
|
|
template <js::AllowGC allowGC>
|
|
static inline JSFatInlineString* new_(js::ExclusiveContext* cx);
|
|
|
|
static const size_t MAX_LENGTH_LATIN1 = JSString::NUM_INLINE_CHARS_LATIN1 +
|
|
INLINE_EXTENSION_CHARS_LATIN1
|
|
-1 /* null terminator */;
|
|
|
|
static const size_t MAX_LENGTH_TWO_BYTE = JSString::NUM_INLINE_CHARS_TWO_BYTE +
|
|
INLINE_EXTENSION_CHARS_TWO_BYTE
|
|
-1 /* null terminator */;
|
|
|
|
template <typename CharT>
|
|
inline CharT* init(size_t length);
|
|
|
|
template<typename CharT>
|
|
static bool lengthFits(size_t length);
|
|
|
|
/* Only called by the GC for strings with the AllocKind::FAT_INLINE_STRING kind. */
|
|
|
|
MOZ_ALWAYS_INLINE void finalize(js::FreeOp* fop);
|
|
};
|
|
|
|
static_assert(sizeof(JSFatInlineString) % js::gc::CellSize == 0,
|
|
"fat inline strings shouldn't waste space up to the next cell "
|
|
"boundary");
|
|
|
|
class JSExternalString : public JSFlatString
|
|
{
|
|
void init(const char16_t* chars, size_t length, const JSStringFinalizer* fin);
|
|
|
|
/* Vacuous and therefore unimplemented. */
|
|
bool isExternal() const = delete;
|
|
JSExternalString& asExternal() const = delete;
|
|
|
|
public:
|
|
static inline JSExternalString* new_(JSContext* cx, const char16_t* chars, size_t length,
|
|
const JSStringFinalizer* fin);
|
|
|
|
const JSStringFinalizer* externalFinalizer() const {
|
|
MOZ_ASSERT(JSString::isExternal());
|
|
return d.s.u3.externalFinalizer;
|
|
}
|
|
|
|
/*
|
|
* External chars are never allocated inline or in the nursery, so we can
|
|
* safely expose this without requiring an AutoCheckCannotGC argument.
|
|
*/
|
|
const char16_t* twoByteChars() const {
|
|
return rawTwoByteChars();
|
|
}
|
|
|
|
/* Only called by the GC for strings with the AllocKind::EXTERNAL_STRING kind. */
|
|
|
|
inline void finalize(js::FreeOp* fop);
|
|
|
|
#ifdef DEBUG
|
|
void dumpRepresentation(FILE* fp, int indent) const;
|
|
#endif
|
|
};
|
|
|
|
static_assert(sizeof(JSExternalString) == sizeof(JSString),
|
|
"string subclasses must be binary-compatible with JSString");
|
|
|
|
class JSUndependedString : public JSFlatString
|
|
{
|
|
/*
|
|
* JSUndependedString is not explicitly used and is only present for
|
|
* consistency. See JSDependentString::undepend for how a JSDependentString
|
|
* gets morphed into a JSUndependedString.
|
|
*/
|
|
};
|
|
|
|
static_assert(sizeof(JSUndependedString) == sizeof(JSString),
|
|
"string subclasses must be binary-compatible with JSString");
|
|
|
|
class JSAtom : public JSFlatString
|
|
{
|
|
/* Vacuous and therefore unimplemented. */
|
|
bool isAtom() const = delete;
|
|
JSAtom& asAtom() const = delete;
|
|
|
|
public:
|
|
/* Returns the PropertyName for this. isIndex() must be false. */
|
|
inline js::PropertyName* asPropertyName();
|
|
|
|
inline void finalize(js::FreeOp* fop);
|
|
|
|
MOZ_ALWAYS_INLINE
|
|
bool isPermanent() const {
|
|
return JSString::isPermanentAtom();
|
|
}
|
|
|
|
// Transform this atom into a permanent atom. This is only done during
|
|
// initialization of the runtime.
|
|
MOZ_ALWAYS_INLINE void morphIntoPermanentAtom() {
|
|
d.u1.flags |= PERMANENT_ATOM_MASK;
|
|
}
|
|
|
|
inline js::HashNumber hash() const;
|
|
inline void initHash(js::HashNumber hash);
|
|
|
|
#ifdef DEBUG
|
|
void dump();
|
|
#endif
|
|
};
|
|
|
|
static_assert(sizeof(JSAtom) == sizeof(JSString),
|
|
"string subclasses must be binary-compatible with JSString");
|
|
|
|
namespace js {
|
|
|
|
class NormalAtom : public JSAtom
|
|
{
|
|
protected: // Silence Clang unused-field warning.
|
|
HashNumber hash_;
|
|
uint32_t padding_; // Ensure the size is a multiple of gc::CellSize.
|
|
|
|
public:
|
|
HashNumber hash() const {
|
|
return hash_;
|
|
}
|
|
void initHash(HashNumber hash) {
|
|
hash_ = hash;
|
|
}
|
|
};
|
|
|
|
static_assert(sizeof(NormalAtom) == sizeof(JSString) + sizeof(uint64_t),
|
|
"NormalAtom must have size of a string + HashNumber, "
|
|
"aligned to gc::CellSize");
|
|
|
|
class FatInlineAtom : public JSAtom
|
|
{
|
|
protected: // Silence Clang unused-field warning.
|
|
char inlineStorage_[sizeof(JSFatInlineString) - sizeof(JSString)];
|
|
HashNumber hash_;
|
|
uint32_t padding_; // Ensure the size is a multiple of gc::CellSize.
|
|
|
|
public:
|
|
HashNumber hash() const {
|
|
return hash_;
|
|
}
|
|
void initHash(HashNumber hash) {
|
|
hash_ = hash;
|
|
}
|
|
};
|
|
|
|
static_assert(sizeof(FatInlineAtom) == sizeof(JSFatInlineString) + sizeof(uint64_t),
|
|
"FatInlineAtom must have size of a fat inline string + HashNumber, "
|
|
"aligned to gc::CellSize");
|
|
|
|
} // namespace js
|
|
|
|
inline js::HashNumber
|
|
JSAtom::hash() const
|
|
{
|
|
if (isFatInline())
|
|
return static_cast<const js::FatInlineAtom*>(this)->hash();
|
|
return static_cast<const js::NormalAtom*>(this)->hash();
|
|
}
|
|
|
|
inline void
|
|
JSAtom::initHash(js::HashNumber hash)
|
|
{
|
|
if (isFatInline())
|
|
return static_cast<js::FatInlineAtom*>(this)->initHash(hash);
|
|
return static_cast<js::NormalAtom*>(this)->initHash(hash);
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE JSAtom*
|
|
JSFlatString::morphAtomizedStringIntoAtom(js::HashNumber hash)
|
|
{
|
|
d.u1.flags |= ATOM_BIT;
|
|
JSAtom* atom = &asAtom();
|
|
atom->initHash(hash);
|
|
return atom;
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE JSAtom*
|
|
JSFlatString::morphAtomizedStringIntoPermanentAtom(js::HashNumber hash)
|
|
{
|
|
d.u1.flags |= PERMANENT_ATOM_MASK;
|
|
JSAtom* atom = &asAtom();
|
|
atom->initHash(hash);
|
|
return atom;
|
|
}
|
|
|
|
namespace js {
|
|
|
|
class StaticStrings
|
|
{
|
|
private:
|
|
/* Bigger chars cannot be in a length-2 string. */
|
|
static const size_t SMALL_CHAR_LIMIT = 128U;
|
|
static const size_t NUM_SMALL_CHARS = 64U;
|
|
|
|
JSAtom* length2StaticTable[NUM_SMALL_CHARS * NUM_SMALL_CHARS];
|
|
|
|
public:
|
|
/* We keep these public for the JITs. */
|
|
static const size_t UNIT_STATIC_LIMIT = 256U;
|
|
JSAtom* unitStaticTable[UNIT_STATIC_LIMIT];
|
|
|
|
static const size_t INT_STATIC_LIMIT = 256U;
|
|
JSAtom* intStaticTable[INT_STATIC_LIMIT];
|
|
|
|
StaticStrings() {
|
|
mozilla::PodZero(this);
|
|
}
|
|
|
|
bool init(JSContext* cx);
|
|
void trace(JSTracer* trc);
|
|
|
|
static bool hasUint(uint32_t u) { return u < INT_STATIC_LIMIT; }
|
|
|
|
JSAtom* getUint(uint32_t u) {
|
|
MOZ_ASSERT(hasUint(u));
|
|
return intStaticTable[u];
|
|
}
|
|
|
|
static bool hasInt(int32_t i) {
|
|
return uint32_t(i) < INT_STATIC_LIMIT;
|
|
}
|
|
|
|
JSAtom* getInt(int32_t i) {
|
|
MOZ_ASSERT(hasInt(i));
|
|
return getUint(uint32_t(i));
|
|
}
|
|
|
|
static bool hasUnit(char16_t c) { return c < UNIT_STATIC_LIMIT; }
|
|
|
|
JSAtom* getUnit(char16_t c) {
|
|
MOZ_ASSERT(hasUnit(c));
|
|
return unitStaticTable[c];
|
|
}
|
|
|
|
/* May not return atom, returns null on (reported) failure. */
|
|
inline JSLinearString* getUnitStringForElement(JSContext* cx, JSString* str, size_t index);
|
|
|
|
template <typename CharT>
|
|
static bool isStatic(const CharT* chars, size_t len);
|
|
static bool isStatic(JSAtom* atom);
|
|
|
|
/* Return null if no static atom exists for the given (chars, length). */
|
|
template <typename CharT>
|
|
JSAtom* lookup(const CharT* chars, size_t length) {
|
|
switch (length) {
|
|
case 1: {
|
|
char16_t c = chars[0];
|
|
if (c < UNIT_STATIC_LIMIT)
|
|
return getUnit(c);
|
|
return nullptr;
|
|
}
|
|
case 2:
|
|
if (fitsInSmallChar(chars[0]) && fitsInSmallChar(chars[1]))
|
|
return getLength2(chars[0], chars[1]);
|
|
return nullptr;
|
|
case 3:
|
|
/*
|
|
* Here we know that JSString::intStringTable covers only 256 (or at least
|
|
* not 1000 or more) chars. We rely on order here to resolve the unit vs.
|
|
* int string/length-2 string atom identity issue by giving priority to unit
|
|
* strings for "0" through "9" and length-2 strings for "10" through "99".
|
|
*/
|
|
static_assert(INT_STATIC_LIMIT <= 999,
|
|
"static int strings assumed below to be at most "
|
|
"three digits");
|
|
if ('1' <= chars[0] && chars[0] <= '9' &&
|
|
'0' <= chars[1] && chars[1] <= '9' &&
|
|
'0' <= chars[2] && chars[2] <= '9') {
|
|
int i = (chars[0] - '0') * 100 +
|
|
(chars[1] - '0') * 10 +
|
|
(chars[2] - '0');
|
|
|
|
if (unsigned(i) < INT_STATIC_LIMIT)
|
|
return getInt(i);
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
private:
|
|
typedef uint8_t SmallChar;
|
|
static const SmallChar INVALID_SMALL_CHAR = -1;
|
|
|
|
static bool fitsInSmallChar(char16_t c) {
|
|
return c < SMALL_CHAR_LIMIT && toSmallChar[c] != INVALID_SMALL_CHAR;
|
|
}
|
|
|
|
static const SmallChar toSmallChar[];
|
|
|
|
JSAtom* getLength2(char16_t c1, char16_t c2);
|
|
JSAtom* getLength2(uint32_t u) {
|
|
MOZ_ASSERT(u < 100);
|
|
return getLength2('0' + u / 10, '0' + u % 10);
|
|
}
|
|
};
|
|
|
|
/*
|
|
* Represents an atomized string which does not contain an index (that is, an
|
|
* unsigned 32-bit value). Thus for any PropertyName propname,
|
|
* ToString(ToUint32(propname)) never equals propname.
|
|
*
|
|
* To more concretely illustrate the utility of PropertyName, consider that it
|
|
* is used to partition, in a type-safe manner, the ways to refer to a
|
|
* property, as follows:
|
|
*
|
|
* - uint32_t indexes,
|
|
* - PropertyName strings which don't encode uint32_t indexes, and
|
|
* - jsspecial special properties (non-ES5 properties like object-valued
|
|
* jsids, JSID_EMPTY, JSID_VOID, and maybe in the future Harmony-proposed
|
|
* private names).
|
|
*/
|
|
class PropertyName : public JSAtom
|
|
{
|
|
private:
|
|
/* Vacuous and therefore unimplemented. */
|
|
PropertyName* asPropertyName() = delete;
|
|
};
|
|
|
|
static_assert(sizeof(PropertyName) == sizeof(JSString),
|
|
"string subclasses must be binary-compatible with JSString");
|
|
|
|
static MOZ_ALWAYS_INLINE jsid
|
|
NameToId(PropertyName* name)
|
|
{
|
|
return NON_INTEGER_ATOM_TO_JSID(name);
|
|
}
|
|
|
|
using PropertyNameVector = js::TraceableVector<PropertyName*>;
|
|
|
|
template <typename CharT>
|
|
void
|
|
CopyChars(CharT* dest, const JSLinearString& str);
|
|
|
|
/* GC-allocate a string descriptor for the given malloc-allocated chars. */
|
|
template <js::AllowGC allowGC, typename CharT>
|
|
extern JSFlatString*
|
|
NewString(js::ExclusiveContext* cx, CharT* chars, size_t length);
|
|
|
|
/* Like NewString, but doesn't try to deflate to Latin1. */
|
|
template <js::AllowGC allowGC, typename CharT>
|
|
extern JSFlatString*
|
|
NewStringDontDeflate(js::ExclusiveContext* cx, CharT* chars, size_t length);
|
|
|
|
extern JSLinearString*
|
|
NewDependentString(JSContext* cx, JSString* base, size_t start, size_t length);
|
|
|
|
/* Copy a counted string and GC-allocate a descriptor for it. */
|
|
template <js::AllowGC allowGC, typename CharT>
|
|
extern JSFlatString*
|
|
NewStringCopyN(js::ExclusiveContext* cx, const CharT* s, size_t n);
|
|
|
|
template <js::AllowGC allowGC>
|
|
inline JSFlatString*
|
|
NewStringCopyN(ExclusiveContext* cx, const char* s, size_t n)
|
|
{
|
|
return NewStringCopyN<allowGC>(cx, reinterpret_cast<const Latin1Char*>(s), n);
|
|
}
|
|
|
|
/* Like NewStringCopyN, but doesn't try to deflate to Latin1. */
|
|
template <js::AllowGC allowGC, typename CharT>
|
|
extern JSFlatString*
|
|
NewStringCopyNDontDeflate(js::ExclusiveContext* cx, const CharT* s, size_t n);
|
|
|
|
/* Copy a C string and GC-allocate a descriptor for it. */
|
|
template <js::AllowGC allowGC>
|
|
inline JSFlatString*
|
|
NewStringCopyZ(js::ExclusiveContext* cx, const char16_t* s)
|
|
{
|
|
return NewStringCopyN<allowGC>(cx, s, js_strlen(s));
|
|
}
|
|
|
|
template <js::AllowGC allowGC>
|
|
inline JSFlatString*
|
|
NewStringCopyZ(js::ExclusiveContext* cx, const char* s)
|
|
{
|
|
return NewStringCopyN<allowGC>(cx, s, strlen(s));
|
|
}
|
|
|
|
JSString*
|
|
NewMaybeExternalString(JSContext* cx, const char16_t* s, size_t n, const JSStringFinalizer* fin,
|
|
bool* isExternal);
|
|
|
|
JS_STATIC_ASSERT(sizeof(HashNumber) == 4);
|
|
|
|
} /* namespace js */
|
|
|
|
// Addon IDs are interned atoms which are never destroyed. This detail is
|
|
// not exposed outside the API.
|
|
class JSAddonId : public JSAtom
|
|
{};
|
|
|
|
MOZ_ALWAYS_INLINE bool
|
|
JSString::getChar(js::ExclusiveContext* cx, size_t index, char16_t* code)
|
|
{
|
|
MOZ_ASSERT(index < length());
|
|
|
|
/*
|
|
* Optimization for one level deep ropes.
|
|
* This is common for the following pattern:
|
|
*
|
|
* while() {
|
|
* text = text.substr(0, x) + "bla" + text.substr(x)
|
|
* test.charCodeAt(x + 1)
|
|
* }
|
|
*/
|
|
JSString* str;
|
|
if (isRope()) {
|
|
JSRope* rope = &asRope();
|
|
if (uint32_t(index) < rope->leftChild()->length()) {
|
|
str = rope->leftChild();
|
|
} else {
|
|
str = rope->rightChild();
|
|
index -= rope->leftChild()->length();
|
|
}
|
|
} else {
|
|
str = this;
|
|
}
|
|
|
|
if (!str->ensureLinear(cx))
|
|
return false;
|
|
|
|
*code = str->asLinear().latin1OrTwoByteChar(index);
|
|
return true;
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE JSLinearString*
|
|
JSString::ensureLinear(js::ExclusiveContext* cx)
|
|
{
|
|
return isLinear()
|
|
? &asLinear()
|
|
: asRope().flatten(cx);
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE JSFlatString*
|
|
JSString::ensureFlat(js::ExclusiveContext* cx)
|
|
{
|
|
return isFlat()
|
|
? &asFlat()
|
|
: isDependent()
|
|
? asDependent().undepend(cx)
|
|
: asRope().flatten(cx);
|
|
}
|
|
|
|
inline JSLinearString*
|
|
JSString::base() const
|
|
{
|
|
MOZ_ASSERT(hasBase());
|
|
MOZ_ASSERT(!d.s.u3.base->isInline());
|
|
return d.s.u3.base;
|
|
}
|
|
|
|
template<>
|
|
MOZ_ALWAYS_INLINE const char16_t*
|
|
JSLinearString::nonInlineChars(const JS::AutoCheckCannotGC& nogc) const
|
|
{
|
|
return nonInlineTwoByteChars(nogc);
|
|
}
|
|
|
|
template<>
|
|
MOZ_ALWAYS_INLINE const JS::Latin1Char*
|
|
JSLinearString::nonInlineChars(const JS::AutoCheckCannotGC& nogc) const
|
|
{
|
|
return nonInlineLatin1Chars(nogc);
|
|
}
|
|
|
|
template<>
|
|
MOZ_ALWAYS_INLINE const char16_t*
|
|
JSLinearString::chars(const JS::AutoCheckCannotGC& nogc) const
|
|
{
|
|
return rawTwoByteChars();
|
|
}
|
|
|
|
template<>
|
|
MOZ_ALWAYS_INLINE const JS::Latin1Char*
|
|
JSLinearString::chars(const JS::AutoCheckCannotGC& nogc) const
|
|
{
|
|
return rawLatin1Chars();
|
|
}
|
|
|
|
template <>
|
|
MOZ_ALWAYS_INLINE bool
|
|
JSRope::copyChars<JS::Latin1Char>(js::ExclusiveContext* cx,
|
|
js::ScopedJSFreePtr<JS::Latin1Char>& out) const
|
|
{
|
|
return copyLatin1Chars(cx, out);
|
|
}
|
|
|
|
template <>
|
|
MOZ_ALWAYS_INLINE bool
|
|
JSRope::copyChars<char16_t>(js::ExclusiveContext* cx, js::ScopedJSFreePtr<char16_t>& out) const
|
|
{
|
|
return copyTwoByteChars(cx, out);
|
|
}
|
|
|
|
template<>
|
|
MOZ_ALWAYS_INLINE bool
|
|
JSThinInlineString::lengthFits<JS::Latin1Char>(size_t length)
|
|
{
|
|
return length <= MAX_LENGTH_LATIN1;
|
|
}
|
|
|
|
template<>
|
|
MOZ_ALWAYS_INLINE bool
|
|
JSThinInlineString::lengthFits<char16_t>(size_t length)
|
|
{
|
|
return length <= MAX_LENGTH_TWO_BYTE;
|
|
}
|
|
|
|
template<>
|
|
MOZ_ALWAYS_INLINE bool
|
|
JSFatInlineString::lengthFits<JS::Latin1Char>(size_t length)
|
|
{
|
|
static_assert((INLINE_EXTENSION_CHARS_LATIN1 * sizeof(char)) % js::gc::CellSize == 0,
|
|
"fat inline strings' Latin1 characters don't exactly "
|
|
"fill subsequent cells and thus are wasteful");
|
|
static_assert(MAX_LENGTH_LATIN1 + 1 ==
|
|
(sizeof(JSFatInlineString) -
|
|
offsetof(JSFatInlineString, d.inlineStorageLatin1)) / sizeof(char),
|
|
"MAX_LENGTH_LATIN1 must be one less than inline Latin1 "
|
|
"storage count");
|
|
|
|
return length <= MAX_LENGTH_LATIN1;
|
|
}
|
|
|
|
template<>
|
|
MOZ_ALWAYS_INLINE bool
|
|
JSFatInlineString::lengthFits<char16_t>(size_t length)
|
|
{
|
|
static_assert((INLINE_EXTENSION_CHARS_TWO_BYTE * sizeof(char16_t)) % js::gc::CellSize == 0,
|
|
"fat inline strings' char16_t characters don't exactly "
|
|
"fill subsequent cells and thus are wasteful");
|
|
static_assert(MAX_LENGTH_TWO_BYTE + 1 ==
|
|
(sizeof(JSFatInlineString) -
|
|
offsetof(JSFatInlineString, d.inlineStorageTwoByte)) / sizeof(char16_t),
|
|
"MAX_LENGTH_TWO_BYTE must be one less than inline "
|
|
"char16_t storage count");
|
|
|
|
return length <= MAX_LENGTH_TWO_BYTE;
|
|
}
|
|
|
|
template<>
|
|
MOZ_ALWAYS_INLINE bool
|
|
JSInlineString::lengthFits<JS::Latin1Char>(size_t length)
|
|
{
|
|
// If it fits in a fat inline string, it fits in any inline string.
|
|
return JSFatInlineString::lengthFits<JS::Latin1Char>(length);
|
|
}
|
|
|
|
template<>
|
|
MOZ_ALWAYS_INLINE bool
|
|
JSInlineString::lengthFits<char16_t>(size_t length)
|
|
{
|
|
// If it fits in a fat inline string, it fits in any inline string.
|
|
return JSFatInlineString::lengthFits<char16_t>(length);
|
|
}
|
|
|
|
template<>
|
|
MOZ_ALWAYS_INLINE void
|
|
JSString::setNonInlineChars(const char16_t* chars)
|
|
{
|
|
d.s.u2.nonInlineCharsTwoByte = chars;
|
|
}
|
|
|
|
template<>
|
|
MOZ_ALWAYS_INLINE void
|
|
JSString::setNonInlineChars(const JS::Latin1Char* chars)
|
|
{
|
|
d.s.u2.nonInlineCharsLatin1 = chars;
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE const JS::Latin1Char*
|
|
JSLinearString::rawLatin1Chars() const
|
|
{
|
|
MOZ_ASSERT(JSString::isLinear());
|
|
MOZ_ASSERT(hasLatin1Chars());
|
|
return isInline() ? d.inlineStorageLatin1 : d.s.u2.nonInlineCharsLatin1;
|
|
}
|
|
|
|
MOZ_ALWAYS_INLINE const char16_t*
|
|
JSLinearString::rawTwoByteChars() const
|
|
{
|
|
MOZ_ASSERT(JSString::isLinear());
|
|
MOZ_ASSERT(hasTwoByteChars());
|
|
return isInline() ? d.inlineStorageTwoByte : d.s.u2.nonInlineCharsTwoByte;
|
|
}
|
|
|
|
inline js::PropertyName*
|
|
JSAtom::asPropertyName()
|
|
{
|
|
#ifdef DEBUG
|
|
uint32_t dummy;
|
|
MOZ_ASSERT(!isIndex(&dummy));
|
|
#endif
|
|
return static_cast<js::PropertyName*>(this);
|
|
}
|
|
|
|
#endif /* vm_String_h */
|