35 #if defined(BUILDING_V8_SHARED) && defined(USING_V8_SHARED)
36 #error both BUILDING_V8_SHARED and USING_V8_SHARED are set - please check the
37 build configuration to ensure that at most one of these is set
40 #ifdef BUILDING_V8_SHARED
41 # define V8_EXPORT __declspec(dllexport)
43 # define V8_EXPORT __declspec(dllimport)
51 #if V8_HAS_ATTRIBUTE_VISIBILITY
&& defined(V8_SHARED)
52 # ifdef BUILDING_V8_SHARED
53 # define V8_EXPORT __attribute__ ((visibility("default")))
80 class ImplementationUtilities;
90 class ObjectOperationDescriptor;
95 class RawOperationDescriptor;
109 template <
class T>
class Local;
112 template <
class T>
class Eternal;
113 template<
class T>
class NonCopyablePersistentTraits;
116 class M = NonCopyablePersistentTraits<T> >
class Persistent;
120 template <
class K,
class V,
class T>
122 template <
class K,
class V,
class T>
125 template<
class T,
class P>
class WeakCallbackObject;
134 class CallHandlerHelper;
144 struct StreamedSource;
146 class PropertyCallbackArguments;
147 class FunctionCallbackArguments;
161 return data_ == other.data_;
165 return data_ != other.data_;
169 return data_ < other.data_;
178 #define TYPE_CHECK(T, S)
180 *(static_cast<T* volatile*>(0
)) = static_cast<S*>(0
);
215 : val_(
reinterpret_cast<T*>(*that)) {
248 if (a == 0)
return b == 0;
249 if (b == 0)
return false;
257 if (a == 0)
return b == 0;
258 if (b == 0)
return false;
270 return !operator==(that);
275 return !operator==(that);
279 #ifdef V8_ENABLE_CHECKS
282 if (that.IsEmpty())
return Local<T>();
284 return Local<T>(T::Cast(*that));
289 return Local<S>::Cast(*
this);
306 template<
class F>
friend class Local;
321 template <
class F1,
class F2,
class F3>
333 #if !defined(V8_IMMINENT_DEPRECATION_WARNINGS)
356 : val_(
reinterpret_cast<T*>(*that)) {
364 out->val_ =
IsEmpty() ?
nullptr :
this->val_;
387 Set(isolate, handle);
395 static const int kInitialValue = -1;
400 static const int kInternalFieldsInWeakCallback = 2;
403 template <
typename T>
409 void* internal_fields[kInternalFieldsInWeakCallback],
411 : isolate_(isolate), parameter_(parameter), callback_(callback) {
412 for (
int i = 0; i < kInternalFieldsInWeakCallback; ++i) {
413 internal_fields_[i] = internal_fields[i];
422 void* GetInternalField1()
const) {
423 return internal_fields_[0];
426 void* GetInternalField2()
const) {
427 return internal_fields_[1];
444 void* internal_fields_[kInternalFieldsInWeakCallback];
448 template <
class T,
class P>
454 : isolate_(isolate), parameter_(parameter), handle_(handle) {}
513 return Local<T>::New(isolate, *
this);
520 if (a == NULL)
return b == NULL;
521 if (b == NULL)
return false;
529 if (a == NULL)
return b == NULL;
530 if (b == NULL)
return false;
536 return !operator==(that);
541 return !operator==(that);
551 template <
typename P>
553 "use WeakCallbackInfo version",
557 template <
typename S,
typename P>
559 "use WeakCallbackInfo version",
560 void SetWeak(P* parameter,
569 template <
typename P>
572 void SetPhantom(P* parameter,
574 int internal_field_index1 = -1,
575 int internal_field_index2 = -1));
577 template <
typename P>
629 template<
class F>
friend class Local;
635 template <
class F1,
class F2,
class F3>
640 explicit V8_INLINE PersistentBase(T* val) : val_(val) {}
656 class NonCopyablePersistentTraits {
660 template<
class S,
class M>
680 template<
class S,
class M>
717 template <
class S,
class M2>
731 template <
class S,
class M2>
739 template <
class S,
class M2>
750 if (M::kResetInDestructor)
this->Reset();
756 #ifdef V8_ENABLE_CHECKS
759 if (!that.IsEmpty()) T::Cast(*that);
761 return reinterpret_cast<
Persistent<T>&>(that);
772 template<
class F>
friend class Local;
777 V8_INLINE T* operator*()
const {
return this->val_; }
778 template<
class S,
class M2>
819 other.val_ =
nullptr;
830 this->val_ = rhs.val_;
848 Global(
const Global&) =
delete;
849 void operator=(
const Global&) =
delete;
850 V8_INLINE T* operator*()
const {
return this->val_; }
885 return reinterpret_cast<
Isolate*>(isolate_);
905 void* operator
new(size_t size);
906 void operator
delete(
void*, size_t);
913 template<
class F>
friend class Local;
938 Escape(
reinterpret_cast<
internal::Object**>(*value));
939 return Local<T>(
reinterpret_cast<T*>(slot));
949 void* operator
new(size_t size);
950 void operator
delete(
void*, size_t);
965 void* operator
new(size_t size);
966 void operator
delete(
void*, size_t);
992 bool is_shared_cross_origin =
false,
993 bool is_opaque =
false)
994 : flags_((is_embedder_debug_script ? kIsEmbedderDebugScript : 0) |
995 (is_shared_cross_origin ? kIsSharedCrossOrigin : 0) |
996 (is_opaque ? kIsOpaque : 0)) {}
999 (kIsEmbedderDebugScript | kIsSharedCrossOrigin | kIsOpaque)) {}
1001 return (flags_ & kIsEmbedderDebugScript) != 0;
1004 return (flags_ & kIsSharedCrossOrigin) != 0;
1006 bool IsOpaque()
const {
return (flags_ & kIsOpaque) != 0; }
1011 kIsEmbedderDebugScript = 1,
1012 kIsSharedCrossOrigin = 1 << 1,
1094 "Use maybe version",
1327 "Use maybe version",
1357 "Use maybe version",
1414 size_t context_extension_count,
1418 Local<
String> arguments[], size_t context_extension_count,
2022 V8_INLINE bool QuickIsUndefined()
const;
2025 bool FullIsUndefined()
const;
2026 bool FullIsNull()
const;
2027 bool FullIsString()
const;
2048 static void CheckCast(
v8::
Value* obj);
2068 static void CheckCast(
v8::
Value* obj);
2160 int* nchars_ref = NULL,
2219 virtual const uint16_t*
data()
const = 0;
2249 virtual const char*
data()
const = 0;
2286 "Use maybe version",
2299 "Use maybe version",
2312 "Use maybe version",
2338 "Use maybe version",
2364 "Use maybe version",
2427 Value(
const Value&);
2428 void operator=(
const Value&);
2435 static void CheckCast(
v8::
Value* obj);
2473 static void CheckCast(
v8::
Value* obj);
2487 static void CheckCast(
v8::
Value* obj);
2502 static void CheckCast(
v8::
Value* obj);
2516 static void CheckCast(
v8::
Value* obj);
2530 static void CheckCast(
v8::
Value* obj);
2592 bool Set(uint32_t index,
Local<
Value> value));
2805 bool HasRealIndexedProperty(uint32_t index));
2809 bool HasRealNamedCallbackProperty(
Local<
String> key));
2818 "Use maybe version",
2829 "Use maybe version",
2936 static void CheckCast(
Value* obj);
2937 Local<
Value> SlowGetInternalField(
int index);
2938 void* SlowGetAlignedPointerFromInternalField(
int index);
2967 static void CheckCast(
Value* obj);
3005 "Use mutation methods instead",
3012 static void CheckCast(
Value* obj);
3045 "Use mutation methods instead",
3052 static void CheckCast(
Value* obj);
3056 template<
typename T>
3060 : value_(that.value_) {
3064 template <
typename S>
3067 template <
typename S>
3069 template <
typename S>
3084 template <
typename S>
3091 template <
class F,
class G,
class H>
3106 template<
typename T>
3135 bool is_construct_call);
3147 template<
typename T>
3159 friend class MacroAssembler;
3191 "Use maybe version",
3264 static void CheckCast(
Value* obj);
3305 static void CheckCast(
Value* obj);
3339 static void CheckCast(
Value* obj);
3343 #ifndef V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT
3345 #define V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT 2
3384 virtual void Free(
void* data, size_t length) = 0;
3401 void*
Data()
const {
return data_; }
3406 size_t byte_length_;
3432 Isolate* isolate,
void* data, size_t byte_length,
3483 static void CheckCast(
Value* obj);
3487 #ifndef V8_ARRAY_BUFFER_VIEW_INTERNAL_FIELD_COUNT
3489 #define V8_ARRAY_BUFFER_VIEW_INTERNAL_FIELD_COUNT 2
3538 static void CheckCast(
Value* obj);
3559 static void CheckCast(
Value* obj);
3570 size_t byte_offset, size_t length);
3572 size_t byte_offset, size_t length);
3577 static void CheckCast(
Value* obj);
3588 size_t byte_offset, size_t length);
3595 Uint8ClampedArray();
3596 static void CheckCast(
Value* obj);
3606 size_t byte_offset, size_t length);
3608 size_t byte_offset, size_t length);
3613 static void CheckCast(
Value* obj);
3624 size_t byte_offset, size_t length);
3626 size_t byte_offset, size_t length);
3631 static void CheckCast(
Value* obj);
3642 size_t byte_offset, size_t length);
3644 size_t byte_offset, size_t length);
3649 static void CheckCast(
Value* obj);
3660 size_t byte_offset, size_t length);
3662 size_t byte_offset, size_t length);
3667 static void CheckCast(
Value* obj);
3678 size_t byte_offset, size_t length);
3680 size_t byte_offset, size_t length);
3685 static void CheckCast(
Value* obj);
3696 size_t byte_offset, size_t length);
3698 size_t byte_offset, size_t length);
3703 static void CheckCast(
Value* obj);
3714 size_t byte_offset, size_t length);
3716 size_t byte_offset, size_t length);
3721 static void CheckCast(
Value* obj);
3732 size_t byte_offset, size_t length);
3734 size_t byte_offset, size_t length);
3739 static void CheckCast(
Value* obj);
3764 void*
Data()
const {
return data_; }
3769 size_t byte_length_;
3795 Isolate* isolate,
void* data, size_t byte_length,
3837 SharedArrayBuffer();
3838 static void CheckCast(
Value* obj);
3875 static void CheckCast(
v8::
Value* obj);
3891 static void CheckCast(
v8::
Value* obj);
3907 static void CheckCast(
v8::
Value* obj);
3923 static void CheckCast(
v8::
Value* obj);
3941 static void CheckCast(
v8::
Value* obj);
3992 static void CheckCast(
v8::
Value* obj);
4006 static void CheckCast(
v8::
Value* obj);
4616 deleter
, enumerator
, data
));
4694 AccessorSignature();
4720 : data_(data), length_(length) {}
4721 const char*
data()
const {
return data_; }
4737 const char* source = 0,
4739 const char** deps = 0,
4740 int source_length = -1);
4747 const char*
name()
const {
return name_; }
4758 size_t source_length_;
4804 uint64_t virtual_memory_limit);
4817 code_range_size_ = value;
4821 int max_semi_space_size_;
4822 int max_old_space_size_;
4823 int max_executable_size_;
4824 uint32_t* stack_limit_;
4825 size_t code_range_size_;
4914 : promise_(promise),
4917 stack_trace_(stack_trace) {}
4977 typedef void (*GCPrologueCallback)(
GCType type,
4980 typedef void (*GCEpilogueCallback)(
GCType type,
5004 size_t total_heap_size_;
5005 size_t total_heap_size_executable_;
5006 size_t total_physical_size_;
5007 size_t total_available_size_;
5008 size_t used_heap_size_;
5009 size_t heap_size_limit_;
5026 const char* space_name_;
5028 size_t space_used_size_;
5029 size_t space_available_size_;
5030 size_t physical_space_size_;
5045 const char* object_type_;
5046 const char* object_sub_type_;
5047 size_t object_count_;
5048 size_t object_size_;
5069 uintptr_t return_addr_location);
5170 uint16_t class_id) {}
5262 Scope(
const Scope&);
5297 void* internal_throws_;
5298 void* internal_assert_;
5470 size_t frames_limit,
SampleInfo* sample_info);
5555 template<
typename T,
typename S>
5559 typedef void (*GCPrologueCallback)(
Isolate* isolate,
5563 typedef void (*GCEpilogueCallback)(
Isolate* isolate,
5753 bool IdleNotification(
int idle_time_in_ms));
5864 bool capture,
int frame_limit = 10,
5902 template <
class K,
class V,
class Traits>
5909 void* operator
new(size_t size);
5910 void operator
delete(
void*, size_t);
5915 void CollectAllGarbage(
const char* gc_reason);
5945 typedef uintptr_t (*ReturnAddressLocationResolver)(
5946 uintptr_t return_addr_location);
5956 "Use isolate version",
5964 "Use isolate version",
void SetAllowCodeGenerationFromStringsCallback(
6008 "Use isolate version",
6016 "Use isolate version",
void RemoveMessageListeners(
MessageCallback that));
6023 "Use isolate version",
6024 void SetCaptureStackTraceForUncaughtExceptions(
6025 bool capture,
int frame_limit = 10,
6045 "Use isolate version",
6059 "Use isolate version",
6060 void AddGCPrologueCallback(
GCCallback callback,
6068 "Use isolate version",
6069 void RemoveGCPrologueCallback(
GCCallback callback));
6082 "Use isolate version",
6083 void AddGCEpilogueCallback(
GCCallback callback,
6091 "Use isolate version",
6092 void RemoveGCEpilogueCallback(
GCCallback callback));
6099 "Use isolate version",
6108 "Use isolate version",
6128 ReturnAddressLocationResolver return_address_resolver);
6140 void TerminateExecution(
Isolate* isolate));
6153 "Use isolate version",
6154 bool IsExecutionTerminating(
Isolate* isolate = NULL));
6173 "Use isolate version",
void CancelTerminateExecution(
Isolate* isolate));
6192 "Use isoalte version",
6200 "Use isolate version",
6208 "Use isolate version",
6209 void VisitHandlesWithClassIds(
Isolate* isolate,
6220 "Use isolate version",
6221 void VisitHandlesForPartialDependence(
Isolate* isolate,
6251 const char* snapshot_blob);
6270 static void DisposeGlobal(
internal::Object** global_handle);
6272 static void MakeWeak(
internal::Object** global_handle,
void* data,
6273 WeakCallback weak_callback);
6274 static void MakeWeak(
internal::Object** global_handle,
void* data,
6277 static void MakeWeak(
internal::Object** global_handle,
void* data,
6279 int internal_field_index1,
6281 int internal_field_index2,
6283 static void* ClearWeak(
internal::Object** global_handle);
6284 static void Eternalize(
Isolate* isolate,
6289 static void FromJustIsNothing();
6290 static void ToLocalEmpty();
6291 static void InternalFieldOutOfBounds(
int index);
6329 return has_value ? value : default_value;
6333 return (
IsJust() == other.IsJust()) &&
6342 Maybe() : has_value(
false) {}
6343 explicit Maybe(
const T& t) : has_value(
true), value(t) {}
6495 if (handler == NULL)
return NULL;
6496 return handler->js_stack_comparable_address_;
6500 void ResetInternal();
6505 void* operator
new(size_t size);
6506 void operator
delete(
void*, size_t);
6512 void* js_stack_comparable_address_;
6513 bool is_verbose_ : 1;
6514 bool can_continue_ : 1;
6515 bool capture_message_ : 1;
6517 bool has_terminated_ : 1;
6533 : name_count_(name_count), names_(names) { }
6535 const char**
begin()
const {
return &names_[0]; }
6536 const char**
end()
const {
return &names_[name_count_]; }
6539 const int name_count_;
6540 const char** names_;
6721 void* SlowGetAlignedPointerFromEmbedderData(
int index);
6810 void Initialize(
Isolate* isolate);
6837 void Initialize(
Isolate* isolate);
6845 void operator=(
const Locker&);
6868 template <size_t ptr_size>
struct SmiTagging;
6870 template<
int kSmiShiftSize>
6873 uintptr_t tagged_value =
6874 (
static_cast<uintptr_t>(value) << smi_shift_bits) |
kSmiTag;
6875 return reinterpret_cast<
internal::Object*>(tagged_value);
6879 template <>
struct SmiTagging<4> {
6886 return static_cast<
int>(
reinterpret_cast<intptr_t>(value)) >> shift_bits;
6903 return static_cast<uintptr_t>(value + 0x40000000U) < 0x80000000U;
6908 template <>
struct SmiTagging<8> {
6915 return static_cast<
int>(
reinterpret_cast<intptr_t>(value) >> shift_bits);
6922 return (value ==
static_cast<int32_t>(value));
6996 #ifdef V8_ENABLE_CHECKS
6997 CheckInitializedImpl(isolate);
7038 return *addr &
static_cast<uint8_t>(1U << shift);
7042 bool value,
int shift) {
7044 uint8_t mask =
static_cast<uint8_t>(1U << shift);
7045 *addr =
static_cast<uint8_t>((*addr & ~mask) | (value << shift));
7062 uint8_t *addr =
reinterpret_cast<uint8_t *>(isolate) +
7064 *
reinterpret_cast<
void**>(addr) = data;
7069 const uint8_t* addr =
reinterpret_cast<
const uint8_t*>(isolate) +
7071 return *
reinterpret_cast<
void*
const*>(addr);
7080 template <
typename T>
7082 const uint8_t* addr =
7084 return *
reinterpret_cast<
const T*>(addr);
7087 template <
typename T>
7091 O* ctx = *
reinterpret_cast<O*
const*>(context);
7097 return I::ReadField<T>(embedder_data, value_offset);
7106 return New(isolate, that.val_);
7111 return New(isolate, that.val_);
7117 if (that == NULL)
return Local<T>();
7121 reinterpret_cast<
internal::Isolate*>(isolate)
, *p
)));
7129 V8::Eternalize(isolate,
reinterpret_cast<
Value*>(*handle), &
this->index_);
7135 return Local<T>(
reinterpret_cast<T*>(
*V8::GetEternal(isolate, index_)));
7142 return Local<T>(val_);
7148 #ifdef V8_ENABLE_CHECKS
7149 if (index < 0 || index >= kInternalFieldsInWeakCallback) {
7150 V8::InternalFieldOutOfBounds(index);
7153 return internal_fields_[index];
7159 if (that == NULL)
return NULL;
7161 return reinterpret_cast<T*>(
7162 V8::GlobalizeReference(
reinterpret_cast<
internal::Isolate*>(isolate),
7167 template <
class T,
class M>
7168 template <
class S,
class M2>
7172 if (that.IsEmpty())
return;
7174 this->val_ =
reinterpret_cast<T*>(
V8::CopyPersistent(p));
7175 M::Copy(that,
this);
7182 if (
this->IsEmpty())
return false;
7191 if (
this->IsEmpty())
return false;
7192 uint8_t node_state =
7202 if (
this->IsEmpty())
return false;
7210 if (
this->IsEmpty())
return;
7211 V8::DisposeGlobal(
reinterpret_cast<
internal::Object**>(
this->val_));
7221 if (other.IsEmpty())
return;
7222 this->val_ = New(isolate, other.val_);
7232 if (other.IsEmpty())
return;
7233 this->val_ = New(isolate, other.val_);
7238 template <
typename S,
typename P>
7244 V8::MakeWeak(
reinterpret_cast<
internal::Object**>(
this->val_), parameter,
7245 reinterpret_cast<Callback>(callback));
7250 template <
typename P>
7254 SetWeak<T, P>(parameter, callback);
7259 template <
typename P>
7262 int internal_field_index1,
int internal_field_index2) {
7264 V8::MakeWeak(
reinterpret_cast<
internal::Object**>(
this->val_), parameter,
7265 internal_field_index1, internal_field_index2,
7266 reinterpret_cast<Callback>(callback));
7271 template <
typename P>
7276 V8::MakeWeak(
reinterpret_cast<
internal::Object**>(
this->val_), parameter,
7277 reinterpret_cast<Callback>(callback), type);
7282 template <
typename P>
7284 return reinterpret_cast<P*>(
7285 V8::ClearWeak(
reinterpret_cast<
internal::Object**>(
this->val_)));
7292 if (
this->IsEmpty())
return;
7302 if (
this->IsEmpty())
return;
7312 if (
this->IsEmpty())
return;
7315 *
reinterpret_cast<uint16_t*>(addr) = class_id;
7322 if (
this->IsEmpty())
return 0;
7325 return *
reinterpret_cast<uint16_t*>(addr);
7329 template<
typename T>
7332 template<
typename T>
7333 template<
typename S>
7337 *value_ = GetDefaultValue();
7339 *value_ = *
reinterpret_cast<
internal::Object**>(*handle);
7343 template <
typename T>
7344 template <
typename S>
7348 *value_ = GetDefaultValue();
7350 *value_ = *
reinterpret_cast<
internal::Object**>(*handle);
7354 template <
typename T>
7355 template <
typename S>
7359 *value_ = GetDefaultValue();
7361 *value_ = *
reinterpret_cast<
internal::Object**>(*handle);
7365 template<
typename T>
7371 template<
typename T>
7382 template<
typename T>
7386 bool fits_into_int32_t = (i & (1U << 31)) == 0;
7388 Set(
static_cast<int32_t>(i));
7394 template<
typename T>
7407 template<
typename T>
7414 template<
typename T>
7421 template<
typename T>
7428 template<
typename T>
7431 return *
reinterpret_cast<
Isolate**>(&value_[-2]);
7434 template<
typename T>
7435 template<
typename S>
7441 template<
typename T>
7448 template<
typename T>
7452 bool is_construct_call)
7459 template<
typename T>
7466 template<
typename T>
7473 template<
typename T>
7479 template<
typename T>
7486 template<
typename T>
7492 template<
typename T>
7498 template<
typename T>
7504 template<
typename T>
7510 template<
typename T>
7523 : resource_name_(resource_name),
7524 resource_line_offset_(resource_line_offset),
7525 resource_column_offset_(resource_column_offset),
7526 options_
(!resource_is_embedder_debug_script
.IsEmpty() &&
7528 !resource_is_shared_cross_origin
.IsEmpty() &&
7531 script_id_(script_id),
7532 source_map_url_(source_map_url) {}
7538 return resource_line_offset_;
7543 return resource_column_offset_;
7555 : source_string(string),
7561 cached_data(data) {}
7566 : source_string(string), cached_data(data) {}
7593 #ifndef V8_ENABLE_CHECKS
7597 O* obj = *
reinterpret_cast<O**>(
this);
7603 O** result =
HandleScope::CreateHandle(
reinterpret_cast<HO*>(obj), value);
7607 return SlowGetInternalField(index);
7612 #ifndef V8_ENABLE_CHECKS
7615 O* obj = *
reinterpret_cast<O**>(
this);
7623 return SlowGetAlignedPointerFromInternalField(index);
7628 #ifdef V8_ENABLE_CHECKS
7631 return static_cast<
String*>(value);
7647 O* obj = *
reinterpret_cast<O*
const*>(
this);
7655 #ifdef V8_ENABLE_CHECKS
7656 VerifyExternalStringResource(result);
7666 O* obj = *
reinterpret_cast<O*
const*>(
this);
7675 #ifdef V8_ENABLE_CHECKS
7676 VerifyExternalStringResourceBase(resource, *encoding_out);
7683 #ifdef V8_ENABLE_CHECKS
7684 return FullIsUndefined();
7686 return QuickIsUndefined();
7690 bool Value::QuickIsUndefined()
const {
7693 O* obj = *
reinterpret_cast<O*
const*>(
this);
7701 #ifdef V8_ENABLE_CHECKS
7702 return FullIsNull();
7704 return QuickIsNull();
7708 bool Value::QuickIsNull()
const {
7711 O* obj = *
reinterpret_cast<O*
const*>(
this);
7719 #ifdef V8_ENABLE_CHECKS
7720 return FullIsString();
7722 return QuickIsString();
7726 bool Value::QuickIsString()
const {
7729 O* obj = *
reinterpret_cast<O*
const*>(
this);
7736 return static_cast<
Value*>(value);
7789 #ifdef V8_ENABLE_CHECKS
7792 return static_cast<
Boolean*>(value);
7797 #ifdef V8_ENABLE_CHECKS
7800 return static_cast<
Name*>(value);
7805 #ifdef V8_ENABLE_CHECKS
7808 return static_cast<
Symbol*>(value);
7813 #ifdef V8_ENABLE_CHECKS
7816 return static_cast<
Number*>(value);
7821 #ifdef V8_ENABLE_CHECKS
7824 return static_cast<
Integer*>(value);
7829 #ifdef V8_ENABLE_CHECKS
7832 return static_cast<
Int32*>(value);
7837 #ifdef V8_ENABLE_CHECKS
7840 return static_cast<
Uint32*>(value);
7845 #ifdef V8_ENABLE_CHECKS
7848 return static_cast<
Date*>(value);
7853 #ifdef V8_ENABLE_CHECKS
7861 #ifdef V8_ENABLE_CHECKS
7869 #ifdef V8_ENABLE_CHECKS
7877 #ifdef V8_ENABLE_CHECKS
7885 #ifdef V8_ENABLE_CHECKS
7888 return static_cast<
RegExp*>(value);
7893 #ifdef V8_ENABLE_CHECKS
7896 return static_cast<
Object*>(value);
7901 #ifdef V8_ENABLE_CHECKS
7904 return static_cast<
Array*>(value);
7909 #ifdef V8_ENABLE_CHECKS
7912 return static_cast<
Map*>(value);
7917 #ifdef V8_ENABLE_CHECKS
7920 return static_cast<
Set*>(value);
7925 #ifdef V8_ENABLE_CHECKS
7928 return static_cast<
Promise*>(value);
7933 #ifdef V8_ENABLE_CHECKS
7941 #ifdef V8_ENABLE_CHECKS
7949 #ifdef V8_ENABLE_CHECKS
7957 #ifdef V8_ENABLE_CHECKS
7965 #ifdef V8_ENABLE_CHECKS
7973 #ifdef V8_ENABLE_CHECKS
7981 #ifdef V8_ENABLE_CHECKS
7989 #ifdef V8_ENABLE_CHECKS
7997 #ifdef V8_ENABLE_CHECKS
8005 #ifdef V8_ENABLE_CHECKS
8013 #ifdef V8_ENABLE_CHECKS
8021 #ifdef V8_ENABLE_CHECKS
8029 #ifdef V8_ENABLE_CHECKS
8037 #ifdef V8_ENABLE_CHECKS
8040 return static_cast<
DataView*>(value);
8045 #ifdef V8_ENABLE_CHECKS
8053 #ifdef V8_ENABLE_CHECKS
8056 return static_cast<
Function*>(value);
8061 #ifdef V8_ENABLE_CHECKS
8064 return static_cast<
External*>(value);
8068 template<
typename T>
8074 template<
typename T>
8080 template<
typename T>
8086 template<
typename T>
8092 template<
typename T>
8153 int64_t change_in_bytes) {
8155 int64_t* amount_of_external_allocated_memory =
8156 reinterpret_cast<int64_t*>(
reinterpret_cast<uint8_t*>(
this) +
8158 int64_t* amount_of_external_allocated_memory_at_last_global_gc =
8159 reinterpret_cast<int64_t*>(
8160 reinterpret_cast<uint8_t*>(
this) +
8162 int64_t amount = *amount_of_external_allocated_memory + change_in_bytes;
8163 if (change_in_bytes > 0 &&
8164 amount - *amount_of_external_allocated_memory_at_last_global_gc >
8166 CollectAllGarbage(
"external memory allocation limit reached.");
8168 *amount_of_external_allocated_memory = amount;
8169 return *amount_of_external_allocated_memory;
8173 template<
typename T>
8177 SetObjectGroupId(
reinterpret_cast<
v8::
internal::Object**>(object.val_), id);
8181 template<
typename T>
8185 SetReferenceFromGroup(id,
8186 reinterpret_cast<
v8::
internal::Object**>(object.val_));
8190 template<
typename T,
typename S>
8195 SetReference(
reinterpret_cast<
v8::
internal::Object**>(parent.val_),
8196 reinterpret_cast<
v8::
internal::Object**>(child.val_));
8201 #ifndef V8_ENABLE_CHECKS
8205 HO* context = *
reinterpret_cast<HO**>(
this);
8210 return SlowGetEmbedderData(index);
8216 #ifndef V8_ENABLE_CHECKS
8220 return SlowGetAlignedPointerFromEmbedderData(index);
8225 void V8::SetAllowCodeGenerationFromStringsCallback(
8250 void V8::SetFailedAccessCheckCallbackFunction(
8257 void V8::SetCaptureStackTraceForUncaughtExceptions(
8271 void V8::RemoveGCPrologueCallback(
GCCallback callback) {
8278 void V8::RemoveGCEpilogueCallback(
GCCallback callback) {
8302 bool V8::IsExecutionTerminating(
Isolate* isolate) {
8303 if (isolate == NULL) {
8310 void V8::CancelTerminateExecution(
Isolate* isolate) {
8327 void V8::VisitHandlesWithClassIds(
Isolate* isolate,
8333 void V8::VisitHandlesForPartialDependence(
Isolate* isolate,