22 #include <type_traits>
52 class ImplementationUtilities;
63 class ObjectOperationDescriptor;
70 class RawOperationDescriptor;
87 template <
class T>
class Local;
90 template <
class T>
class Eternal;
91 template<
class T>
class NonCopyablePersistentTraits;
93 template <
class T,
class M = NonCopyablePersistentTraits<T> >
100 template <
class K,
class V,
class T>
102 template <
class K,
class V,
class T>
105 template<
class T,
class P>
class WeakCallbackObject;
113 class CallHandlerHelper;
119 class DeferredHandles;
122 class ExternalString;
124 class LocalEmbedderHeapTracer;
125 class MicrotaskQueue;
126 struct ScriptStreamingData;
128 class PropertyCallbackArguments;
129 class FunctionCallbackArguments;
131 class ScopedExternalStringLock;
132 class ThreadLocalTop;
136 class StreamingDecoder;
142 class ConsoleCallArguments;
147 #define TYPE_CHECK(T, S)
149 *(static_cast<T* volatile*>(0
)) = static_cast<S*>(0
);
189 : val_(
reinterpret_cast<T*>(*that)) {
222 if (a ==
nullptr)
return b ==
nullptr;
223 if (b ==
nullptr)
return false;
231 if (a ==
nullptr)
return b ==
nullptr;
232 if (b ==
nullptr)
return false;
244 return !operator==(that);
249 return !operator==(that);
258 #ifdef V8_ENABLE_CHECKS
261 if (that.IsEmpty())
return Local<T>();
263 return Local<T>(T::Cast(*that));
273 return Local<S>::Cast(*
this);
291 template<
class F>
friend class Local;
308 template <
class F1,
class F2,
class F3>
316 explicit V8_INLINE Local(T* that) : val_(that) {}
322 #if !defined(V8_IMMINENT_DEPRECATION_WARNINGS)
345 : val_(
reinterpret_cast<T*>(*that)) {
357 out->val_ =
IsEmpty() ?
nullptr :
this->val_;
389 Set(isolate, handle);
401 static const int kInternalFieldsInWeakCallback = 2;
402 static const int kEmbedderFieldsInWeakCallback = 2;
404 template <
typename T>
410 void* embedder_fields[kEmbedderFieldsInWeakCallback],
412 : isolate_(isolate), parameter_(parameter), callback_(callback) {
413 for (
int i = 0; i < kEmbedderFieldsInWeakCallback; ++i) {
414 embedder_fields_[i] = embedder_fields[i];
434 void* embedder_fields_[kEmbedderFieldsInWeakCallback];
483 return Local<T>::New(isolate, *
this);
490 if (a ==
nullptr)
return b ==
nullptr;
491 if (b ==
nullptr)
return false;
499 if (a ==
nullptr)
return b ==
nullptr;
500 if (b ==
nullptr)
return false;
506 return !operator==(that);
511 return !operator==(that);
521 template <
typename P>
569 template<
class F>
friend class Local;
575 template <
class F1,
class F2,
class F3>
580 explicit V8_INLINE PersistentBase(T* val) : val_(val) {}
594 class NonCopyablePersistentTraits {
598 template<
class S,
class M>
618 template<
class S,
class M>
655 template <
class S,
class M2>
669 template <
class S,
class M2>
677 template <
class S,
class M2>
688 if (M::kResetInDestructor)
this->Reset();
694 #ifdef V8_ENABLE_CHECKS
697 if (!that.IsEmpty()) T::Cast(*that);
711 template<
class F>
friend class Local;
716 V8_INLINE T* operator*()
const {
return this->val_; }
717 template<
class S,
class M2>
786 V8_INLINE T* operator*()
const {
return this->val_; }
797 template <
typename T>
825 template <
typename T>
841 : val_(New(isolate, *that, &val_)) {
850 *
this = std::move(other);
856 template <
typename S>
859 *
this = std::move(other);
873 template <
typename S>
911 bool IsEmpty()
const {
return val_ ==
nullptr; }
941 if (a ==
nullptr)
return b ==
nullptr;
942 if (b ==
nullptr)
return false;
950 if (a ==
nullptr)
return b ==
nullptr;
951 if (b ==
nullptr)
return false;
957 return !operator==(that);
962 return !operator==(that);
991 struct WrappedForDestruction {
994 explicit WrappedForDestruction(T* val) : value(val) {}
995 ~WrappedForDestruction();
996 operator T*()
const {
return value; }
997 T* operator*()
const {
return value; }
998 T* operator->()
const {
return value; }
999 WrappedForDestruction& operator=(
const WrappedForDestruction& other) {
1000 value = other.value;
1003 WrappedForDestruction& operator=(T* val) {
1011 T* operator*()
const {
return this->val_; }
1013 typename std::conditional<
1015 WrappedForDestruction, T*>::type val_{
nullptr};
1018 template <
typename F>
1021 template <
typename F>
1051 return reinterpret_cast<
Isolate*>(isolate_);
1068 void* operator
new(size_t size);
1069 void* operator
new[](size_t size);
1070 void operator
delete(
void*, size_t);
1071 void operator
delete[](
void*, size_t);
1104 return Local<T>(
reinterpret_cast<T*>(slot));
1109 return Escape(value.FromMaybe(
Local<T>()));
1118 void* operator
new(size_t size);
1119 void* operator
new[](size_t size);
1120 void operator
delete(
void*, size_t);
1121 void operator
delete[](
void*, size_t);
1143 void* operator
new(size_t size);
1144 void* operator
new[](size_t size);
1145 void operator
delete(
void*, size_t);
1146 void operator
delete[](
void*, size_t);
1150 int prev_sealed_level_;
1208 bool is_opaque =
false,
bool is_wasm =
false,
1209 bool is_module =
false)
1210 : flags_((is_shared_cross_origin ? kIsSharedCrossOrigin : 0) |
1211 (is_wasm ? kIsWasm : 0) | (is_opaque ? kIsOpaque : 0) |
1212 (is_module ? kIsModule : 0)) {}
1215 (kIsSharedCrossOrigin | kIsOpaque | kIsWasm | kIsModule)) {}
1218 return (flags_ & kIsSharedCrossOrigin) != 0;
1220 bool IsOpaque()
const {
return (flags_ & kIsOpaque) != 0; }
1221 bool IsWasm()
const {
return (flags_ & kIsWasm) != 0; }
1222 bool IsModule()
const {
return (flags_ & kIsModule) != 0; }
1228 kIsSharedCrossOrigin = 1,
1318 : line_number_(line_number), column_number_(column_number) {}
1621 "This class takes ownership of source_stream, so use the constructor "
1622 "taking a unique_ptr to make these semantics clearer",
1635 std::unique_ptr<
internal::ScriptStreamingData> impl_;
1649 explicit ScriptStreamingTask(
internal::ScriptStreamingData* data)
1652 internal::ScriptStreamingData* data_;
1786 Local<
String> arguments[], size_t context_extension_count,
2155 size_t* actual_size);
2221 PrivateData* private_;
2246 Isolate* isolate, uint32_t transfer_id);
2253 Isolate* isolate, uint32_t clone_id);
2323 PrivateData* private_;
2661 V8_INLINE bool QuickIsUndefined()
const;
2663 V8_INLINE bool QuickIsNullOrUndefined()
const;
2665 bool FullIsUndefined()
const;
2666 bool FullIsNull()
const;
2667 bool FullIsString()
const;
2688 static void CheckCast(
v8::
Value* obj);
2709 static void CheckCast(
Value* obj);
2809 int Write(
Isolate* isolate, uint16_t* buffer,
int start = 0,
int length = -1,
2813 int length = -1,
int options =
NO_OPTIONS)
const;
2816 int* nchars_ref =
nullptr,
int options =
NO_OPTIONS)
const;
2901 virtual const uint16_t*
data()
const = 0;
2931 virtual const char*
data()
const = 0;
2963 Isolate* isolate,
const char* data,
2969 Isolate* isolate,
const uint8_t* data,
2975 Isolate* isolate,
const uint16_t* data,
3094 static void CheckCast(
v8::
Value* obj);
3146 static void CheckCast(
Value* obj);
3184 static void CheckCast(
Data* that);
3198 static void CheckCast(
v8::
Value* obj);
3213 static void CheckCast(
v8::
Value* obj);
3227 static void CheckCast(
v8::
Value* obj);
3241 static void CheckCast(
v8::
Value* obj);
3259 int word_count,
const uint64_t* words);
3296 static void CheckCast(
v8::
Value* obj);
3848 static void CheckCast(
Value* obj);
3849 Local<
Value> SlowGetInternalField(
int index);
3850 void* SlowGetAlignedPointerFromInternalField(
int index);
3876 static void CheckCast(
Value* obj);
3912 static void CheckCast(
Value* obj);
3944 static void CheckCast(
Value* obj);
3948 template<
typename T>
3952 : value_(that.value_) {
3956 template <
typename S>
3958 template <
typename S>
3960 template <
typename S>
3975 template <
typename S>
3987 template <
class F,
class G,
class H>
4002 template<
typename T>
4038 friend class debug::ConsoleCallArguments;
4058 template<
typename T>
4150 friend class MacroAssembler;
4257 static void CheckCast(
Value* obj);
4260 #ifndef V8_PROMISE_INTERNAL_FIELD_COUNT
4262 #define V8_PROMISE_INTERNAL_FIELD_COUNT 0
4303 static void CheckCast(
Value* obj);
4350 static void CheckCast(
Value* obj);
4423 PrivateData* private_;
4448 static void CheckCast(
Value* obj);
4461 template <
typename T>
4467 constexpr MemorySpan(T* data, size_t size) : data_(data), size_(size) {}
4470 constexpr T*
data()
const {
return data_; }
4472 constexpr size_t
size()
const {
return size_; }
4506 explicit CompiledWasmModule(std::shared_ptr<
internal::
wasm::NativeModule>);
4509 const std::shared_ptr<
internal::
wasm::NativeModule> native_module_;
4521 class TransferrableModule
final {
4526 TransferrableModule&
operator=(TransferrableModule&& src) =
default;
4527 TransferrableModule&
operator=(
const TransferrableModule& src) =
delete;
4530 typedef std::shared_ptr<
internal::
wasm::NativeModule> SharedModule;
4532 explicit TransferrableModule(SharedModule shared_module)
4533 : shared_module_(std::move(shared_module)) {}
4535 : serialized_(std::move(serialized)), wire_bytes_(std::move(bytes)) {}
4537 SharedModule shared_module_;
4554 Isolate* isolate,
const TransferrableModule&);
4576 const uint8_t* start,
4583 static void CheckCast(
Value* obj);
4594 class WasmStreamingImpl;
4657 std::unique_ptr<WasmStreamingImpl> impl_;