Loading...
Searching...
No Matches
v8-primitive.h
Go to the documentation of this file.
1// Copyright 2021 the V8 project authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#ifndef INCLUDE_V8_PRIMITIVE_H_
6#define INCLUDE_V8_PRIMITIVE_H_
7
8#include "v8-data.h" // NOLINT(build/include_directory)
9#include "v8-internal.h" // NOLINT(build/include_directory)
10#include "v8-local-handle.h" // NOLINT(build/include_directory)
11#include "v8-value.h" // NOLINT(build/include_directory)
12#include "v8config.h" // NOLINT(build/include_directory)
13
14namespace v8 {
15
16class Context;
17class Isolate;
18class String;
19
20namespace internal {
21class ExternalString;
22class ScopedExternalStringLock;
23class StringForwardingTable;
24} // namespace internal
25
29class V8_EXPORT Primitive : public Value {};
30
35class V8_EXPORT Boolean : public Primitive {
36 public:
37 bool Value() const;
38 V8_INLINE static Boolean* Cast(v8::Data* data) {
39#ifdef V8_ENABLE_CHECKS
40 CheckCast(data);
41#endif
42 return static_cast<Boolean*>(data);
43 }
44
45 V8_INLINE static Local<Boolean> New(Isolate* isolate, bool value);
46
47 private:
48 static void CheckCast(v8::Data* that);
49};
50
59 public:
60 static Local<PrimitiveArray> New(Isolate* isolate, int length);
61 int Length() const;
62 void Set(Isolate* isolate, int index, Local<Primitive> item);
63 Local<Primitive> Get(Isolate* isolate, int index);
64
66#ifdef V8_ENABLE_CHECKS
67 CheckCast(data);
68#endif
69 return reinterpret_cast<PrimitiveArray*>(data);
70 }
71
72 private:
73 static void CheckCast(Data* obj);
74};
75
79class V8_EXPORT Name : public Primitive {
80 public:
89
90 V8_INLINE static Name* Cast(Data* data) {
91#ifdef V8_ENABLE_CHECKS
92 CheckCast(data);
93#endif
94 return static_cast<Name*>(data);
95 }
96
97 private:
98 static void CheckCast(Data* that);
99};
100
107enum class NewStringType {
111 kNormal,
112
119};
120
124class V8_EXPORT String : public Name {
125 public:
126 static constexpr int kMaxLength =
127 internal::kApiSystemPointerSize == 4 ? (1 << 28) - 16 : (1 << 29) - 24;
128
129 enum Encoding {
130 UNKNOWN_ENCODING = 0x1,
131 TWO_BYTE_ENCODING = 0x0,
132 ONE_BYTE_ENCODING = 0x8
133 };
137 int Length() const;
138
143 size_t Utf8LengthV2(Isolate* isolate) const;
144
151 bool IsOneByte() const;
152
159
160 struct WriteFlags {
161 enum {
162 kNone = 0,
163 // Indicates that the output string should be null-terminated. In that
164 // case, the output buffer must include sufficient space for the
165 // additional null character.
166 kNullTerminate = 1,
167 // Used by WriteUtf8 to replace orphan surrogate code units with the
168 // unicode replacement character. Needs to be set to guarantee valid UTF-8
169 // output.
170 kReplaceInvalidUtf8 = 2
171 };
172 };
173
188 void WriteV2(Isolate* isolate, uint32_t offset, uint32_t length,
189 uint16_t* buffer, int flags = WriteFlags::kNone) const;
190 void WriteOneByteV2(Isolate* isolate, uint32_t offset, uint32_t length,
191 uint8_t* buffer, int flags = WriteFlags::kNone) const;
192
213 size_t WriteUtf8V2(Isolate* isolate, char* buffer, size_t capacity,
214 int flags = WriteFlags::kNone,
215 size_t* processed_characters_return = nullptr) const;
216
220 V8_INLINE static Local<String> Empty(Isolate* isolate);
221
225 bool IsExternal() const;
226
230 bool IsExternalTwoByte() const;
231
235 bool IsExternalOneByte() const;
236
242
244 public:
245 virtual ~ExternalStringResourceBase() = default;
246
252 virtual bool IsCacheable() const { return true; }
253
259 virtual void Unaccount(Isolate* isolate) {}
260
270 virtual size_t EstimateMemoryUsage() const {
271 return kDefaultMemoryEstimate;
272 }
273 static constexpr size_t kDefaultMemoryEstimate = static_cast<size_t>(-1);
274
276 public:
281 virtual void RecordSharedMemoryUsage(const void* location,
282 size_t size) = 0;
283 };
284
290 SharedMemoryUsageRecorder* recorder) const {}
291
292 // Disallow copying and assigning.
295
296 protected:
298
305 virtual void Dispose() { delete this; }
306
318 virtual void Lock() const {}
319
323 virtual void Unlock() const {}
324
325 private:
326 friend class internal::ExternalString;
327 friend class v8::String;
328 friend class internal::StringForwardingTable;
329 friend class internal::ScopedExternalStringLock;
330 };
331
339 public:
344 ~ExternalStringResource() override = default;
345
350 virtual const uint16_t* data() const = 0;
351
355 virtual size_t length() const = 0;
356
362 const uint16_t* cached_data() const {
363 CheckCachedDataInvariants();
364 return cached_data_;
365 }
366
372
373 protected:
375
376 private:
377 void CheckCachedDataInvariants() const;
378
379 const uint16_t* cached_data_ = nullptr;
380 };
381
394 public:
399 ~ExternalOneByteStringResource() override = default;
400
405 virtual const char* data() const = 0;
406
408 virtual size_t length() const = 0;
409
415 const char* cached_data() const {
416 CheckCachedDataInvariants();
417 return cached_data_;
418 }
419
425
426 protected:
428
429 private:
430 void CheckCachedDataInvariants() const;
431
432 const char* cached_data_ = nullptr;
433 };
434
440 V8_INLINE ExternalStringResourceBase* GetExternalStringResourceBase(
441 v8::Isolate* isolate, Encoding* encoding_out) const;
442 V8_INLINE ExternalStringResourceBase* GetExternalStringResourceBase(
443 Encoding* encoding_out) const;
444
449 V8_INLINE ExternalStringResource* GetExternalStringResource() const;
450
456
457 V8_INLINE static String* Cast(v8::Data* data) {
458#ifdef V8_ENABLE_CHECKS
459 CheckCast(data);
460#endif
461 return static_cast<String*>(data);
462 }
463
473 template <int N>
475 Isolate* isolate, const char (&literal)[N],
476 NewStringType type = NewStringType::kNormal) {
477 static_assert(N <= kMaxLength, "String is too long");
478 return NewFromUtf8Literal(isolate, literal, type, N - 1);
479 }
480
484 Isolate* isolate, const char* data,
485 NewStringType type = NewStringType::kNormal, int length = -1);
490 Isolate* isolate, const uint8_t* data,
491 NewStringType type = NewStringType::kNormal, int length = -1);
492
496 Isolate* isolate, const uint16_t* data,
497 NewStringType type = NewStringType::kNormal, int length = -1);
498
504 Local<String> right);
505
515 Isolate* isolate, ExternalStringResource* resource);
516
526 V8_DEPRECATE_SOON("Use the version with the isolate argument instead.")
527 bool MakeExternal(ExternalStringResource* resource);
528
538 bool MakeExternal(Isolate* isolate, ExternalStringResource* resource);
539
548 static V8_WARN_UNUSED_RESULT MaybeLocal<String> NewExternalOneByte(
549 Isolate* isolate, ExternalOneByteStringResource* resource);
550
560 V8_DEPRECATE_SOON("Use the version with the isolate argument instead.")
561 bool MakeExternal(ExternalOneByteStringResource* resource);
562
572 bool MakeExternal(Isolate* isolate, ExternalOneByteStringResource* resource);
573
578 bool CanMakeExternal(Encoding encoding) const;
579
583 bool StringEquals(Local<String> str) const;
584
596 public:
599 char* operator*() { return str_; }
600 const char* operator*() const { return str_; }
601 size_t length() const { return length_; }
602
603 // Disallow copying and assigning.
604 Utf8Value(const Utf8Value&) = delete;
605 void operator=(const Utf8Value&) = delete;
606
607 private:
608 char* str_;
609 size_t length_;
610 };
611
623 public:
625 "Prefer using String::ValueView if you can, or string->Write to a "
626 "buffer if you cannot.")
627 Value(Isolate* isolate, Local<v8::Value> obj);
629 uint16_t* operator*() { return str_; }
630 const uint16_t* operator*() const { return str_; }
631 uint32_t length() const { return length_; }
632
633 // Disallow copying and assigning.
634 Value(const Value&) = delete;
635 void operator=(const Value&) = delete;
636
637 private:
638 uint16_t* str_;
639 uint32_t length_;
640 };
641
653 public:
656 const uint8_t* data8() const {
657#if V8_ENABLE_CHECKS
658 CheckOneByte(true);
659#endif
660 return data8_;
661 }
662 const uint16_t* data16() const {
663#if V8_ENABLE_CHECKS
664 CheckOneByte(false);
665#endif
666 return data16_;
667 }
668 uint32_t length() const { return length_; }
669 bool is_one_byte() const { return is_one_byte_; }
670
671 // Disallow copying and assigning.
672 ValueView(const ValueView&) = delete;
673 void operator=(const ValueView&) = delete;
674
675 private:
676 void CheckOneByte(bool is_one_byte) const;
677
678 Local<v8::String> flat_str_;
679 union {
680 const uint8_t* data8_;
681 const uint16_t* data16_;
682 };
683 uint32_t length_;
684 bool is_one_byte_;
685 // Avoid exposing the internal DisallowGarbageCollection scope.
686 alignas(internal::Internals::
687 kDisallowGarbageCollectionAlign) char no_gc_debug_scope_
688 [internal::Internals::kDisallowGarbageCollectionSize];
689 };
690
691 private:
692 void VerifyExternalStringResourceBase(ExternalStringResourceBase* v,
693 Encoding encoding) const;
694 void VerifyExternalStringResource(ExternalStringResource* val) const;
695 ExternalStringResource* GetExternalStringResourceSlow() const;
696 ExternalStringResourceBase* GetExternalStringResourceBaseSlow(
697 String::Encoding* encoding_out) const;
698
699 static Local<v8::String> NewFromUtf8Literal(Isolate* isolate,
700 const char* literal,
701 NewStringType type, int length);
702
703 static void CheckCast(v8::Data* that);
704};
705
706// Zero-length string specialization (templated string size includes
707// terminator).
708template <>
710 Isolate* isolate, const char (&literal)[1], NewStringType type) {
711 return String::Empty(isolate);
712}
713
718 public:
719 virtual ~ExternalResourceVisitor() = default;
720 virtual void VisitExternalString(Local<String> string) {}
721};
722
726class V8_EXPORT Symbol : public Name {
727 public:
732
737 static Local<Symbol> New(Isolate* isolate,
738 Local<String> description = Local<String>());
739
748 static Local<Symbol> For(Isolate* isolate, Local<String> description);
749
754 static Local<Symbol> ForApi(Isolate* isolate, Local<String> description);
755
756 // Well-known symbols
770
771 V8_INLINE static Symbol* Cast(Data* data) {
772#ifdef V8_ENABLE_CHECKS
773 CheckCast(data);
774#endif
775 return static_cast<Symbol*>(data);
776 }
777
778 private:
779 Symbol();
780 static void CheckCast(Data* that);
781};
782
788 private:
789 Numeric();
790 static void CheckCast(v8::Data* that);
791};
792
796class V8_EXPORT Number : public Numeric {
797 public:
798 double Value() const;
799 static Local<Number> New(Isolate* isolate, double value);
800 template <typename Int>
801 requires(std::is_integral<Int>::value && !std::is_same<Int, bool>::value &&
802 std::is_signed_v<Int> && sizeof(Int) <= sizeof(int32_t))
803 V8_INLINE static Local<Number> New(Isolate* isolate, Int value) {
804 return NewFromInt32(isolate, value);
805 }
806 template <typename UInt>
807 requires(std::is_integral<UInt>::value &&
808 !std::is_same<UInt, bool>::value && std::is_unsigned_v<UInt> &&
809 sizeof(UInt) <= sizeof(uint32_t))
810 V8_INLINE static Local<Number> New(Isolate* isolate, UInt value) {
811 return NewFromUint32(isolate, value);
812 }
813 V8_INLINE static Number* Cast(v8::Data* data) {
814#ifdef V8_ENABLE_CHECKS
815 CheckCast(data);
816#endif
817 return static_cast<Number*>(data);
818 }
819
820 private:
821 Number();
822 static Local<Number> NewFromInt32(Isolate* isolate, int32_t value);
823 static Local<Number> NewFromUint32(Isolate* isolate, uint32_t value);
824 static void CheckCast(v8::Data* that);
825};
826
830class V8_EXPORT Integer : public Number {
831 public:
832 static Local<Integer> New(Isolate* isolate, int32_t value);
833 static Local<Integer> NewFromUnsigned(Isolate* isolate, uint32_t value);
834 int64_t Value() const;
836#ifdef V8_ENABLE_CHECKS
837 CheckCast(data);
838#endif
839 return static_cast<Integer*>(data);
840 }
841
842 private:
843 Integer();
844 static void CheckCast(v8::Data* that);
845};
846
850class V8_EXPORT Int32 : public Integer {
851 public:
852 int32_t Value() const;
853 V8_INLINE static Int32* Cast(v8::Data* data) {
854#ifdef V8_ENABLE_CHECKS
855 CheckCast(data);
856#endif
857 return static_cast<Int32*>(data);
858 }
859
860 private:
861 Int32();
862 static void CheckCast(v8::Data* that);
863};
864
868class V8_EXPORT Uint32 : public Integer {
869 public:
870 uint32_t Value() const;
871 V8_INLINE static Uint32* Cast(v8::Data* data) {
872#ifdef V8_ENABLE_CHECKS
873 CheckCast(data);
874#endif
875 return static_cast<Uint32*>(data);
876 }
877
878 private:
879 Uint32();
880 static void CheckCast(v8::Data* that);
881};
882
886class V8_EXPORT BigInt : public Numeric {
887 public:
888 static Local<BigInt> New(Isolate* isolate, int64_t value);
889 static Local<BigInt> NewFromUnsigned(Isolate* isolate, uint64_t value);
897 static MaybeLocal<BigInt> NewFromWords(Local<Context> context, int sign_bit,
898 int word_count, const uint64_t* words);
899
906 uint64_t Uint64Value(bool* lossless = nullptr) const;
907
913 int64_t Int64Value(bool* lossless = nullptr) const;
914
919 int WordCount() const;
920
929 void ToWordsArray(int* sign_bit, int* word_count, uint64_t* words) const;
930
931 V8_INLINE static BigInt* Cast(v8::Data* data) {
932#ifdef V8_ENABLE_CHECKS
933 CheckCast(data);
934#endif
935 return static_cast<BigInt*>(data);
936 }
937
938 private:
939 BigInt();
940 static void CheckCast(v8::Data* that);
941};
942
944 using S = internal::Address;
945 using I = internal::Internals;
946 I::CheckInitialized(isolate);
947 S* slot = I::GetRootSlot(isolate, I::kEmptyStringRootIndex);
948 return Local<String>::FromSlot(slot);
949}
950
952 using A = internal::Address;
953 using I = internal::Internals;
955
957 if (I::IsExternalTwoByteString(I::GetInstanceType(obj))) {
958 Isolate* isolate = I::GetCurrentIsolateForSandbox();
959 A value = I::ReadExternalPointerField<internal::kExternalStringResourceTag>(
960 isolate, obj, I::kStringResourceOffset);
961 result = reinterpret_cast<String::ExternalStringResource*>(value);
962 } else {
963 result = GetExternalStringResourceSlow();
964 }
965#ifdef V8_ENABLE_CHECKS
966 VerifyExternalStringResource(result);
967#endif
968 return result;
969}
970
972 v8::Isolate* isolate, String::Encoding* encoding_out) const {
973 using A = internal::Address;
974 using I = internal::Internals;
976 int type = I::GetInstanceType(obj) & I::kStringRepresentationAndEncodingMask;
977 *encoding_out = static_cast<Encoding>(type & I::kStringEncodingMask);
979 if (type == I::kExternalOneByteRepresentationTag ||
980 type == I::kExternalTwoByteRepresentationTag) {
981 A value = I::ReadExternalPointerField<internal::kExternalStringResourceTag>(
982 isolate, obj, I::kStringResourceOffset);
983 resource = reinterpret_cast<ExternalStringResourceBase*>(value);
984 } else {
985 resource = GetExternalStringResourceBaseSlow(encoding_out);
986 }
987#ifdef V8_ENABLE_CHECKS
988 VerifyExternalStringResourceBase(resource, *encoding_out);
989#endif
990 return resource;
991}
992
994 String::Encoding* encoding_out) const {
995 using A = internal::Address;
996 using I = internal::Internals;
998 int type = I::GetInstanceType(obj) & I::kStringRepresentationAndEncodingMask;
999 *encoding_out = static_cast<Encoding>(type & I::kStringEncodingMask);
1001 if (type == I::kExternalOneByteRepresentationTag ||
1002 type == I::kExternalTwoByteRepresentationTag) {
1003 Isolate* isolate = I::GetCurrentIsolateForSandbox();
1004 A value = I::ReadExternalPointerField<internal::kExternalStringResourceTag>(
1005 isolate, obj, I::kStringResourceOffset);
1006 resource = reinterpret_cast<ExternalStringResourceBase*>(value);
1007 } else {
1008 resource = GetExternalStringResourceBaseSlow(encoding_out);
1009 }
1010#ifdef V8_ENABLE_CHECKS
1011 VerifyExternalStringResourceBase(resource, *encoding_out);
1012#endif
1013 return resource;
1014}
1015
1016// --- Statics ---
1017
1019 using S = internal::Address;
1020 using I = internal::Internals;
1021 I::CheckInitialized(isolate);
1022 S* slot = I::GetRootSlot(isolate, I::kUndefinedValueRootIndex);
1023 return Local<Primitive>::FromSlot(slot);
1024}
1025
1027 using S = internal::Address;
1028 using I = internal::Internals;
1029 I::CheckInitialized(isolate);
1030 S* slot = I::GetRootSlot(isolate, I::kNullValueRootIndex);
1031 return Local<Primitive>::FromSlot(slot);
1032}
1033
1035 using S = internal::Address;
1036 using I = internal::Internals;
1037 I::CheckInitialized(isolate);
1038 S* slot = I::GetRootSlot(isolate, I::kTrueValueRootIndex);
1039 return Local<Boolean>::FromSlot(slot);
1040}
1041
1043 using S = internal::Address;
1044 using I = internal::Internals;
1045 I::CheckInitialized(isolate);
1046 S* slot = I::GetRootSlot(isolate, I::kFalseValueRootIndex);
1047 return Local<Boolean>::FromSlot(slot);
1048}
1049
1050Local<Boolean> Boolean::New(Isolate* isolate, bool value) {
1051 return value ? True(isolate) : False(isolate);
1052}
1053
1054} // namespace v8
1055
1056#endif // INCLUDE_V8_PRIMITIVE_H_
Definition: v8-primitive.h:886
uint64_t Uint64Value(bool *lossless=nullptr) const
static BigInt * Cast(v8::Data *data)
Definition: v8-primitive.h:931
static Local< BigInt > New(Isolate *isolate, int64_t value)
int64_t Int64Value(bool *lossless=nullptr) const
static MaybeLocal< BigInt > NewFromWords(Local< Context > context, int sign_bit, int word_count, const uint64_t *words)
int WordCount() const
static Local< BigInt > NewFromUnsigned(Isolate *isolate, uint64_t value)
void ToWordsArray(int *sign_bit, int *word_count, uint64_t *words) const
Definition: v8-primitive.h:35
bool Value() const
static Local< Boolean > New(Isolate *isolate, bool value)
Definition: v8-primitive.h:1050
static Boolean * Cast(v8::Data *data)
Definition: v8-primitive.h:38
Definition: v8-data.h:18
Definition: v8-primitive.h:717
virtual ~ExternalResourceVisitor()=default
virtual void VisitExternalString(Local< String > string)
Definition: v8-primitive.h:720
Definition: v8-primitive.h:850
static Int32 * Cast(v8::Data *data)
Definition: v8-primitive.h:853
int32_t Value() const
Definition: v8-primitive.h:830
static Integer * Cast(v8::Data *data)
Definition: v8-primitive.h:835
static Local< Integer > New(Isolate *isolate, int32_t value)
static Local< Integer > NewFromUnsigned(Isolate *isolate, uint32_t value)
int64_t Value() const
Definition: v8-isolate.h:290
Definition: v8-local-handle.h:366
Definition: v8-local-handle.h:734
Definition: v8-primitive.h:79
static Name * Cast(Data *data)
Definition: v8-primitive.h:90
int GetIdentityHash()
Definition: v8-primitive.h:796
static Local< Number > New(Isolate *isolate, double value)
static Local< Number > New(Isolate *isolate, Int value)
Definition: v8-primitive.h:803
static Local< Number > New(Isolate *isolate, UInt value)
Definition: v8-primitive.h:810
static Number * Cast(v8::Data *data)
Definition: v8-primitive.h:813
double Value() const
Definition: v8-primitive.h:787
Definition: v8-primitive.h:58
static Local< PrimitiveArray > New(Isolate *isolate, int length)
Local< Primitive > Get(Isolate *isolate, int index)
static PrimitiveArray * Cast(Data *data)
Definition: v8-primitive.h:65
int Length() const
void Set(Isolate *isolate, int index, Local< Primitive > item)
Definition: v8-primitive.h:29
Definition: v8-primitive.h:393
const char * cached_data() const
Definition: v8-primitive.h:415
~ExternalOneByteStringResource() override=default
virtual const char * data() const =0
virtual void RecordSharedMemoryUsage(const void *location, size_t size)=0
Definition: v8-primitive.h:243
void operator=(const ExternalStringResourceBase &)=delete
virtual void Unaccount(Isolate *isolate)
Definition: v8-primitive.h:259
ExternalStringResourceBase(const ExternalStringResourceBase &)=delete
virtual ~ExternalStringResourceBase()=default
virtual void Unlock() const
Definition: v8-primitive.h:323
virtual void EstimateSharedMemoryUsage(SharedMemoryUsageRecorder *recorder) const
Definition: v8-primitive.h:289
virtual bool IsCacheable() const
Definition: v8-primitive.h:252
virtual void Lock() const
Definition: v8-primitive.h:318
virtual size_t EstimateMemoryUsage() const
Definition: v8-primitive.h:270
virtual void Dispose()
Definition: v8-primitive.h:305
Definition: v8-primitive.h:338
virtual const uint16_t * data() const =0
const uint16_t * cached_data() const
Definition: v8-primitive.h:362
virtual size_t length() const =0
~ExternalStringResource() override=default
Definition: v8-primitive.h:595
char * operator*()
Definition: v8-primitive.h:599
Utf8Value(Isolate *isolate, Local< v8::Value > obj)
Utf8Value(const Utf8Value &)=delete
const char * operator*() const
Definition: v8-primitive.h:600
void operator=(const Utf8Value &)=delete
size_t length() const
Definition: v8-primitive.h:601
Definition: v8-primitive.h:652
bool is_one_byte() const
Definition: v8-primitive.h:669
const uint16_t * data16_
Definition: v8-primitive.h:681
void operator=(const ValueView &)=delete
const uint8_t * data8() const
Definition: v8-primitive.h:656
uint32_t length() const
Definition: v8-primitive.h:668
ValueView(const ValueView &)=delete
const uint16_t * data16() const
Definition: v8-primitive.h:662
ValueView(Isolate *isolate, Local< v8::String > str)
const uint8_t * data8_
Definition: v8-primitive.h:680
Definition: v8-primitive.h:622
const uint16_t * operator*() const
Definition: v8-primitive.h:630
uint32_t length() const
Definition: v8-primitive.h:631
Value(const Value &)=delete
void operator=(const Value &)=delete
Definition: v8-primitive.h:124
size_t Utf8LengthV2(Isolate *isolate) const
bool IsExternalTwoByte() const
bool IsExternal() const
static Local< String > Concat(Isolate *isolate, Local< String > left, Local< String > right)
bool IsExternalOneByte() const
bool ContainsOnlyOneByte() const
ExternalStringResourceBase * GetExternalStringResourceBase(v8::Isolate *isolate, Encoding *encoding_out) const
Definition: v8-primitive.h:971
Encoding
Definition: v8-primitive.h:129
void WriteOneByteV2(Isolate *isolate, uint32_t offset, uint32_t length, uint8_t *buffer, int flags=WriteFlags::kNone) const
Local< String > InternalizeString(Isolate *isolate)
static MaybeLocal< String > NewFromUtf8(Isolate *isolate, const char *data, NewStringType type=NewStringType::kNormal, int length=-1)
void WriteV2(Isolate *isolate, uint32_t offset, uint32_t length, uint16_t *buffer, int flags=WriteFlags::kNone) const
const ExternalOneByteStringResource * GetExternalOneByteStringResource() const
size_t WriteUtf8V2(Isolate *isolate, char *buffer, size_t capacity, int flags=WriteFlags::kNone, size_t *processed_characters_return=nullptr) const
static MaybeLocal< String > NewExternalTwoByte(Isolate *isolate, ExternalStringResource *resource)
bool IsOneByte() const
static String * Cast(v8::Data *data)
Definition: v8-primitive.h:457
static Local< String > Empty(Isolate *isolate)
Definition: v8-primitive.h:943
static MaybeLocal< String > NewFromTwoByte(Isolate *isolate, const uint16_t *data, NewStringType type=NewStringType::kNormal, int length=-1)
static Local< String > NewFromUtf8Literal(Isolate *isolate, const char(&literal)[N], NewStringType type=NewStringType::kNormal)
Definition: v8-primitive.h:474
ExternalStringResource * GetExternalStringResource() const
Definition: v8-primitive.h:951
int Length() const
Definition: v8-primitive.h:726
static Local< Symbol > GetDispose(Isolate *isolate)
static Local< Symbol > GetMatch(Isolate *isolate)
static Local< Symbol > GetIterator(Isolate *isolate)
static Symbol * Cast(Data *data)
Definition: v8-primitive.h:771
static Local< Symbol > ForApi(Isolate *isolate, Local< String > description)
static Local< Symbol > GetSearch(Isolate *isolate)
static Local< Symbol > GetToPrimitive(Isolate *isolate)
static Local< Symbol > GetAsyncIterator(Isolate *isolate)
static Local< Symbol > GetIsConcatSpreadable(Isolate *isolate)
static Local< Symbol > New(Isolate *isolate, Local< String > description=Local< String >())
static Local< Symbol > GetReplace(Isolate *isolate)
static Local< Symbol > GetAsyncDispose(Isolate *isolate)
static Local< Symbol > GetToStringTag(Isolate *isolate)
static Local< Symbol > GetSplit(Isolate *isolate)
static Local< Symbol > GetUnscopables(Isolate *isolate)
static Local< Symbol > For(Isolate *isolate, Local< String > description)
Local< Value > Description(Isolate *isolate) const
static Local< Symbol > GetHasInstance(Isolate *isolate)
Definition: v8-primitive.h:868
static Uint32 * Cast(v8::Data *data)
Definition: v8-primitive.h:871
uint32_t Value() const
Definition: v8-value.h:32
Definition: v8-internal.h:878
static Address ValueAsAddress(const T *value)
Definition: v8-internal.h:1723
uintptr_t Address
Definition: v8-internal.h:38
Definition: libplatform.h:15
Local< Primitive > Null(Isolate *isolate)
Definition: v8-primitive.h:1026
Local< Primitive > Undefined(Isolate *isolate)
Definition: v8-primitive.h:1018
Local< Boolean > False(Isolate *isolate)
Definition: v8-primitive.h:1042
Local< Boolean > True(Isolate *isolate)
Definition: v8-primitive.h:1034
NewStringType
Definition: v8-primitive.h:107
Definition: v8-primitive.h:160
#define V8_EXPORT
Definition: v8config.h:855
#define V8_INLINE
Definition: v8config.h:508
#define V8_DEPRECATE_SOON(message)
Definition: v8config.h:622
#define V8_WARN_UNUSED_RESULT
Definition: v8config.h:679