v8  3.28.71(node0.12.18)
V8 is Google's open source JavaScript engine
V8 Class Reference

#include <v8.h>

Static Public Member Functions

static void SetFatalErrorHandler (FatalErrorCallback that)
 
static void SetAllowCodeGenerationFromStringsCallback (AllowCodeGenerationFromStringsCallback that)
 
static void SetArrayBufferAllocator (ArrayBuffer::Allocator *allocator)
 
static bool IsDead ()
 
static StartupData::CompressionAlgorithm GetCompressedStartupDataAlgorithm ()
 
static int GetCompressedStartupDataCount ()
 
static void GetCompressedStartupData (StartupData *compressed_data)
 
static void SetDecompressedStartupData (StartupData *decompressed_data)
 
static void SetNativesDataBlob (StartupData *startup_blob)
 
static void SetSnapshotDataBlob (StartupData *startup_blob)
 
static bool AddMessageListener (MessageCallback that, Handle< Value > data=Handle< Value >())
 
static void RemoveMessageListeners (MessageCallback that)
 
static void SetCaptureStackTraceForUncaughtExceptions (bool capture, int frame_limit=10, StackTrace::StackTraceOptions options=StackTrace::kOverview)
 
static void SetFlagsFromString (const char *str, int length)
 
static void SetFlagsFromCommandLine (int *argc, char **argv, bool remove_flags)
 
static const char * GetVersion ()
 
static void SetFailedAccessCheckCallbackFunction (FailedAccessCheckCallback)
 
static void AddGCPrologueCallback (GCPrologueCallback callback, GCType gc_type_filter=kGCTypeAll)
 
static void RemoveGCPrologueCallback (GCPrologueCallback callback)
 
static void AddGCEpilogueCallback (GCEpilogueCallback callback, GCType gc_type_filter=kGCTypeAll)
 
static void RemoveGCEpilogueCallback (GCEpilogueCallback callback)
 
static void AddMemoryAllocationCallback (MemoryAllocationCallback callback, ObjectSpace space, AllocationAction action)
 
static void RemoveMemoryAllocationCallback (MemoryAllocationCallback callback)
 
static bool Initialize ()
 
static void SetEntropySource (EntropySource source)
 
static void SetReturnAddressLocationResolver (ReturnAddressLocationResolver return_address_resolver)
 
static bool SetFunctionEntryHook (Isolate *isolate, FunctionEntryHook entry_hook)
 
static void SetJitCodeEventHandler (JitCodeEventOptions options, JitCodeEventHandler event_handler)
 
static void TerminateExecution (Isolate *isolate)
 
static bool IsExecutionTerminating (Isolate *isolate=NULL)
 
static void CancelTerminateExecution (Isolate *isolate)
 
static bool Dispose ()
 
static void VisitExternalResources (ExternalResourceVisitor *visitor)
 
static void VisitHandlesWithClassIds (PersistentHandleVisitor *visitor)
 
static void VisitHandlesForPartialDependence (Isolate *isolate, PersistentHandleVisitor *visitor)
 
static bool InitializeICU (const char *icu_data_file=NULL)
 
static void InitializePlatform (Platform *platform)
 
static void ShutdownPlatform ()
 

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 4693 of file v8.h.

Member Function Documentation

static void 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.

static void 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.

static void 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.

static bool AddMessageListener ( MessageCallback  that,
Handle< Value data = HandleValue >() 
)
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.

static void 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
isolateThe isolate in which to resume execution capability.
static bool 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.

static void GetCompressedStartupData ( StartupData compressed_data)
static
static StartupData::CompressionAlgorithm 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.

static int GetCompressedStartupDataCount ( )
static
static const char* GetVersion ( )
static

Get the version string.

static bool Initialize ( )
static

Initializes from snapshot if possible. Otherwise, attempts to initialize from scratch. This function is called implicitly if you use the API without calling it first.

static bool 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.

static void InitializePlatform ( Platform platform)
static

Sets the v8::Platform to use. This should be invoked before V8 is initialized.

static bool IsDead ( )
static

Check if V8 is dead and therefore unusable. This is the case after fatal errors such as out-of-memory situations.

static bool 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
isolateThe isolate in which to check.
static void RemoveGCEpilogueCallback ( GCEpilogueCallback  callback)
static

This function removes callback which was installed by AddGCEpilogueCallback function.

static void RemoveGCPrologueCallback ( GCPrologueCallback  callback)
static

This function removes callback which was installed by AddGCPrologueCallback function.

static void RemoveMemoryAllocationCallback ( MemoryAllocationCallback  callback)
static

Removes callback that was installed by AddMemoryAllocationCallback.

static void RemoveMessageListeners ( MessageCallback  that)
static

Remove all message listeners from the specified callback function.

static void SetAllowCodeGenerationFromStringsCallback ( AllowCodeGenerationFromStringsCallback  that)
static

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

static void 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.

static void 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.

static void SetDecompressedStartupData ( StartupData decompressed_data)
static
static void 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.

static void SetFailedAccessCheckCallbackFunction ( FailedAccessCheckCallback  )
static

Callback function for reporting failed access checks.

static void SetFatalErrorHandler ( FatalErrorCallback  that)
static

Set the callback to invoke in case of fatal errors.

static void SetFlagsFromCommandLine ( int *  argc,
char **  argv,
bool  remove_flags 
)
static

Sets V8 flags from the command line.

static void SetFlagsFromString ( const char *  str,
int  length 
)
static

Sets V8 flags from a string.

static bool SetFunctionEntryHook ( Isolate isolate,
FunctionEntryHook  entry_hook 
)
static

Allows the host application to provide the address of a function that's invoked on entry to every V8-generated function. Note that entry_hook is invoked at the very start of each generated function.

Parameters
isolatethe isolate to operate on.
entry_hooka function that will be invoked on entry to every V8-generated function.
Returns
true on success on supported platforms, false on failure.
Note
Setting an entry hook can only be done very early in an isolates lifetime, and once set, the entry hook cannot be revoked.
static void SetJitCodeEventHandler ( JitCodeEventOptions  options,
JitCodeEventHandler  event_handler 
)
static

Allows the host application to provide the address of a function that is notified each time code is added, moved or removed.

Parameters
optionsoptions for the JIT code event handler.
event_handlerthe JIT code event handler, which will be invoked each time code is added, moved or removed.
Note
event_handler won't get notified of existent code.
since code removal notifications are not currently issued, the event_handler may get notifications of code that overlaps earlier code notifications. This happens when code areas are reused, and the earlier overlapping code areas should therefore be discarded.
the events passed to event_handler and the strings they point to are not guaranteed to live past each call. The event_handler must copy strings and other parameters it needs to keep around.
the set of events declared in JitCodeEvent::EventType is expected to grow over time, and the JitCodeEvent structure is expected to accrue new members. The event_handler function must ignore event codes it does not recognize to maintain future compatibility.
static void 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.
static void 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.

static void SetSnapshotDataBlob ( StartupData startup_blob)
static
static void ShutdownPlatform ( )
static

Clears all references to the v8::Platform. This should be invoked after V8 was disposed.

static void 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
isolateThe isolate in which to terminate the current JS execution.
static void 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.

static void 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.

static void VisitHandlesWithClassIds ( PersistentHandleVisitor visitor)
static

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

Friends And Related Function Documentation

friend class Context
friend

Definition at line 5033 of file v8.h.

friend class Eternal
friend

Definition at line 5030 of file v8.h.

friend class Handle
friend

Definition at line 5028 of file v8.h.

friend class Local
friend

Definition at line 5029 of file v8.h.

friend class Persistent
friend

Definition at line 5032 of file v8.h.

friend class PersistentBase
friend

Definition at line 5031 of file v8.h.


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