v8
3.11.10 (node 0.8.28)
V8 is Google's open source JavaScript engine
|
#include <v8.h>
Friends | |
template<class T > | |
class | Handle |
template<class T > | |
class | Local |
template<class T > | |
class | Persistent |
class | Context |
|
static |
Adds a callback to notify the host application when a script finished running. If a script re-enters the runtime during executing, the CallCompletedCallback is only invoked when the outer-most script execution ends. Executing scripts inside the callback do not trigger further callbacks.
|
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 |
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 |
Allows the host application to declare implicit references between the objects: if |parent| is alive, all |children| are alive too. After each garbage collection, all implicit references are removed. It is intended to be used in the before-garbage-collection callback function.
|
static |
Enables the host application to provide a mechanism to be notified and perform custom logging when V8 Allocates Executable Memory.
|
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.
|
static |
Allows the host application to group objects together. If one object in the group is alive, all objects in the group are alive. After each garbage collection, object groups are removed. It is intended to be used in the before-garbage-collection callback function, for instance to simulate DOM tree connections among JS wrapper objects. See v8-profiler.h for RetainedObjectInfo interface description.
|
static |
Adjusts the amount of registered external memory. Used to give V8 an indication of the amount of externally allocated memory that is kept alive by JavaScript objects. V8 uses this to decide when to perform global garbage collections. Registering externally allocated memory will trigger global garbage collections more often than otherwise in an attempt to garbage collect the JavaScript objects keeping the externally allocated memory alive.
change_in_bytes | the change in externally allocated memory that is kept alive by JavaScript objects. |
|
static |
|
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 |
Enables the computation of a sliding window of states. The sliding window information is recorded in statistics counters.
|
static |
|
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 |
|
static |
|
static |
Get statistics about the heap memory usage.
|
static |
Get the version string.
|
static |
Optional notification that the embedder is idle. V8 uses the notification to reduce memory footprint. This call can be used repeatedly if the embedder remains idle. Returns true if the embedder should stop calling IdleNotification until real work has been done. This indicates that V8 has done as much cleanup as it will be able to do.
The hint argument specifies the amount of work to be done in the function on scale from 1 to 1000. There is no guarantee that the actual work will match the hint.
|
static |
Ignore out-of-memory exceptions.
V8 running out of memory is treated as a fatal error by default. This means that the fatal error handler is called and that V8 is terminated.
IgnoreOutOfMemoryException can be used to not treat an out-of-memory situation as a fatal error. This way, the contexts that did not cause the out of memory problem might be able to continue execution.
|
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 |
Check if V8 is dead and therefore unusable. This is the case after fatal errors such as out-of-memory situations.
|
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.
isolate | The isolate in which to check. |
|
static |
Return whether profiler is currently paused.
|
static |
Optional notification that the system is running low on memory. V8 uses these notifications to attempt to free memory.
|
static |
Suspends recording of tick samples in the profiler. When the V8 profiling mode is enabled (usually via command line switches) this function suspends recording of tick samples. Profiling ticks are discarded until ResumeProfiler() is called.
See also the –prof and –prof_auto command line switches to enable V8 profiling.
|
static |
Removes callback that was installed by AddCallCompletedCallback.
|
static |
This function removes callback which was installed by AddGCEpilogueCallback function.
|
static |
This function removes callback which was installed by AddGCPrologueCallback function.
|
static |
Removes callback that was installed by AddMemoryAllocationCallback.
|
static |
Remove all message listeners from the specified callback function.
|
static |
Resumes recording of tick samples in the profiler. See also PauseProfiler().
|
static |
|
static |
Set the callback to invoke to check if code generation from strings should be allowed.
|
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 |
Enables the host application to provide a mechanism for recording statistics counters.
|
static |
Enables the host application to provide a mechanism for recording histograms. The CreateHistogram function returns a histogram which will later be passed to the AddHistogramSample function.
|
static |
|
static |
Allows the host application to provide a callback which can be used as a source of entropy for random number generators.
|
static |
Callback function for reporting failed access checks.
|
static |
Set the callback to invoke in case of fatal errors.
|
static |
Sets V8 flags from the command line.
|
static |
Sets V8 flags from a string.
|
static |
The function is deprecated. Please use AddGCEpilogueCallback instead. Enables the host application to receive a notification after a major 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.
|
static |
The function is deprecated. Please use AddGCPrologueCallback instead. 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.
|
static |
Allows the host application to provide a callback that allows v8 to cooperate with a profiler that rewrites return addresses on stack.
|
static |
Forcefully terminate execution of a JavaScript thread. This can be used to terminate long-running scripts.
TerminateExecution should only be called when then V8 lock has been acquired with a Locker object. Therefore, in order to be able to terminate long-running threads, preemption must be enabled to allow the user of TerminateExecution to acquire the lock.
The termination is achieved by throwing an exception that is uncatchable by JavaScript exception handlers. Termination exceptions act as if they were caught by a C++ TryCatch exception handler. If forceful termination is used, any C++ TryCatch exception handler that catches an exception should check if that exception is a termination exception and immediately return if that is the case. Returning immediately in that case will continue the propagation of the termination exception if needed.
The thread id passed to TerminateExecution must have been obtained by calling GetCurrentThreadId on the thread in question.
thread_id | The thread id of the thread to terminate. |
|
static |
Forcefully terminate the current thread of JavaScript execution in the given isolate. If no isolate is provided, the default isolate is used.
This method can be used by any thread even if that thread has not acquired the V8 lock with a Locker object.
isolate | The isolate in which to terminate the current JS execution. |
|
static |
Iterates through all external resources referenced from current isolate heap. This method is not expected to be used except for debugging purposes and may be quite slow.
|
friend |
Definition at line 3344 of file v8.h.
Referenced by Handle< T >::As(), Handle< T >::Cast(), v8::False(), Extension::GetNativeFunction(), Local< T >::Local(), v8::Null(), Persistent< T >::Persistent(), v8::True(), and v8::Undefined().
|
friend |
Definition at line 3345 of file v8.h.
Referenced by Local< T >::As(), Arguments::Callee(), Local< T >::Cast(), HandleScope::Close(), Arguments::Data(), AccessorInfo::Data(), String::Empty(), Object::GetInternalField(), Arguments::Holder(), AccessorInfo::Holder(), Local< T >::New(), Arguments::operator[](), Arguments::This(), and AccessorInfo::This().
|
friend |
Definition at line 3346 of file v8.h.
Referenced by Persistent< T >::As(), Persistent< T >::Cast(), and Persistent< T >::New().