Where Online Learning is simpler!
The C and C++ Include Header Files
/usr/include/node/v8-local-handle.h
$ cat -n /usr/include/node/v8-local-handle.h 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_LOCAL_HANDLE_H_ 6 #define INCLUDE_V8_LOCAL_HANDLE_H_ 7 8 #include <stddef.h> 9 10 #include <type_traits> 11 #include <vector> 12 13 #include "v8-handle-base.h" // NOLINT(build/include_directory) 14 #include "v8-internal.h" // NOLINT(build/include_directory) 15 16 namespace v8 { 17 18 template <class T> 19 class LocalBase; 20 template <class T> 21 class Local; 22 template <class T> 23 class LocalVector; 24 template <class F> 25 class MaybeLocal; 26 27 template <class T> 28 class Eternal; 29 template <class T> 30 class Global; 31 32 template <class T> 33 class NonCopyablePersistentTraits; 34 template <class T> 35 class PersistentBase; 36 template <class T, class M = NonCopyablePersistentTraits<T>> 37 class Persistent; 38 39 class TracedReferenceBase; 40 template <class T> 41 class BasicTracedReference; 42 template <class F> 43 class TracedReference; 44 45 class Boolean; 46 class Context; 47 class EscapableHandleScope; 48 template <class F> 49 class FunctionCallbackInfo; 50 class Isolate; 51 class Object; 52 template <class F1, class F2, class F3> 53 class PersistentValueMapBase; 54 template <class F1, class F2> 55 class PersistentValueVector; 56 class Primitive; 57 class Private; 58 template <class F> 59 class PropertyCallbackInfo; 60 template <class F> 61 class ReturnValue; 62 class String; 63 template <class F> 64 class Traced; 65 class TypecheckWitness; 66 class Utils; 67 68 namespace debug { 69 class ConsoleCallArguments; 70 } 71 72 namespace internal { 73 template <typename T> 74 class CustomArguments; 75 template <typename T> 76 class LocalUnchecked; 77 class SamplingHeapProfiler; 78 } // namespace internal 79 80 namespace api_internal { 81 // Called when ToLocalChecked is called on an empty Local. 82 V8_EXPORT void ToLocalEmpty(); 83 } // namespace api_internal 84 85 /** 86 * A stack-allocated class that governs a number of local handles. 87 * After a handle scope has been created, all local handles will be 88 * allocated within that handle scope until either the handle scope is 89 * deleted or another handle scope is created. If there is already a 90 * handle scope and a new one is created, all allocations will take 91 * place in the new handle scope until it is deleted. After that, 92 * new handles will again be allocated in the original handle scope. 93 * 94 * After the handle scope of a local handle has been deleted the 95 * garbage collector will no longer track the object stored in the 96 * handle and may deallocate it. The behavior of accessing a handle 97 * for which the handle scope has been deleted is undefined. 98 */ 99 class V8_EXPORT V8_NODISCARD HandleScope { 100 public: 101 explicit HandleScope(Isolate* isolate); 102 103 ~HandleScope(); 104 105 /** 106 * Counts the number of allocated handles. 107 */ 108 static int NumberOfHandles(Isolate* isolate); 109 110 V8_INLINE Isolate* GetIsolate() const { 111 return reinterpret_cast<Isolate*>(i_isolate_); 112 } 113 114 HandleScope(const HandleScope&) = delete; 115 void operator=(const HandleScope&) = delete; 116 117 static internal::Address* CreateHandleForCurrentIsolate( 118 internal::Address value); 119 120 protected: 121 V8_INLINE HandleScope() = default; 122 123 void Initialize(Isolate* isolate); 124 125 static internal::Address* CreateHandle(internal::Isolate* i_isolate, 126 internal::Address value); 127 128 private: 129 // Declaring operator new and delete as deleted is not spec compliant. 130 // Therefore declare them private instead to disable dynamic alloc 131 void* operator new(size_t size); 132 void* operator new[](size_t size); 133 void operator delete(void*, size_t); 134 void operator delete[](void*, size_t); 135 136 internal::Isolate* i_isolate_; 137 internal::Address* prev_next_; 138 internal::Address* prev_limit_; 139 #ifdef V8_ENABLE_CHECKS 140 int scope_level_ = 0; 141 #endif 142 143 // LocalBase<T>::New uses CreateHandle with an Isolate* parameter. 144 template <typename T> 145 friend class LocalBase; 146 147 // Object::GetInternalField and Context::GetEmbedderData use CreateHandle with 148 // a HeapObject in their shortcuts. 149 friend class Object; 150 friend class Context; 151 }; 152 153 /** 154 * A base class for local handles. 155 * Its implementation depends on whether direct local support is enabled. 156 * When it is, a local handle contains a direct pointer to the referenced 157 * object, otherwise it contains an indirect pointer. 158 */ 159 #ifdef V8_ENABLE_DIRECT_LOCAL 160 161 template <typename T> 162 class LocalBase : public api_internal::DirectHandleBase { 163 protected: 164 template <class F> 165 friend class Local; 166 167 V8_INLINE LocalBase() = default; 168 169 V8_INLINE explicit LocalBase(internal::Address ptr) : DirectHandleBase(ptr) {} 170 171 template <typename S> 172 V8_INLINE LocalBase(const LocalBase<S>& other) : DirectHandleBase(other) {} 173 174 V8_INLINE static LocalBase<T> New(Isolate* isolate, internal::Address value) { 175 return LocalBase<T>(value); 176 } 177 178 V8_INLINE static LocalBase<T> New(Isolate* isolate, T* that) { 179 return LocalBase<T>::New(isolate, 180 internal::ValueHelper::ValueAsAddress(that)); 181 } 182 183 V8_INLINE static LocalBase<T> FromSlot(internal::Address* slot) { 184 return LocalBase<T>(*slot); 185 } 186 }; 187 188 #else // !V8_ENABLE_DIRECT_LOCAL 189 190 template <typename T> 191 class LocalBase : public api_internal::IndirectHandleBase { 192 protected: 193 template <class F> 194 friend class Local; 195 196 V8_INLINE LocalBase() = default; 197 198 V8_INLINE explicit LocalBase(internal::Address* location) 199 : IndirectHandleBase(location) {} 200 201 template <typename S> 202 V8_INLINE LocalBase(const LocalBase<S>& other) : IndirectHandleBase(other) {} 203 204 V8_INLINE static LocalBase<T> New(Isolate* isolate, internal::Address value) { 205 return LocalBase(HandleScope::CreateHandle( 206 reinterpret_cast<internal::Isolate*>(isolate), value)); 207 } 208 209 V8_INLINE static LocalBase<T> New(Isolate* isolate, T* that) { 210 if (internal::ValueHelper::IsEmpty(that)) return LocalBase<T>(); 211 return LocalBase<T>::New(isolate, 212 internal::ValueHelper::ValueAsAddress(that)); 213 } 214 215 V8_INLINE static LocalBase<T> FromSlot(internal::Address* slot) { 216 return LocalBase<T>(slot); 217 } 218 }; 219 220 #endif // V8_ENABLE_DIRECT_LOCAL 221 222 /** 223 * An object reference managed by the v8 garbage collector. 224 * 225 * All objects returned from v8 have to be tracked by the garbage collector so 226 * that it knows that the objects are still alive. Also, because the garbage 227 * collector may move objects, it is unsafe to point directly to an object. 228 * Instead, all objects are stored in handles which are known by the garbage 229 * collector and updated whenever an object moves. Handles should always be 230 * passed by value (except in cases like out-parameters) and they should never 231 * be allocated on the heap. 232 * 233 * There are two types of handles: local and persistent handles. 234 * 235 * Local handles are light-weight and transient and typically used in local 236 * operations. They are managed by HandleScopes. That means that a HandleScope 237 * must exist on the stack when they are created and that they are only valid 238 * inside of the HandleScope active during their creation. For passing a local 239 * handle to an outer HandleScope, an EscapableHandleScope and its Escape() 240 * method must be used. 241 * 242 * Persistent handles can be used when storing objects across several 243 * independent operations and have to be explicitly deallocated when they're no 244 * longer used. 245 * 246 * It is safe to extract the object stored in the handle by dereferencing the 247 * handle (for instance, to extract the Object* from a Local<Object>); the value 248 * will still be governed by a handle behind the scenes and the same rules apply 249 * to these values as to their handles. 250 */ 251 template <class T> 252 class V8_TRIVIAL_ABI Local : public LocalBase<T>, 253 #ifdef V8_ENABLE_LOCAL_OFF_STACK_CHECK 254 public api_internal::StackAllocated<true> 255 #else 256 public api_internal::StackAllocated<false> 257 #endif 258 { 259 public: 260 V8_INLINE Local() = default; 261 262 template <class S> 263 V8_INLINE Local(Local<S> that) : LocalBase<T>(that) { 264 /** 265 * This check fails when trying to convert between incompatible 266 * handles. For example, converting from a Local<String> to a 267 * Local<Number>. 268 */ 269 static_assert(std::is_base_of<T, S>::value, "type check"); 270 } 271 272 V8_INLINE T* operator->() const { return this->template value<T>(); } 273 274 V8_INLINE T* operator*() const { return this->operator->(); } 275 276 /** 277 * Checks whether two handles are equal or different. 278 * They are equal iff they are both empty or they are both non-empty and the 279 * objects to which they refer are physically equal. 280 * 281 * If both handles refer to JS objects, this is the same as strict 282 * non-equality. For primitives, such as numbers or strings, a `true` return 283 * value does not indicate that the values aren't equal in the JavaScript 284 * sense. Use `Value::StrictEquals()` to check primitives for equality. 285 */ 286 287 template <class S> 288 V8_INLINE bool operator==(const Local<S>& that) const { 289 return internal::HandleHelper::EqualHandles(*this, that); 290 } 291 292 template <class S> 293 V8_INLINE bool operator==(const PersistentBase<S>& that) const { 294 return internal::HandleHelper::EqualHandles(*this, that); 295 } 296 297 template <class S> 298 V8_INLINE bool operator!=(const Local<S>& that) const { 299 return !operator==(that); 300 } 301 302 template <class S> 303 V8_INLINE bool operator!=(const Persistent<S>& that) const { 304 return !operator==(that); 305 } 306 307 /** 308 * Cast a handle to a subclass, e.g. Local<Value> to Local<Object>. 309 * This is only valid if the handle actually refers to a value of the 310 * target type. 311 */ 312 template <class S> 313 V8_INLINE static Local<T> Cast(Local<S> that) { 314 #ifdef V8_ENABLE_CHECKS 315 // If we're going to perform the type check then we have to check 316 // that the handle isn't empty before doing the checked cast. 317 if (that.IsEmpty()) return Local<T>(); 318 T::Cast(that.template value<S>()); 319 #endif 320 return Local<T>(LocalBase<T>(that)); 321 } 322 323 /** 324 * Calling this is equivalent to Local<S>::Cast(). 325 * In particular, this is only valid if the handle actually refers to a value 326 * of the target type. 327 */ 328 template <class S> 329 V8_INLINE Local<S> As() const { 330 return Local<S>::Cast(*this); 331 } 332 333 /** 334 * Create a local handle for the content of another handle. 335 * The referee is kept alive by the local handle even when 336 * the original handle is destroyed/disposed. 337 */ 338 V8_INLINE static Local<T> New(Isolate* isolate, Local<T> that) { 339 return New(isolate, that.template value<T, true>()); 340 } 341 342 V8_INLINE static Local<T> New(Isolate* isolate, 343 const PersistentBase<T>& that) { 344 return New(isolate, that.template value<T, true>()); 345 } 346 347 V8_INLINE static Local<T> New(Isolate* isolate, 348 const BasicTracedReference<T>& that) { 349 return New(isolate, that.template value<T, true>()); 350 } 351 352 private: 353 friend class TracedReferenceBase; 354 friend class Utils; 355 template <class F> 356 friend class Eternal; 357 template <class F> 358 friend class Global; 359 template <class F> 360 friend class Local; 361 template <class F> 362 friend class MaybeLocal; 363 template <class F, class M> 364 friend class Persistent; 365 template <class F> 366 friend class FunctionCallbackInfo; 367 template <class F> 368 friend class PropertyCallbackInfo; 369 friend class String; 370 friend class Object; 371 friend class Context; 372 friend class Isolate; 373 friend class Private; 374 template <class F> 375 friend class internal::CustomArguments; 376 friend Local<Primitive> Undefined(Isolate* isolate); 377 friend Local<Primitive> Null(Isolate* isolate); 378 friend Local<Boolean> True(Isolate* isolate); 379 friend Local<Boolean> False(Isolate* isolate); 380 friend class HandleScope; 381 friend class EscapableHandleScope; 382 friend class InternalEscapableScope; 383 template <class F1, class F2, class F3> 384 friend class PersistentValueMapBase; 385 template <class F1, class F2> 386 friend class PersistentValueVector; 387 template <class F> 388 friend class ReturnValue; 389 template <class F> 390 friend class Traced; 391 friend class internal::SamplingHeapProfiler; 392 friend class internal::HandleHelper; 393 friend class debug::ConsoleCallArguments; 394 friend class internal::LocalUnchecked<T>; 395 396 explicit Local(no_checking_tag do_not_check) 397 : LocalBase<T>(), StackAllocated(do_not_check) {} 398 explicit Local(const Local<T>& other, no_checking_tag do_not_check) 399 : LocalBase<T>(other), StackAllocated(do_not_check) {} 400 401 V8_INLINE explicit Local(const LocalBase<T>& other) : LocalBase<T>(other) {} 402 403 V8_INLINE static Local<T> FromSlot(internal::Address* slot) { 404 return Local<T>(LocalBase<T>::FromSlot(slot)); 405 } 406 407 #ifdef V8_ENABLE_DIRECT_LOCAL 408 friend class TypecheckWitness; 409 410 V8_INLINE static Local<T> FromAddress(internal::Address ptr) { 411 return Local<T>(LocalBase<T>(ptr)); 412 } 413 #endif // V8_ENABLE_DIRECT_LOCAL 414 415 V8_INLINE static Local<T> New(Isolate* isolate, internal::Address value) { 416 return Local<T>(LocalBase<T>::New(isolate, value)); 417 } 418 419 V8_INLINE static Local<T> New(Isolate* isolate, T* that) { 420 return Local<T>(LocalBase<T>::New(isolate, that)); 421 } 422 423 // Unsafe cast, should be avoided. 424 template <class S> 425 V8_INLINE Local<S> UnsafeAs() const { 426 return Local<S>(LocalBase<S>(*this)); 427 } 428 }; 429 430 namespace internal { 431 // A local variant that is suitable for off-stack allocation. 432 // Used internally by LocalVector<T>. Not to be used directly! 433 template <typename T> 434 class V8_TRIVIAL_ABI LocalUnchecked : public Local<T> { 435 public: 436 LocalUnchecked() : Local<T>(Local<T>::do_not_check) {} 437 438 #if defined(V8_ENABLE_LOCAL_OFF_STACK_CHECK) && V8_HAS_ATTRIBUTE_TRIVIAL_ABI 439 // In this case, the check is also enforced in the copy constructor and we 440 // need to suppress it. 441 LocalUnchecked(const LocalUnchecked& other) 442 : Local<T>(other, Local<T>::do_not_check) {} 443 LocalUnchecked& operator=(const LocalUnchecked&) = default; 444 #endif 445 446 // Implicit conversion from Local. 447 LocalUnchecked(const Local<T>& other) // NOLINT(runtime/explicit) 448 : Local<T>(other, Local<T>::do_not_check) {} 449 }; 450 451 #ifdef V8_ENABLE_DIRECT_LOCAL 452 // Off-stack allocated direct locals must be registered as strong roots. 453 // For off-stack indirect locals, this is not necessary. 454 455 template <typename T> 456 class StrongRootAllocator<LocalUnchecked<T>> : public StrongRootAllocatorBase { 457 public: 458 using value_type = LocalUnchecked<T>; 459 static_assert(std::is_standard_layout_v<value_type>); 460 static_assert(sizeof(value_type) == sizeof(Address)); 461 462 explicit StrongRootAllocator(Heap* heap) : StrongRootAllocatorBase(heap) {} 463 explicit StrongRootAllocator(v8::Isolate* isolate) 464 : StrongRootAllocatorBase(isolate) {} 465 template <typename U> 466 StrongRootAllocator(const StrongRootAllocator<U>& other) noexcept 467 : StrongRootAllocatorBase(other) {} 468 469 value_type* allocate(size_t n) { 470 return reinterpret_cast<value_type*>(allocate_impl(n)); 471 } 472 void deallocate(value_type* p, size_t n) noexcept { 473 return deallocate_impl(reinterpret_cast<Address*>(p), n); 474 } 475 }; 476 #endif // V8_ENABLE_DIRECT_LOCAL 477 } // namespace internal 478 479 template <typename T> 480 class LocalVector { 481 private: 482 using element_type = internal::LocalUnchecked<T>; 483 484 #ifdef V8_ENABLE_DIRECT_LOCAL 485 using allocator_type = internal::StrongRootAllocator<element_type>; 486 487 static allocator_type make_allocator(Isolate* isolate) noexcept { 488 return allocator_type(isolate); 489 } 490 #else 491 using allocator_type = std::allocator<element_type>; 492 493 static allocator_type make_allocator(Isolate* isolate) noexcept { 494 return allocator_type(); 495 } 496 #endif // V8_ENABLE_DIRECT_LOCAL 497 498 using vector_type = std::vector<element_type, allocator_type>; 499 500 public: 501 using value_type = Local<T>; 502 using reference = value_type&; 503 using const_reference = const value_type&; 504 using size_type = size_t; 505 using difference_type = ptrdiff_t; 506 using iterator = 507 internal::WrappedIterator<typename vector_type::iterator, Local<T>>; 508 using const_iterator = 509 internal::WrappedIterator<typename vector_type::const_iterator, 510 const Local<T>>; 511 512 explicit LocalVector(Isolate* isolate) : backing_(make_allocator(isolate)) {} 513 LocalVector(Isolate* isolate, size_t n) 514 : backing_(n, make_allocator(isolate)) {} 515 explicit LocalVector(Isolate* isolate, std::initializer_list<Local<T>> init) 516 : backing_(make_allocator(isolate)) { 517 if (init.size() == 0) return; 518 backing_.reserve(init.size()); 519 backing_.insert(backing_.end(), init.begin(), init.end()); 520 } 521 522 iterator begin() noexcept { return iterator(backing_.begin()); } 523 const_iterator begin() const noexcept { 524 return const_iterator(backing_.begin()); 525 } 526 iterator end() noexcept { return iterator(backing_.end()); } 527 const_iterator end() const noexcept { return const_iterator(backing_.end()); } 528 529 size_t size() const noexcept { return backing_.size(); } 530 bool empty() const noexcept { return backing_.empty(); } 531 void reserve(size_t n) { backing_.reserve(n); } 532 void shrink_to_fit() { backing_.shrink_to_fit(); } 533 534 Local<T>& operator[](size_t n) { return backing_[n]; } 535 const Local<T>& operator[](size_t n) const { return backing_[n]; } 536 537 Local<T>& at(size_t n) { return backing_.at(n); } 538 const Local<T>& at(size_t n) const { return backing_.at(n); } 539 540 Local<T>& front() { return backing_.front(); } 541 const Local<T>& front() const { return backing_.front(); } 542 Local<T>& back() { return backing_.back(); } 543 const Local<T>& back() const { return backing_.back(); } 544 545 Local<T>* data() noexcept { return backing_.data(); } 546 const Local<T>* data() const noexcept { return backing_.data(); } 547 548 iterator insert(const_iterator pos, const Local<T>& value) { 549 return iterator(backing_.insert(pos.base(), value)); 550 } 551 552 template <typename InputIt> 553 iterator insert(const_iterator pos, InputIt first, InputIt last) { 554 return iterator(backing_.insert(pos.base(), first, last)); 555 } 556 557 iterator insert(const_iterator pos, std::initializer_list<Local<T>> init) { 558 return iterator(backing_.insert(pos.base(), init.begin(), init.end())); 559 } 560 561 LocalVector<T>& operator=(std::initializer_list<Local<T>> init) { 562 backing_.clear(); 563 backing_.insert(backing_.end(), init.begin(), init.end()); 564 return *this; 565 } 566 567 void push_back(const Local<T>& x) { backing_.push_back(x); } 568 void pop_back() { backing_.pop_back(); } 569 void emplace_back(const Local<T>& x) { backing_.emplace_back(x); } 570 571 void clear() noexcept { backing_.clear(); } 572 void resize(size_t n) { backing_.resize(n); } 573 void swap(LocalVector<T>& other) { backing_.swap(other.backing_); } 574 575 friend bool operator==(const LocalVector<T>& x, const LocalVector<T>& y) { 576 return x.backing_ == y.backing_; 577 } 578 friend bool operator!=(const LocalVector<T>& x, const LocalVector<T>& y) { 579 return x.backing_ != y.backing_; 580 } 581 friend bool operator<(const LocalVector<T>& x, const LocalVector<T>& y) { 582 return x.backing_ < y.backing_; 583 } 584 friend bool operator>(const LocalVector<T>& x, const LocalVector<T>& y) { 585 return x.backing_ > y.backing_; 586 } 587 friend bool operator<=(const LocalVector<T>& x, const LocalVector<T>& y) { 588 return x.backing_ <= y.backing_; 589 } 590 friend bool operator>=(const LocalVector<T>& x, const LocalVector<T>& y) { 591 return x.backing_ >= y.backing_; 592 } 593 594 private: 595 vector_type backing_; 596 }; 597 598 #if !defined(V8_IMMINENT_DEPRECATION_WARNINGS) 599 // Handle is an alias for Local for historical reasons. 600 template <class T> 601 using Handle = Local<T>; 602 #endif 603 604 /** 605 * A MaybeLocal<> is a wrapper around Local<> that enforces a check whether 606 * the Local<> is empty before it can be used. 607 * 608 * If an API method returns a MaybeLocal<>, the API method can potentially fail 609 * either because an exception is thrown, or because an exception is pending, 610 * e.g. because a previous API call threw an exception that hasn't been caught 611 * yet, or because a TerminateExecution exception was thrown. In that case, an 612 * empty MaybeLocal is returned. 613 */ 614 template <class T> 615 class MaybeLocal { 616 public: 617 V8_INLINE MaybeLocal() : local_() {} 618 template <class S> 619 V8_INLINE MaybeLocal(Local<S> that) : local_(that) {} 620 621 V8_INLINE bool IsEmpty() const { return local_.IsEmpty(); } 622 623 /** 624 * Converts this MaybeLocal<> to a Local<>. If this MaybeLocal<> is empty, 625 * |false| is returned and |out| is assigned with nullptr. 626 */ 627 template <class S> 628 V8_WARN_UNUSED_RESULT V8_INLINE bool ToLocal(Local<S>* out) const { 629 *out = local_; 630 return !IsEmpty(); 631 } 632 633 /** 634 * Converts this MaybeLocal<> to a Local<>. If this MaybeLocal<> is empty, 635 * V8 will crash the process. 636 */ 637 V8_INLINE Local<T> ToLocalChecked() { 638 if (V8_UNLIKELY(IsEmpty())) api_internal::ToLocalEmpty(); 639 return local_; 640 } 641 642 /** 643 * Converts this MaybeLocal<> to a Local<>, using a default value if this 644 * MaybeLocal<> is empty. 645 */ 646 template <class S> 647 V8_INLINE Local<S> FromMaybe(Local<S> default_value) const { 648 return IsEmpty() ? default_value : Local<S>(local_); 649 } 650 651 /** 652 * Cast a handle to a subclass, e.g. MaybeLocal<Value> to MaybeLocal<Object>. 653 * This is only valid if the handle actually refers to a value of the target 654 * type. 655 */ 656 template <class S> 657 V8_INLINE static MaybeLocal<T> Cast(MaybeLocal<S> that) { 658 #ifdef V8_ENABLE_CHECKS 659 // If we're going to perform the type check then we have to check 660 // that the handle isn't empty before doing the checked cast. 661 if (that.IsEmpty()) return MaybeLocal<T>(); 662 T::Cast(that.local_.template value<S>()); 663 #endif 664 return MaybeLocal<T>(that.local_); 665 } 666 667 /** 668 * Calling this is equivalent to MaybeLocal<S>::Cast(). 669 * In particular, this is only valid if the handle actually refers to a value 670 * of the target type. 671 */ 672 template <class S> 673 V8_INLINE MaybeLocal<S> As() const { 674 return MaybeLocal<S>::Cast(*this); 675 } 676 677 private: 678 Local<T> local_; 679 680 template <typename S> 681 friend class MaybeLocal; 682 }; 683 684 /** 685 * A HandleScope which first allocates a handle in the current scope 686 * which will be later filled with the escape value. 687 */ 688 class V8_EXPORT V8_NODISCARD EscapableHandleScopeBase : public HandleScope { 689 public: 690 explicit EscapableHandleScopeBase(Isolate* isolate); 691 V8_INLINE ~EscapableHandleScopeBase() = default; 692 693 EscapableHandleScopeBase(const EscapableHandleScopeBase&) = delete; 694 void operator=(const EscapableHandleScopeBase&) = delete; 695 void* operator new(size_t size) = delete; 696 void* operator new[](size_t size) = delete; 697 void operator delete(void*, size_t) = delete; 698 void operator delete[](void*, size_t) = delete; 699 700 protected: 701 /** 702 * Pushes the value into the previous scope and returns a handle to it. 703 * Cannot be called twice. 704 */ 705 internal::Address* EscapeSlot(internal::Address* escape_value); 706 707 private: 708 internal::Address* escape_slot_; 709 }; 710 711 class V8_EXPORT V8_NODISCARD EscapableHandleScope 712 : public EscapableHandleScopeBase { 713 public: 714 explicit EscapableHandleScope(Isolate* isolate) 715 : EscapableHandleScopeBase(isolate) {} 716 V8_INLINE ~EscapableHandleScope() = default; 717 template <class T> 718 V8_INLINE Local<T> Escape(Local<T> value) { 719 #ifdef V8_ENABLE_DIRECT_LOCAL 720 return value; 721 #else 722 if (value.IsEmpty()) return value; 723 return Local<T>::FromSlot(EscapeSlot(value.slot())); 724 #endif 725 } 726 727 template <class T> 728 V8_INLINE MaybeLocal<T> EscapeMaybe(MaybeLocal<T> value) { 729 return Escape(value.FromMaybe(Local<T>())); 730 } 731 }; 732 733 /** 734 * A SealHandleScope acts like a handle scope in which no handle allocations 735 * are allowed. It can be useful for debugging handle leaks. 736 * Handles can be allocated within inner normal HandleScopes. 737 */ 738 class V8_EXPORT V8_NODISCARD SealHandleScope { 739 public: 740 explicit SealHandleScope(Isolate* isolate); 741 ~SealHandleScope(); 742 743 SealHandleScope(const SealHandleScope&) = delete; 744 void operator=(const SealHandleScope&) = delete; 745 void* operator new(size_t size) = delete; 746 void* operator new[](size_t size) = delete; 747 void operator delete(void*, size_t) = delete; 748 void operator delete[](void*, size_t) = delete; 749 750 private: 751 internal::Isolate* const i_isolate_; 752 internal::Address* prev_limit_; 753 int prev_sealed_level_; 754 }; 755 756 } // namespace v8 757 758 #endif // INCLUDE_V8_LOCAL_HANDLE_H_
Contact us
|
About us
|
Term of use
|
Copyright © 2000-2025 MyWebUniversity.com ™
