Classes | Public Types | Static Public Member Functions | List of all members
v8::ScriptCompiler Class Reference

#include <v8.h>

Classes

struct  CachedData
 
class  ExternalSourceStream
 
class  ScriptStreamingTask
 
class  Source
 
class  StreamedSource
 

Public Types

enum  CompileOptions { kNoCompileOptions = 0 , kConsumeCodeCache , kEagerCompile }
 
enum  NoCacheReason {
  kNoCacheNoReason = 0 , kNoCacheBecauseCachingDisabled , kNoCacheBecauseNoResource , kNoCacheBecauseInlineScript ,
  kNoCacheBecauseModule , kNoCacheBecauseStreamingSource , kNoCacheBecauseInspector , kNoCacheBecauseScriptTooSmall ,
  kNoCacheBecauseCacheTooCold , kNoCacheBecauseV8Extension , kNoCacheBecauseExtensionModule , kNoCacheBecausePacScript ,
  kNoCacheBecauseInDocumentWrite , kNoCacheBecauseResourceWithNoCacheHandler , kNoCacheBecauseDeferredProduceCodeCache
}
 

Static Public Member Functions

static MaybeLocal< UnboundScriptCompileUnboundScript (Isolate *isolate, Source *source, CompileOptions options=kNoCompileOptions, NoCacheReason no_cache_reason=kNoCacheNoReason)
 
static MaybeLocal< ScriptCompile (Local< Context > context, Source *source, CompileOptions options=kNoCompileOptions, NoCacheReason no_cache_reason=kNoCacheNoReason)
 
static ScriptStreamingTaskStartStreamingScript (Isolate *isolate, StreamedSource *source, CompileOptions options=kNoCompileOptions)
 
static ScriptStreamingTaskStartStreaming (Isolate *isolate, StreamedSource *source, ScriptType type=ScriptType::kClassic)
 
static MaybeLocal< ScriptCompile (Local< Context > context, StreamedSource *source, Local< String > full_source_string, const ScriptOrigin &origin)
 
static uint32_t CachedDataVersionTag ()
 
static MaybeLocal< ModuleCompileModule (Isolate *isolate, Source *source, CompileOptions options=kNoCompileOptions, NoCacheReason no_cache_reason=kNoCacheNoReason)
 
static MaybeLocal< ModuleCompileModule (Local< Context > context, StreamedSource *v8_source, Local< String > full_source_string, const ScriptOrigin &origin)
 
static MaybeLocal< FunctionCompileFunctionInContext (Local< Context > context, Source *source, size_t arguments_count, Local< String > arguments[], size_t context_extension_count, Local< Object > context_extensions[], CompileOptions options=kNoCompileOptions, NoCacheReason no_cache_reason=kNoCacheNoReason, Local< ScriptOrModule > *script_or_module_out=nullptr)
 
static CachedDataCreateCodeCache (Local< UnboundScript > unbound_script)
 
static CachedDataCreateCodeCache (Local< UnboundModuleScript > unbound_module_script)
 
static CachedDataCreateCodeCacheForFunction (Local< Function > function)
 

Detailed Description

For compiling scripts.

Member Enumeration Documentation

◆ CompileOptions

Enumerator
kNoCompileOptions 
kConsumeCodeCache 
kEagerCompile 

◆ NoCacheReason

The reason for which we are not requesting or providing a code cache.

Enumerator
kNoCacheNoReason 
kNoCacheBecauseCachingDisabled 
kNoCacheBecauseNoResource 
kNoCacheBecauseInlineScript 
kNoCacheBecauseModule 
kNoCacheBecauseStreamingSource 
kNoCacheBecauseInspector 
kNoCacheBecauseScriptTooSmall 
kNoCacheBecauseCacheTooCold 
kNoCacheBecauseV8Extension 
kNoCacheBecauseExtensionModule 
kNoCacheBecausePacScript 
kNoCacheBecauseInDocumentWrite 
kNoCacheBecauseResourceWithNoCacheHandler 
kNoCacheBecauseDeferredProduceCodeCache 

Member Function Documentation

◆ CachedDataVersionTag()

static uint32_t v8::ScriptCompiler::CachedDataVersionTag ( )
static

Return a version tag for CachedData for the current V8 version & flags.

This value is meant only for determining whether a previously generated CachedData instance is still valid; the tag has no other meaing.

Background: The data carried by CachedData may depend on the exact V8 version number or current compiler flags. This means that when persisting CachedData, the embedder must take care to not pass in data from another V8 version, or the same version with different features enabled.

The easiest way to do so is to clear the embedder's cache on any such change.

Alternatively, this tag can be stored alongside the cached data and compared when it is being used.

◆ Compile() [1/2]

static MaybeLocal<Script> v8::ScriptCompiler::Compile ( Local< Context context,
Source source,
CompileOptions  options = kNoCompileOptions,
NoCacheReason  no_cache_reason = kNoCacheNoReason 
)
static

Compiles the specified script (bound to current context).

Parameters
sourceScript source code.
pre_dataPre-parsing data, as obtained by ScriptData::PreCompile() using pre_data speeds compilation if it's done multiple times. Owned by caller, no references are kept when this function returns.
Returns
Compiled script object, bound to the context that was active when this function was called. When run it will always use this context.

◆ Compile() [2/2]

static MaybeLocal<Script> v8::ScriptCompiler::Compile ( Local< Context context,
StreamedSource source,
Local< String full_source_string,
const ScriptOrigin origin 
)
static

Compiles a streamed script (bound to current context).

This can only be called after the streaming has finished (ScriptStreamingTask has been run). V8 doesn't construct the source string during streaming, so the embedder needs to pass the full source here.

◆ CompileFunctionInContext()

static MaybeLocal<Function> v8::ScriptCompiler::CompileFunctionInContext ( Local< Context context,
Source source,
size_t  arguments_count,
Local< String arguments[],
size_t  context_extension_count,
Local< Object context_extensions[],
CompileOptions  options = kNoCompileOptions,
NoCacheReason  no_cache_reason = kNoCacheNoReason,
Local< ScriptOrModule > *  script_or_module_out = nullptr 
)
static

Compile a function for a given context. This is equivalent to running

with (obj) { return function(args) { ... } }

It is possible to specify multiple context extensions (obj in the above example).

◆ CompileModule() [1/2]

static MaybeLocal<Module> v8::ScriptCompiler::CompileModule ( Isolate isolate,
Source source,
CompileOptions  options = kNoCompileOptions,
NoCacheReason  no_cache_reason = kNoCacheNoReason 
)
static

Compile an ES module, returning a Module that encapsulates the compiled code.

Corresponds to the ParseModule abstract operation in the ECMAScript specification.

◆ CompileModule() [2/2]

static MaybeLocal<Module> v8::ScriptCompiler::CompileModule ( Local< Context context,
StreamedSource v8_source,
Local< String full_source_string,
const ScriptOrigin origin 
)
static

Compiles a streamed module script.

This can only be called after the streaming has finished (ScriptStreamingTask has been run). V8 doesn't construct the source string during streaming, so the embedder needs to pass the full source here.

◆ CompileUnboundScript()

static MaybeLocal<UnboundScript> v8::ScriptCompiler::CompileUnboundScript ( Isolate isolate,
Source source,
CompileOptions  options = kNoCompileOptions,
NoCacheReason  no_cache_reason = kNoCacheNoReason 
)
static

Compiles the specified script (context-independent). Cached data as part of the source object can be optionally produced to be consumed later to speed up compilation of identical source scripts.

Note that when producing cached data, the source must point to NULL for cached data. When consuming cached data, the cached data must have been produced by the same version of V8.

Parameters
sourceScript source code.
Returns
Compiled script object (context independent; for running it must be bound to a context).

◆ CreateCodeCache() [1/2]

static CachedData* v8::ScriptCompiler::CreateCodeCache ( Local< UnboundModuleScript unbound_module_script)
static

Creates and returns code cache for the specified unbound_module_script. This will return nullptr if the script cannot be serialized. The CachedData returned by this function should be owned by the caller.

◆ CreateCodeCache() [2/2]

static CachedData* v8::ScriptCompiler::CreateCodeCache ( Local< UnboundScript unbound_script)
static

Creates and returns code cache for the specified unbound_script. This will return nullptr if the script cannot be serialized. The CachedData returned by this function should be owned by the caller.

◆ CreateCodeCacheForFunction()

static CachedData* v8::ScriptCompiler::CreateCodeCacheForFunction ( Local< Function function)
static

Creates and returns code cache for the specified function that was previously produced by CompileFunctionInContext. This will return nullptr if the script cannot be serialized. The CachedData returned by this function should be owned by the caller.

◆ StartStreaming()

static ScriptStreamingTask* v8::ScriptCompiler::StartStreaming ( Isolate isolate,
StreamedSource source,
ScriptType  type = ScriptType::kClassic 
)
static

◆ StartStreamingScript()

static ScriptStreamingTask* v8::ScriptCompiler::StartStreamingScript ( Isolate isolate,
StreamedSource source,
CompileOptions  options = kNoCompileOptions 
)
static

Returns a task which streams script data into V8, or NULL if the script cannot be streamed. The user is responsible for running the task on a background thread and deleting it. When ran, the task starts parsing the script, and it will request data from the StreamedSource as needed. When ScriptStreamingTask::Run exits, all data has been streamed and the script can be compiled (see Compile below).

This API allows to start the streaming with as little data as possible, and the remaining data (for example, the ScriptOrigin) is passed to Compile.


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