v8::HandleScope Class Reference

A stack-allocated class that governs a number of local handles. More...

#include <v8.h>

Inheritance diagram for v8::HandleScope:

Collaboration diagram for v8::HandleScope:

Public Member Functions
	HandleScope (Isolate *isolate)
	~HandleScope ()
Isolate *	GetIsolate () const

Static Public Member Functions
static int	NumberOfHandles (Isolate *isolate)
	Counts the number of allocated handles. More...

Protected Member Functions
	HandleScope ()
void	Initialize (Isolate *isolate)

Static Protected Member Functions
static internal::Object **	CreateHandle (internal::Isolate *isolate, internal::Object *value)

Private Member Functions
	HandleScope (const HandleScope &)
void	operator= (const HandleScope &)
void *	operator new (size_t size)
void	operator delete (void *, size_t)

Static Private Member Functions
static internal::Object **	CreateHandle (internal::HeapObject *heap_object, internal::Object *value)

Private Attributes
internal::Isolate *	isolate_
internal::Object **	prev_next_
internal::Object **	prev_limit_

Friends
template<class F >
class	Local
class	Object
class	Context

Detailed Description

A stack-allocated class that governs a number of local handles.

After a handle scope has been created, all local handles will be allocated within that handle scope until either the handle scope is deleted or another handle scope is created. If there is already a handle scope and a new one is created, all allocations will take place in the new handle scope until it is deleted. After that, new handles will again be allocated in the original handle scope.

After the handle scope of a local handle has been deleted the garbage collector will no longer track the object stored in the handle and may deallocate it. The behavior of accessing a handle for which the handle scope has been deleted is undefined.

Definition at line 802 of file v8.h.

Constructor & Destructor Documentation

HandleScope() [1/3]

v8::HandleScope::HandleScope

(

Isolate *

isolate

)

Definition at line 546 of file api.cc.

                                         {
  Initialize(isolate);
}

References Initialize().

Here is the call graph for this function:

~HandleScope()

v8::HandleScope::~HandleScope

(

)

Definition at line 568 of file api.cc.

                          {
  i::HandleScope::CloseScope(isolate_, prev_next_, prev_limit_);
}

References v8::internal::HandleScope::CloseScope(), isolate_, prev_limit_, and prev_next_.

Here is the call graph for this function:

HandleScope() [2/3]

v8::HandleScope::HandleScope ( )

inlineprotected

Definition at line 818 of file v8.h.

{}

HandleScope() [3/3]

v8::HandleScope::HandleScope ( const HandleScope &  )

private

Member Function Documentation

CreateHandle() [1/2]

i::Object ** v8::HandleScope::CreateHandle ( internal::HeapObject *  heap_object, internal::Object *  value  )

staticprivate

Definition at line 584 of file api.cc.

                                                      {
  DCHECK(heap_object->IsHeapObject());
  return i::HandleScope::CreateHandle(heap_object->GetIsolate(), value);
}

References v8::internal::HandleScope::CreateHandle(), DCHECK, and v8::internal::HeapObject::GetIsolate().

Here is the call graph for this function:

CreateHandle() [2/2]

i::Object ** v8::HandleScope::CreateHandle ( internal::Isolate *  isolate, internal::Object *  value  )

staticprotected

Definition at line 579 of file api.cc.

                                                                     {
  return i::HandleScope::CreateHandle(isolate, value);
}

References v8::internal::HandleScope::CreateHandle().

Referenced by v8::EscapableHandleScope::EscapableHandleScope(), v8::Context::GetEmbedderData(), v8::Object::GetInternalField(), v8::Handle< T >::New(), and v8::Local< T >::New().

Here is the call graph for this function:

Here is the caller graph for this function:

GetIsolate()

Isolate* v8::HandleScope::GetIsolate ( ) const

inline

Definition at line 813 of file v8.h.

                                        {
    return reinterpret_cast<Isolate*>(isolate_);
  }

Referenced by v8::EscapableHandleScope::Escape().

Here is the caller graph for this function:

Initialize()

void v8::HandleScope::Initialize ( Isolate *  isolate )

protected

Definition at line 551 of file api.cc.

                                             {
  i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
  // We do not want to check the correct usage of the Locker class all over the
  // place, so we do it only here: Without a HandleScope, an embedder can do
  // almost nothing, so it is enough to check in this central place.
  Utils::ApiCheck(!v8::Locker::IsActive() ||
                  internal_isolate->thread_manager()->IsLockedByCurrentThread(),
                  "HandleScope::HandleScope",
                  "Entering the V8 API without proper locking in place");
  i::HandleScopeData* current = internal_isolate->handle_scope_data();
  isolate_ = internal_isolate;
  prev_next_ = current->next;
  prev_limit_ = current->limit;
  current->level++;
}

References v8::Utils::ApiCheck(), v8::internal::Isolate::handle_scope_data(), v8::Locker::IsActive(), v8::internal::ThreadManager::IsLockedByCurrentThread(), isolate_, v8::internal::HandleScopeData::level, v8::internal::HandleScopeData::limit, v8::internal::HandleScopeData::next, prev_limit_, prev_next_, and v8::internal::Isolate::thread_manager().

Referenced by v8::EscapableHandleScope::EscapableHandleScope(), and HandleScope().

Here is the call graph for this function:

Here is the caller graph for this function:

NumberOfHandles()

int v8::HandleScope::NumberOfHandles ( Isolate *  isolate )

static

Counts the number of allocated handles.

Definition at line 573 of file api.cc.

                                                 {
  return i::HandleScope::NumberOfHandles(
      reinterpret_cast<i::Isolate*>(isolate));
}

References v8::internal::HandleScope::NumberOfHandles().

Here is the call graph for this function:

operator delete()

void v8::HandleScope::operator delete ( void *  , size_t    )

private

operator new()

void* v8::HandleScope::operator new ( size_t  size )

private

operator=()

void v8::HandleScope::operator= ( const HandleScope &  )

private

Friends And Related Function Documentation

Context

friend class Context

friend

Definition at line 847 of file v8.h.

Local

template<class F >

friend class Local

friend

Definition at line 842 of file v8.h.

Object

friend class Object

friend

Definition at line 846 of file v8.h.

Member Data Documentation

isolate_

internal::Isolate* v8::HandleScope::isolate_

private

Definition at line 837 of file v8.h.

Referenced by Initialize(), and ~HandleScope().

prev_limit_

internal::Object** v8::HandleScope::prev_limit_

private

Definition at line 839 of file v8.h.

Referenced by Initialize(), and ~HandleScope().

prev_next_

internal::Object** v8::HandleScope::prev_next_

private

Definition at line 838 of file v8.h.

Referenced by Initialize(), and ~HandleScope().

---

The documentation for this class was generated from the following files:

• /mnt/V8SourceCode/include/v8.h
• /mnt/V8SourceCode/src/api.cc