v8::V8 Class Reference

Container class for static utility functions. More...

#include <v8.h>

Collaboration diagram for v8::V8:

Static Public Member Functions
static void	SetFatalErrorHandler (FatalErrorCallback that)
	Set the callback to invoke in case of fatal errors. More...
static void	SetAllowCodeGenerationFromStringsCallback (AllowCodeGenerationFromStringsCallback that)
	Set the callback to invoke to check if code generation from strings should be allowed. More...
static void	SetArrayBufferAllocator (ArrayBuffer::Allocator *allocator)
	Set allocator to use for ArrayBuffer memory. More...
static bool	IsDead ()
	Check if V8 is dead and therefore unusable. More...
static StartupData::CompressionAlgorithm	GetCompressedStartupDataAlgorithm ()
	The following 4 functions are to be used when V8 is built with the 'compress_startup_data' flag enabled. More...
static int	GetCompressedStartupDataCount ()
static void	GetCompressedStartupData (StartupData *compressed_data)
static void	SetDecompressedStartupData (StartupData *decompressed_data)
static void	SetNativesDataBlob (StartupData *startup_blob)
	Hand startup data to V8, in case the embedder has chosen to build V8 with external startup data. More...
static void	SetSnapshotDataBlob (StartupData *startup_blob)
static bool	AddMessageListener (MessageCallback that, Handle< Value > data=Handle< Value >())
	Adds a message listener. More...
static void	RemoveMessageListeners (MessageCallback that)
	Remove all message listeners from the specified callback function. More...
static void	SetCaptureStackTraceForUncaughtExceptions (bool capture, int frame_limit=10, StackTrace::StackTraceOptions options=StackTrace::kOverview)
	Tells V8 to capture current stack trace when uncaught exception occurs and report it to the message listeners. More...
static void	SetFlagsFromString (const char *str, int length)
	Sets V8 flags from a string. More...
static void	SetFlagsFromCommandLine (int *argc, char **argv, bool remove_flags)
	Sets V8 flags from the command line. More...
static const char *	GetVersion ()
	Get the version string. More...
static void	SetFailedAccessCheckCallbackFunction (FailedAccessCheckCallback)
	Callback function for reporting failed access checks. More...
static void	AddGCPrologueCallback (GCPrologueCallback callback, GCType gc_type_filter=kGCTypeAll)
	Enables the host application to receive a notification before a garbage collection. More...
static void	RemoveGCPrologueCallback (GCPrologueCallback callback)
	This function removes callback which was installed by AddGCPrologueCallback function. More...
static void	AddGCEpilogueCallback (GCEpilogueCallback callback, GCType gc_type_filter=kGCTypeAll)
	Enables the host application to receive a notification after a garbage collection. More...
static void	RemoveGCEpilogueCallback (GCEpilogueCallback callback)
	This function removes callback which was installed by AddGCEpilogueCallback function. More...
static void	AddMemoryAllocationCallback (MemoryAllocationCallback callback, ObjectSpace space, AllocationAction action)
	Enables the host application to provide a mechanism to be notified and perform custom logging when V8 Allocates Executable Memory. More...
static void	RemoveMemoryAllocationCallback (MemoryAllocationCallback callback)
	Removes callback that was installed by AddMemoryAllocationCallback. More...
static bool	Initialize ()
	Initializes V8. More...
static void	SetEntropySource (EntropySource source)
	Allows the host application to provide a callback which can be used as a source of entropy for random number generators. More...
static void	SetReturnAddressLocationResolver (ReturnAddressLocationResolver return_address_resolver)
	Allows the host application to provide a callback that allows v8 to cooperate with a profiler that rewrites return addresses on stack. More...
static void	TerminateExecution (Isolate *isolate)
	Forcefully terminate the current thread of JavaScript execution in the given isolate. More...
static bool	IsExecutionTerminating (Isolate *isolate=NULL)
	Is V8 terminating JavaScript execution. More...
static void	CancelTerminateExecution (Isolate *isolate)
	Resume execution capability in the given isolate, whose execution was previously forcefully terminated using TerminateExecution(). More...
static bool	Dispose ()
	Releases any resources used by v8 and stops any utility threads that may be running. More...
static void	VisitExternalResources (ExternalResourceVisitor *visitor)
	Iterates through all external resources referenced from current isolate heap. More...
static void	VisitHandlesWithClassIds (PersistentHandleVisitor *visitor)
	Iterates through all the persistent handles in the current isolate's heap that have class_ids. More...
static void	VisitHandlesForPartialDependence (Isolate *isolate, PersistentHandleVisitor *visitor)
	Iterates through all the persistent handles in the current isolate's heap that have class_ids and are candidates to be marked as partially dependent handles. More...
static bool	InitializeICU (const char *icu_data_file=NULL)
	Initialize the ICU library bundled with V8. More...
static void	InitializePlatform (Platform *platform)
	Sets the v8::Platform to use. More...
static void	ShutdownPlatform ()
	Clears all references to the v8::Platform. More...

Private Types
typedef WeakCallbackData< Value, void >::Callback	WeakCallback

Private Member Functions
	V8 ()

Static Private Member Functions
static internal::Object **	GlobalizeReference (internal::Isolate *isolate, internal::Object **handle)
static internal::Object **	CopyPersistent (internal::Object **handle)
static void	DisposeGlobal (internal::Object **global_handle)
static void	MakeWeak (internal::Object **global_handle, void *data, WeakCallback weak_callback)
static void *	ClearWeak (internal::Object **global_handle)
static void	Eternalize (Isolate *isolate, Value *handle, int *index)
static Local< Value >	GetEternal (Isolate *isolate, int index)

Friends
template<class T >
class	Handle
template<class T >
class	Local
template<class T >
class	Eternal
template<class T >
class	PersistentBase
template<class T , class M >
class	Persistent
class	Context

Detailed Description

Container class for static utility functions.

Definition at line 4964 of file v8.h.

Member Typedef Documentation

WeakCallback

typedef WeakCallbackData<Value, void>::Callback v8::V8::WeakCallback

private

Definition at line 5249 of file v8.h.

Constructor & Destructor Documentation

V8()

v8::V8::V8 ( )

private

Member Function Documentation

AddGCEpilogueCallback()

void v8::V8::AddGCEpilogueCallback ( GCEpilogueCallback  callback, GCType  gc_type_filter = kGCTypeAll  )

static

Enables the host application to receive a notification after a garbage collection.

Allocations are not allowed in the callback function, you therefore cannot manipulate objects (set or delete properties for example) since it is possible such operations will result in the allocation of objects. It is possible to specify the GCType filter for your callback. But it is not possible to register the same callback function two times with different GCType filters.

Definition at line 6494 of file api.cc.

                                                                          {
  i::Isolate* isolate = i::Isolate::Current();
  isolate->heap()->AddGCEpilogueCallback(
      reinterpret_cast<v8::Isolate::GCEpilogueCallback>(callback),
      gc_type,
      false);
}

References v8::internal::Heap::AddGCEpilogueCallback(), and v8::internal::Isolate::heap().

Here is the call graph for this function:

AddGCPrologueCallback()

void v8::V8::AddGCPrologueCallback ( GCPrologueCallback  callback, GCType  gc_type_filter = kGCTypeAll  )

static

Enables the host application to receive a notification before a garbage collection.

Allocations are not allowed in the callback function, you therefore cannot manipulate objects (set or delete properties for example) since it is possible such operations will result in the allocation of objects. It is possible to specify the GCType filter for your callback. But it is not possible to register the same callback function two times with different GCType filters.

Definition at line 6478 of file api.cc.

                                                                          {
  i::Isolate* isolate = i::Isolate::Current();
  isolate->heap()->AddGCPrologueCallback(
      reinterpret_cast<v8::Isolate::GCPrologueCallback>(callback),
      gc_type,
      false);
}

References v8::internal::Heap::AddGCPrologueCallback(), and v8::internal::Isolate::heap().

Here is the call graph for this function:

AddMemoryAllocationCallback()

void v8::V8::AddMemoryAllocationCallback ( MemoryAllocationCallback  callback, ObjectSpace  space, AllocationAction  action  )

static

Enables the host application to provide a mechanism to be notified and perform custom logging when V8 Allocates Executable Memory.

Definition at line 6510 of file api.cc.

                                                              {
  i::Isolate* isolate = i::Isolate::Current();
  isolate->memory_allocator()->AddMemoryAllocationCallback(
      callback, space, action);
}

References v8::internal::MemoryAllocator::AddMemoryAllocationCallback(), v8::internal::Isolate::memory_allocator(), and space().

Here is the call graph for this function:

AddMessageListener()

bool v8::V8::AddMessageListener ( MessageCallback  that, Handle< Value >  data = Handle<Value>()  )

static

Adds a message listener.

The same message listener can be added more than once and in that case it will be called more than once for each message.

If data is specified, it will be passed to the callback when it is called. Otherwise, the exception object will be passed to the callback instead.

Definition at line 6307 of file api.cc.

                                                                    {
  i::Isolate* isolate = i::Isolate::Current();
  ON_BAILOUT(isolate, "v8::V8::AddMessageListener()", return false);
  ENTER_V8(isolate);
  i::HandleScope scope(isolate);
  NeanderArray listeners(isolate->factory()->message_listeners());
  NeanderObject obj(isolate, 2);
  obj.set(0, *isolate->factory()->NewForeign(FUNCTION_ADDR(that)));
  obj.set(1, data.IsEmpty() ? isolate->heap()->undefined_value()
          : *Utils::OpenHandle(*data));
  listeners.add(obj.value());
  return true;
}

References v8::NeanderArray::add(), ENTER_V8, v8::internal::Isolate::factory(), FUNCTION_ADDR, v8::internal::Isolate::heap(), v8::Handle< T >::IsEmpty(), ON_BAILOUT, v8::Utils::OpenHandle(), v8::NeanderObject::set(), and v8::NeanderObject::value().

Here is the call graph for this function:

CancelTerminateExecution()

void v8::V8::CancelTerminateExecution ( Isolate *  isolate )

static

Resume execution capability in the given isolate, whose execution was previously forcefully terminated using TerminateExecution().

When execution is forcefully terminated using TerminateExecution(), the isolate can not resume execution until all JavaScript frames have propagated the uncatchable exception which is generated. This method allows the program embedding the engine to handle the termination event and resume execution capability, even if JavaScript frames remain on the stack.

This method can be used by any thread even if that thread has not acquired the V8 lock with a Locker object.

Parameters

isolate

The isolate in which to resume execution capability.

Definition at line 6539 of file api.cc.

                                                  {
  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
  i_isolate->stack_guard()->ClearTerminateExecution();
  i_isolate->CancelTerminateExecution();
}

References v8::internal::Isolate::CancelTerminateExecution(), and v8::internal::Isolate::stack_guard().

Here is the call graph for this function:

ClearWeak()

void * v8::V8::ClearWeak ( internal::Object **  global_handle )

staticprivate

Definition at line 520 of file api.cc.

                                 {
  return i::GlobalHandles::ClearWeakness(obj);
}

References v8::internal::GlobalHandles::ClearWeakness().

Referenced by v8::PersistentBase< T >::ClearWeak().

Here is the call graph for this function:

Here is the caller graph for this function:

CopyPersistent()

i::Object ** v8::V8::CopyPersistent ( internal::Object **  handle )

staticprivate

Definition at line 504 of file api.cc.

                                          {
  i::Handle<i::Object> result = i::GlobalHandles::CopyGlobal(obj);
#ifdef DEBUG
  (*obj)->ObjectVerify();
#endif  // DEBUG
  return result.location();
}

References v8::internal::GlobalHandles::CopyGlobal().

Referenced by v8::Persistent< T, M >::Copy().

Here is the call graph for this function:

Here is the caller graph for this function:

Dispose()

bool v8::V8::Dispose ( )

static

Releases any resources used by v8 and stops any utility threads that may be running.

Note that disposing v8 is permanent, it cannot be reinitialized.

It should generally not be necessary to dispose v8 before exiting a process, this should happen automatically. It is only necessary to use if the process needs the resources taken up by v8.

Definition at line 5084 of file api.cc.

                   {
  i::V8::TearDown();
  return true;
}

References v8::internal::V8::TearDown().

Referenced by main(), v8::Shell::Main(), and anonymous_namespace{run-all-unittests.cc}::FINAL::TearDown().

Here is the call graph for this function:

Here is the caller graph for this function:

DisposeGlobal()

void v8::V8::DisposeGlobal ( internal::Object **  global_handle )

staticprivate

Definition at line 525 of file api.cc.

                                    {
  i::GlobalHandles::Destroy(obj);
}

References v8::internal::GlobalHandles::Destroy().

Referenced by v8::PersistentBase< T >::Reset().

Here is the call graph for this function:

Here is the caller graph for this function:

Eternalize()

void v8::V8::Eternalize ( Isolate *  isolate, Value *  handle, int *  index  )

staticprivate

Definition at line 530 of file api.cc.

                                                                 {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
  i::Object* object = *Utils::OpenHandle(value);
  isolate->eternal_handles()->Create(isolate, object, index);
}

References v8::internal::EternalHandles::Create(), v8::internal::Isolate::eternal_handles(), and v8::Utils::OpenHandle().

Referenced by v8::Eternal< T >::Set().

Here is the call graph for this function:

Here is the caller graph for this function:

GetCompressedStartupData()

void v8::V8::GetCompressedStartupData ( StartupData *  compressed_data )

static

Definition at line 273 of file api.cc.

                                                              {
#ifdef COMPRESS_STARTUP_DATA_BZ2
  compressed_data[kSnapshot].data =
      reinterpret_cast<const char*>(i::Snapshot::data());
  compressed_data[kSnapshot].compressed_size = i::Snapshot::size();
  compressed_data[kSnapshot].raw_size = i::Snapshot::raw_size();
 
  compressed_data[kSnapshotContext].data =
      reinterpret_cast<const char*>(i::Snapshot::context_data());
  compressed_data[kSnapshotContext].compressed_size =
      i::Snapshot::context_size();
  compressed_data[kSnapshotContext].raw_size = i::Snapshot::context_raw_size();
 
  i::Vector<const i::byte> libraries_source = i::Natives::GetScriptsSource();
  compressed_data[kLibraries].data =
      reinterpret_cast<const char*>(libraries_source.start());
  compressed_data[kLibraries].compressed_size = libraries_source.length();
  compressed_data[kLibraries].raw_size = i::Natives::GetRawScriptsSize();
 
  i::Vector<const i::byte> exp_libraries_source =
      i::ExperimentalNatives::GetScriptsSource();
  compressed_data[kExperimentalLibraries].data =
      reinterpret_cast<const char*>(exp_libraries_source.start());
  compressed_data[kExperimentalLibraries].compressed_size =
      exp_libraries_source.length();
  compressed_data[kExperimentalLibraries].raw_size =
      i::ExperimentalNatives::GetRawScriptsSize();
#endif
}

References v8::StartupData::compressed_size, v8::internal::Snapshot::context_data(), v8::internal::Snapshot::context_raw_size(), v8::internal::Snapshot::context_size(), v8::StartupData::data, v8::internal::Snapshot::data(), v8::internal::NativesCollection< type >::GetRawScriptsSize(), v8::internal::NativesCollection< type >::GetScriptsSource(), v8::kExperimentalLibraries, v8::kLibraries, v8::kSnapshot, v8::kSnapshotContext, v8::internal::Vector< T >::length(), v8::StartupData::raw_size, v8::internal::Snapshot::raw_size(), v8::internal::Snapshot::size(), and v8::internal::Vector< T >::start().

Referenced by v8::StartupDataDecompressor::Decompress().

Here is the call graph for this function:

Here is the caller graph for this function:

GetCompressedStartupDataAlgorithm()

StartupData::CompressionAlgorithm v8::V8::GetCompressedStartupDataAlgorithm ( )

static

The following 4 functions are to be used when V8 is built with the 'compress_startup_data' flag enabled.

In this case, the embedder must decompress startup data prior to initializing V8.

This is how interaction with V8 should look like: int compressed_data_count = v8::V8::GetCompressedStartupDataCount(); v8::StartupData* compressed_data = new v8::StartupData[compressed_data_count]; v8::V8::GetCompressedStartupData(compressed_data); ... decompress data (compressed_data can be updated in-place) ... v8::V8::SetDecompressedStartupData(compressed_data); ... now V8 can be initialized ... make sure the decompressed data stays valid until V8 shutdown

A helper class StartupDataDecompressor is provided. It implements the protocol of the interaction described above, and can be used in most cases instead of calling these API functions directly.

Definition at line 246 of file api.cc.

                                                                      {
#ifdef COMPRESS_STARTUP_DATA_BZ2
  return StartupData::kBZip2;
#else
  return StartupData::kUncompressed;
#endif
}

References v8::StartupData::kBZip2, and v8::StartupData::kUncompressed.

GetCompressedStartupDataCount()

int v8::V8::GetCompressedStartupDataCount ( )

static

Definition at line 264 of file api.cc.

                                      {
#ifdef COMPRESS_STARTUP_DATA_BZ2
  return kCompressedStartupDataCount;
#else
  return 0;
#endif
}

References v8::kCompressedStartupDataCount.

Referenced by v8::StartupDataDecompressor::Decompress(), v8::StartupDataDecompressor::StartupDataDecompressor(), and v8::StartupDataDecompressor::~StartupDataDecompressor().

Here is the caller graph for this function:

GetEternal()

Local< Value > v8::V8::GetEternal ( Isolate *  isolate, int  index  )

staticprivate

Definition at line 537 of file api.cc.

                                                          {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
  return Utils::ToLocal(isolate->eternal_handles()->Get(index));
}

References v8::internal::Isolate::eternal_handles(), v8::internal::EternalHandles::Get(), and v8::Utils::ToLocal().

Referenced by v8::Eternal< T >::Get().

Here is the call graph for this function:

Here is the caller graph for this function:

GetVersion()

const char * v8::V8::GetVersion ( )

static

Get the version string.

Definition at line 5146 of file api.cc.

                             {
  return i::Version::GetVersion();
}

References v8::internal::Version::GetVersion().

Referenced by v8::Shell::RunShell(), v8::internal::RUNTIME_FUNCTION(), and v8::Shell::Version().

Here is the call graph for this function:

Here is the caller graph for this function:

GlobalizeReference()

i::Object ** v8::V8::GlobalizeReference ( internal::Isolate *  isolate, internal::Object **  handle  )

staticprivate

Definition at line 494 of file api.cc.

                                                                 {
  LOG_API(isolate, "Persistent::New");
  i::Handle<i::Object> result = isolate->global_handles()->Create(*obj);
#ifdef DEBUG
  (*obj)->ObjectVerify();
#endif  // DEBUG
  return result.location();
}

References v8::internal::GlobalHandles::Create(), v8::internal::Isolate::global_handles(), and LOG_API.

Referenced by v8::PersistentBase< T >::New().

Here is the call graph for this function:

Here is the caller graph for this function:

Initialize()

bool v8::V8::Initialize ( )

static

Initializes V8.

This function needs to be called before the first Isolate is created. It always returns true.

Definition at line 5058 of file api.cc.

                      {
  i::V8::Initialize();
  return true;
}

References v8::internal::V8::Initialize().

Referenced by v8::Locker::Initialize(), main(), v8::Shell::Main(), and anonymous_namespace{run-all-unittests.cc}::FINAL::SetUp().

Here is the call graph for this function:

Here is the caller graph for this function:

InitializeICU()

bool v8::V8::InitializeICU ( const char *  icu_data_file = NULL )

static

Initialize the ICU library bundled with V8.

The embedder should only invoke this method when using the bundled ICU. Returns true on success.

If V8 was compiled with the ICU data in an external file, the location of the data file has to be provided.

Definition at line 5141 of file api.cc.

                                                  {
  return i::InitializeICU(icu_data_file);
}

References v8::internal::InitializeICU().

Referenced by main(), and v8::Shell::Main().

Here is the call graph for this function:

Here is the caller graph for this function:

InitializePlatform()

void v8::V8::InitializePlatform ( Platform *  platform )

static

Sets the v8::Platform to use.

This should be invoked before V8 is initialized.

Definition at line 5048 of file api.cc.

                                                {
  i::V8::InitializePlatform(platform);
}

References v8::internal::V8::InitializePlatform().

Referenced by main(), v8::Shell::Main(), and anonymous_namespace{run-all-unittests.cc}::FINAL::SetUp().

Here is the call graph for this function:

Here is the caller graph for this function:

IsDead()

bool v8::V8::IsDead ( )

static

Check if V8 is dead and therefore unusable.

This is the case after fatal errors such as out-of-memory situations.

Definition at line 189 of file api.cc.

                {
  i::Isolate* isolate = i::Isolate::Current();
  return isolate->IsDead();
}

References v8::internal::Isolate::IsDead().

Here is the call graph for this function:

IsExecutionTerminating()

bool v8::V8::IsExecutionTerminating ( Isolate *  isolate = NULL )

static

Is V8 terminating JavaScript execution.

Returns true if JavaScript execution is currently terminating because of a call to TerminateExecution. In that case there are still JavaScript frames on the stack and the termination exception is still active.

Parameters

isolate

The isolate in which to check.

Definition at line 6532 of file api.cc.

                                                {
  i::Isolate* i_isolate = isolate != NULL ?
      reinterpret_cast<i::Isolate*>(isolate) : i::Isolate::Current();
  return IsExecutionTerminatingCheck(i_isolate);
}

References v8::IsExecutionTerminatingCheck(), and NULL.

Here is the call graph for this function:

MakeWeak()

void v8::V8::MakeWeak ( internal::Object **  global_handle, void *  data, WeakCallback  weak_callback  )

staticprivate

Definition at line 513 of file api.cc.

                                              {
  i::GlobalHandles::MakeWeak(object, parameters, weak_callback);
}

References v8::internal::GlobalHandles::MakeWeak().

Referenced by v8::PersistentBase< T >::SetWeak().

Here is the call graph for this function:

Here is the caller graph for this function:

RemoveGCEpilogueCallback()

void v8::V8::RemoveGCEpilogueCallback ( GCEpilogueCallback  callback )

static

This function removes callback which was installed by AddGCEpilogueCallback function.

Definition at line 6503 of file api.cc.

                                                             {
  i::Isolate* isolate = i::Isolate::Current();
  isolate->heap()->RemoveGCEpilogueCallback(
      reinterpret_cast<v8::Isolate::GCEpilogueCallback>(callback));
}

References v8::internal::Isolate::heap(), and v8::internal::Heap::RemoveGCEpilogueCallback().

Here is the call graph for this function:

RemoveGCPrologueCallback()

void v8::V8::RemoveGCPrologueCallback ( GCPrologueCallback  callback )

static

This function removes callback which was installed by AddGCPrologueCallback function.

Definition at line 6487 of file api.cc.

                                                             {
  i::Isolate* isolate = i::Isolate::Current();
  isolate->heap()->RemoveGCPrologueCallback(
      reinterpret_cast<v8::Isolate::GCPrologueCallback>(callback));
}

References v8::internal::Isolate::heap(), and v8::internal::Heap::RemoveGCPrologueCallback().

Here is the call graph for this function:

RemoveMemoryAllocationCallback()

void v8::V8::RemoveMemoryAllocationCallback ( MemoryAllocationCallback  callback )

static

Removes callback that was installed by AddMemoryAllocationCallback.

Definition at line 6519 of file api.cc.

                                                                         {
  i::Isolate* isolate = i::Isolate::Current();
  isolate->memory_allocator()->RemoveMemoryAllocationCallback(
      callback);
}

References v8::internal::Isolate::memory_allocator(), and v8::internal::MemoryAllocator::RemoveMemoryAllocationCallback().

Here is the call graph for this function:

RemoveMessageListeners()

void v8::V8::RemoveMessageListeners ( MessageCallback  that )

static

Remove all message listeners from the specified callback function.

Definition at line 6322 of file api.cc.

                                                    {
  i::Isolate* isolate = i::Isolate::Current();
  ON_BAILOUT(isolate, "v8::V8::RemoveMessageListeners()", return);
  ENTER_V8(isolate);
  i::HandleScope scope(isolate);
  NeanderArray listeners(isolate->factory()->message_listeners());
  for (int i = 0; i < listeners.length(); i++) {
    if (listeners.get(i)->IsUndefined()) continue;  // skip deleted ones
 
    NeanderObject listener(i::JSObject::cast(listeners.get(i)));
    i::Handle<i::Foreign> callback_obj(i::Foreign::cast(listener.get(0)));
    if (callback_obj->foreign_address() == FUNCTION_ADDR(that)) {
      listeners.set(i, isolate->heap()->undefined_value());
    }
  }
}

References ENTER_V8, v8::internal::Isolate::factory(), FUNCTION_ADDR, v8::NeanderObject::get(), v8::NeanderArray::get(), v8::internal::Isolate::heap(), v8::NeanderArray::length(), ON_BAILOUT, and v8::NeanderArray::set().

Here is the call graph for this function:

SetAllowCodeGenerationFromStringsCallback()

void v8::V8::SetAllowCodeGenerationFromStringsCallback ( AllowCodeGenerationFromStringsCallback  that )

static

Set the callback to invoke to check if code generation from strings should be allowed.

Definition at line 357 of file api.cc.

                                                     {
  i::Isolate* isolate = i::Isolate::Current();
  isolate->set_allow_code_gen_callback(callback);
}

SetArrayBufferAllocator()

void v8::V8::SetArrayBufferAllocator ( ArrayBuffer::Allocator *  allocator )

static

Set allocator to use for ArrayBuffer memory.

The allocator should be set only once. The allocator should be set before any code tha uses ArrayBuffers is executed. This allocator is used in all isolates.

Definition at line 5074 of file api.cc.

                                     {
  if (!Utils::ApiCheck(i::V8::ArrayBufferAllocator() == NULL,
                       "v8::V8::SetArrayBufferAllocator",
                       "ArrayBufferAllocator might only be set once"))
    return;
  i::V8::SetArrayBufferAllocator(allocator);
}

References v8::Utils::ApiCheck(), v8::internal::V8::ArrayBufferAllocator(), NULL, and v8::internal::V8::SetArrayBufferAllocator().

Referenced by v8::Shell::Main().

Here is the call graph for this function:

Here is the caller graph for this function:

SetCaptureStackTraceForUncaughtExceptions()

void v8::V8::SetCaptureStackTraceForUncaughtExceptions ( bool  capture, int  frame_limit = 10, StackTrace::StackTraceOptions  options = StackTrace::kOverview  )

static

Tells V8 to capture current stack trace when uncaught exception occurs and report it to the message listeners.

The option is off by default.

Definition at line 6340 of file api.cc.

                                         {
  i::Isolate::Current()->SetCaptureStackTraceForUncaughtExceptions(
      capture,
      frame_limit,
      options);
}

Referenced by main().

Here is the caller graph for this function:

SetDecompressedStartupData()

void v8::V8::SetDecompressedStartupData ( StartupData *  decompressed_data )

static

Definition at line 304 of file api.cc.

                                                                  {
#ifdef COMPRESS_STARTUP_DATA_BZ2
  DCHECK_EQ(i::Snapshot::raw_size(), decompressed_data[kSnapshot].raw_size);
  i::Snapshot::set_raw_data(
      reinterpret_cast<const i::byte*>(decompressed_data[kSnapshot].data));
 
  DCHECK_EQ(i::Snapshot::context_raw_size(),
            decompressed_data[kSnapshotContext].raw_size);
  i::Snapshot::set_context_raw_data(
      reinterpret_cast<const i::byte*>(
          decompressed_data[kSnapshotContext].data));
 
  DCHECK_EQ(i::Natives::GetRawScriptsSize(),
            decompressed_data[kLibraries].raw_size);
  i::Vector<const char> libraries_source(
      decompressed_data[kLibraries].data,
      decompressed_data[kLibraries].raw_size);
  i::Natives::SetRawScriptsSource(libraries_source);
 
  DCHECK_EQ(i::ExperimentalNatives::GetRawScriptsSize(),
            decompressed_data[kExperimentalLibraries].raw_size);
  i::Vector<const char> exp_libraries_source(
      decompressed_data[kExperimentalLibraries].data,
      decompressed_data[kExperimentalLibraries].raw_size);
  i::ExperimentalNatives::SetRawScriptsSource(exp_libraries_source);
#endif
}

References v8::internal::Snapshot::context_raw_size(), DCHECK_EQ, v8::internal::NativesCollection< type >::GetRawScriptsSize(), v8::kExperimentalLibraries, v8::kLibraries, v8::kSnapshot, v8::kSnapshotContext, v8::internal::Snapshot::raw_size(), v8::internal::Snapshot::set_context_raw_data(), v8::internal::Snapshot::set_raw_data(), and v8::internal::NativesCollection< type >::SetRawScriptsSource().

Referenced by v8::StartupDataDecompressor::Decompress().

Here is the call graph for this function:

Here is the caller graph for this function:

SetEntropySource()

void v8::V8::SetEntropySource ( EntropySource  source )

static

Allows the host application to provide a callback which can be used as a source of entropy for random number generators.

Definition at line 5064 of file api.cc.

                                                        {
  base::RandomNumberGenerator::SetEntropySource(entropy_source);
}

References v8::base::entropy_source.

SetFailedAccessCheckCallbackFunction()

void v8::V8::SetFailedAccessCheckCallbackFunction ( FailedAccessCheckCallback  callback )

static

Callback function for reporting failed access checks.

Definition at line 6351 of file api.cc.

                                        {
  i::Isolate* isolate = i::Isolate::Current();
  isolate->SetFailedAccessCheckCallback(callback);
}

References v8::internal::Isolate::SetFailedAccessCheckCallback().

Here is the call graph for this function:

SetFatalErrorHandler()

void v8::V8::SetFatalErrorHandler ( FatalErrorCallback  that )

static

Set the callback to invoke in case of fatal errors.

Definition at line 351 of file api.cc.

                                                     {
  i::Isolate* isolate = i::Isolate::Current();
  isolate->set_exception_behavior(that);
}

SetFlagsFromCommandLine()

void v8::V8::SetFlagsFromCommandLine ( int *  argc, char **  argv, bool  remove_flags  )

static

Sets V8 flags from the command line.

Definition at line 369 of file api.cc.

                                                                          {
  i::FlagList::SetFlagsFromCommandLine(argc, argv, remove_flags);
}

References v8::internal::FlagList::SetFlagsFromCommandLine().

Referenced by main(), and v8::Shell::SetOptions().

Here is the call graph for this function:

Here is the caller graph for this function:

SetFlagsFromString()

void v8::V8::SetFlagsFromString ( const char *  str, int  length  )

static

Sets V8 flags from a string.

Definition at line 364 of file api.cc.

                                                       {
  i::FlagList::SetFlagsFromString(str, length);
}

References v8::internal::FlagList::SetFlagsFromString().

Referenced by vTune::InitializeVtuneForV8(), and v8::SetFlagsFromString().

Here is the call graph for this function:

Here is the caller graph for this function:

SetNativesDataBlob()

void v8::V8::SetNativesDataBlob ( StartupData *  startup_blob )

static

Hand startup data to V8, in case the embedder has chosen to build V8 with external startup data.

Note:

• By default the startup data is linked into the V8 library, in which case this function is not meaningful.
• If this needs to be called, it needs to be called before V8 tries to make use of its built-ins.
• To avoid unnecessary copies of data, V8 will point directly into the given data blob, so pretty please keep it around until V8 exit.
• Compression of the startup blob might be useful, but needs to handled entirely on the embedders' side.
• The call will abort if the data is invalid.

Definition at line 333 of file api.cc.

                                                     {
#ifdef V8_USE_EXTERNAL_STARTUP_DATA
  i::SetNativesFromFile(natives_blob);
#else
  CHECK(false);
#endif
}

References CHECK, and v8::internal::SetNativesFromFile().

Here is the call graph for this function:

SetReturnAddressLocationResolver()

void v8::V8::SetReturnAddressLocationResolver ( ReturnAddressLocationResolver  return_address_resolver )

static

Allows the host application to provide a callback that allows v8 to cooperate with a profiler that rewrites return addresses on stack.

Definition at line 5069 of file api.cc.

                                                           {
  i::V8::SetReturnAddressLocationResolver(return_address_resolver);
}

References v8::internal::V8::SetReturnAddressLocationResolver().

Here is the call graph for this function:

SetSnapshotDataBlob()

void v8::V8::SetSnapshotDataBlob ( StartupData *  startup_blob )

static

Definition at line 342 of file api.cc.

                                                       {
#ifdef V8_USE_EXTERNAL_STARTUP_DATA
  i::SetSnapshotFromFile(snapshot_blob);
#else
  CHECK(false);
#endif
}

References CHECK, and v8::internal::SetSnapshotFromFile().

Here is the call graph for this function:

ShutdownPlatform()

void v8::V8::ShutdownPlatform ( )

static

Clears all references to the v8::Platform.

This should be invoked after V8 was disposed.

Definition at line 5053 of file api.cc.

                            {
  i::V8::ShutdownPlatform();
}

References v8::internal::V8::ShutdownPlatform().

Referenced by main(), v8::Shell::Main(), and anonymous_namespace{run-all-unittests.cc}::FINAL::TearDown().

Here is the call graph for this function:

Here is the caller graph for this function:

TerminateExecution()

void v8::V8::TerminateExecution ( Isolate *  isolate )

static

Forcefully terminate the current thread of JavaScript execution in the given isolate.

This method can be used by any thread even if that thread has not acquired the V8 lock with a Locker object.

Parameters

isolate

The isolate in which to terminate the current JS execution.

Definition at line 6526 of file api.cc.

                                            {
  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
  i_isolate->stack_guard()->RequestTerminateExecution();
}

References v8::internal::Isolate::stack_guard().

Here is the call graph for this function:

VisitExternalResources()

void v8::V8::VisitExternalResources ( ExternalResourceVisitor *  visitor )

static

Iterates through all external resources referenced from current isolate heap.

GC is not invoked prior to iterating, therefore there is no guarantee that visited objects are still alive.

Definition at line 5097 of file api.cc.

                                                                  {
  i::Isolate* isolate = i::Isolate::Current();
  isolate->heap()->VisitExternalResources(visitor);
}

References v8::internal::Isolate::heap(), and v8::internal::Heap::VisitExternalResources().

Here is the call graph for this function:

VisitHandlesForPartialDependence()

void v8::V8::VisitHandlesForPartialDependence ( Isolate *  isolate, PersistentHandleVisitor *  visitor  )

static

Iterates through all the persistent handles in the current isolate's heap that have class_ids and are candidates to be marked as partially dependent handles.

This will visit handles to young objects created since the last garbage collection but is free to visit an arbitrary superset of these objects.

Definition at line 5129 of file api.cc.

                                                                 {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(exported_isolate);
  DCHECK(isolate == i::Isolate::Current());
  i::DisallowHeapAllocation no_allocation;
 
  VisitorAdapter visitor_adapter(visitor);
  isolate->global_handles()->IterateAllRootsInNewSpaceWithClassIds(
      &visitor_adapter);
}

References DCHECK, v8::internal::Isolate::global_handles(), and v8::internal::GlobalHandles::IterateAllRootsInNewSpaceWithClassIds().

Here is the call graph for this function:

VisitHandlesWithClassIds()

void v8::V8::VisitHandlesWithClassIds ( PersistentHandleVisitor *  visitor )

static

Iterates through all the persistent handles in the current isolate's heap that have class_ids.

Definition at line 5120 of file api.cc.

                                                                    {
  i::Isolate* isolate = i::Isolate::Current();
  i::DisallowHeapAllocation no_allocation;
 
  VisitorAdapter visitor_adapter(visitor);
  isolate->global_handles()->IterateAllRootsWithClassIds(&visitor_adapter);
}

References v8::internal::Isolate::global_handles(), and v8::internal::GlobalHandles::IterateAllRootsWithClassIds().

Here is the call graph for this function:

Friends And Related Function Documentation

Context

friend class Context

friend

Definition at line 5264 of file v8.h.

Eternal

template<class T >

friend class Eternal

friend

Definition at line 5261 of file v8.h.

Handle

template<class T >

friend class Handle

friend

Definition at line 5259 of file v8.h.

Local

template<class T >

friend class Local

friend

Definition at line 5260 of file v8.h.

Persistent

template<class T , class M >

friend class Persistent

friend

Definition at line 5263 of file v8.h.

PersistentBase

template<class T >

friend class PersistentBase

friend

Definition at line 5262 of file v8.h.

---

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

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