v8::ScriptCompiler Class Reference

For compiling scripts. More...

#include <v8.h>

Collaboration diagram for v8::ScriptCompiler:

Classes
struct	CachedData
	Compilation data that the embedder can cache and pass back to speed up future compilations. More...
class	ExternalSourceStream
	For streaming incomplete script data to V8. More...
class	ScriptStreamingTask
	A streaming task which the embedder must run on a background thread to stream scripts into V8. More...
class	Source
	Source code which can be then compiled to a UnboundScript or Script. More...
class	StreamedSource
	Source code which can be streamed into V8 in pieces. More...

Public Types
enum	CompileOptions {   kNoCompileOptions = 0 , kProduceParserCache , kConsumeParserCache , kProduceCodeCache ,   kConsumeCodeCache , kProduceDataToCache }

Static Public Member Functions
static Local< UnboundScript >	CompileUnbound (Isolate *isolate, Source *source, CompileOptions options=kNoCompileOptions)
	Compiles the specified script (context-independent). More...
static Local< Script >	Compile (Isolate *isolate, Source *source, CompileOptions options=kNoCompileOptions)
	Compiles the specified script (bound to current context). More...
static ScriptStreamingTask *	StartStreamingScript (Isolate *isolate, StreamedSource *source, CompileOptions options=kNoCompileOptions)
	Returns a task which streams script data into V8, or NULL if the script cannot be streamed. More...
static Local< Script >	Compile (Isolate *isolate, StreamedSource *source, Handle< String > full_source_string, const ScriptOrigin &origin)
	Compiles a streamed script (bound to current context). More...

Detailed Description

For compiling scripts.

Definition at line 1019 of file v8.h.

Member Enumeration Documentation

CompileOptions

enum v8::ScriptCompiler::CompileOptions

Enumerator
kNoCompileOptions
kProduceParserCache
kConsumeParserCache
kProduceCodeCache
kConsumeCodeCache
kProduceDataToCache

Definition at line 1159 of file v8.h.

                      {
    kNoCompileOptions = 0,
    kProduceParserCache,
    kConsumeParserCache,
    kProduceCodeCache,
    kConsumeCodeCache,
 
    // Support the previous API for a transition period.
    kProduceDataToCache
  };

Member Function Documentation

Compile() [1/2]

Local< Script > v8::ScriptCompiler::Compile ( Isolate *  isolate, Source *  source, CompileOptions  options = kNoCompileOptions  )

static

Compiles the specified script (bound to current context).

Parameters

source	Script source code.
pre_data	Pre-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.

Definition at line 1783 of file api.cc.

                            {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
  ON_BAILOUT(isolate, "v8::ScriptCompiler::Compile()", return Local<Script>());
  LOG_API(isolate, "ScriptCompiler::CompiletBound()");
  ENTER_V8(isolate);
  Local<UnboundScript> generic = CompileUnbound(v8_isolate, source, options);
  if (generic.IsEmpty()) return Local<Script>();
  return generic->BindToCurrentContext();
}

References CompileUnbound(), ENTER_V8, LOG_API, and ON_BAILOUT.

Referenced by v8::Script::Compile().

Here is the call graph for this function:

Here is the caller graph for this function:

Compile() [2/2]

Local< Script > v8::ScriptCompiler::Compile ( Isolate *  isolate, StreamedSource *  source, Handle< 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.

Definition at line 1816 of file api.cc.

                                                                  {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
  i::StreamedSource* source = v8_source->impl();
  ON_BAILOUT(isolate, "v8::ScriptCompiler::Compile()", return Local<Script>());
  LOG_API(isolate, "ScriptCompiler::Compile()");
  ENTER_V8(isolate);
  i::SharedFunctionInfo* raw_result = NULL;
 
  {
    i::HandleScope scope(isolate);
    i::Handle<i::String> str = Utils::OpenHandle(*(full_source_string));
    i::Handle<i::Script> script = isolate->factory()->NewScript(str);
    if (!origin.ResourceName().IsEmpty()) {
      script->set_name(*Utils::OpenHandle(*(origin.ResourceName())));
    }
    if (!origin.ResourceLineOffset().IsEmpty()) {
      script->set_line_offset(i::Smi::FromInt(
          static_cast<int>(origin.ResourceLineOffset()->Value())));
    }
    if (!origin.ResourceColumnOffset().IsEmpty()) {
      script->set_column_offset(i::Smi::FromInt(
          static_cast<int>(origin.ResourceColumnOffset()->Value())));
    }
    if (!origin.ResourceIsSharedCrossOrigin().IsEmpty()) {
      script->set_is_shared_cross_origin(origin.ResourceIsSharedCrossOrigin() ==
                                         v8::True(v8_isolate));
    }
    source->info->set_script(script);
    source->info->SetContext(isolate->global_context());
 
    EXCEPTION_PREAMBLE(isolate);
 
    // Do the parsing tasks which need to be done on the main thread. This will
    // also handle parse errors.
    source->parser->Internalize();
 
    i::Handle<i::SharedFunctionInfo> result =
        i::Handle<i::SharedFunctionInfo>::null();
    if (source->info->function() != NULL) {
      // Parsing has succeeded.
      result =
          i::Compiler::CompileStreamedScript(source->info.get(), str->length());
    }
    has_pending_exception = result.is_null();
    if (has_pending_exception) isolate->ReportPendingMessages();
    EXCEPTION_BAILOUT_CHECK(isolate, Local<Script>());
 
    raw_result = *result;
    // The Handle<Script> will go out of scope soon; make sure CompilationInfo
    // doesn't point to it.
    source->info->set_script(i::Handle<i::Script>());
  }  // HandleScope goes out of scope.
  i::Handle<i::SharedFunctionInfo> result(raw_result, isolate);
  Local<UnboundScript> generic = ToApiHandle<UnboundScript>(result);
  if (generic.IsEmpty()) {
    return Local<Script>();
  }
  return generic->BindToCurrentContext();
}

References v8::internal::Compiler::CompileStreamedScript(), ENTER_V8, EXCEPTION_BAILOUT_CHECK, EXCEPTION_PREAMBLE, v8::internal::Isolate::factory(), v8::internal::Smi::FromInt(), v8::internal::Isolate::global_context(), v8::ScriptCompiler::StreamedSource::impl(), v8::internal::StreamedSource::info, v8::internal::Handle< T >::is_null(), LOG_API, NULL, v8::internal::Handle< T >::null(), ON_BAILOUT, v8::Utils::OpenHandle(), v8::internal::StreamedSource::parser, v8::internal::Isolate::ReportPendingMessages(), v8::ScriptOrigin::ResourceColumnOffset(), v8::ScriptOrigin::ResourceIsSharedCrossOrigin(), v8::ScriptOrigin::ResourceLineOffset(), v8::ScriptOrigin::ResourceName(), and v8::True().

Here is the call graph for this function:

CompileUnbound()

Local< UnboundScript > v8::ScriptCompiler::CompileUnbound ( Isolate *  isolate, Source *  source, CompileOptions  options = kNoCompileOptions  )

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

source

Script source code.

Returns

Compiled script object (context independent; for running it must be bound to a context).

Definition at line 1703 of file api.cc.

                            {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
  ON_BAILOUT(isolate, "v8::ScriptCompiler::CompileUnbound()",
             return Local<UnboundScript>());
 
  // Support the old API for a transition period:
  // - kProduceToCache -> kProduceParserCache
  // - kNoCompileOptions + cached_data != NULL -> kConsumeParserCache
  if (options == kProduceDataToCache) {
    options = kProduceParserCache;
  } else if (options == kNoCompileOptions && source->cached_data) {
    options = kConsumeParserCache;
  }
 
  i::ScriptData* script_data = NULL;
  if (options == kConsumeParserCache || options == kConsumeCodeCache) {
    DCHECK(source->cached_data);
    // ScriptData takes care of pointer-aligning the data.
    script_data = new i::ScriptData(source->cached_data->data,
                                    source->cached_data->length);
  }
 
  i::Handle<i::String> str = Utils::OpenHandle(*(source->source_string));
  LOG_API(isolate, "ScriptCompiler::CompileUnbound");
  ENTER_V8(isolate);
  i::SharedFunctionInfo* raw_result = NULL;
  { i::HandleScope scope(isolate);
    i::Handle<i::Object> name_obj;
    int line_offset = 0;
    int column_offset = 0;
    bool is_shared_cross_origin = false;
    if (!source->resource_name.IsEmpty()) {
      name_obj = Utils::OpenHandle(*(source->resource_name));
    }
    if (!source->resource_line_offset.IsEmpty()) {
      line_offset = static_cast<int>(source->resource_line_offset->Value());
    }
    if (!source->resource_column_offset.IsEmpty()) {
      column_offset =
          static_cast<int>(source->resource_column_offset->Value());
    }
    if (!source->resource_is_shared_cross_origin.IsEmpty()) {
      v8::Isolate* v8_isolate = reinterpret_cast<v8::Isolate*>(isolate);
      is_shared_cross_origin =
          source->resource_is_shared_cross_origin == v8::True(v8_isolate);
    }
    EXCEPTION_PREAMBLE(isolate);
    i::Handle<i::SharedFunctionInfo> result = i::Compiler::CompileScript(
        str, name_obj, line_offset, column_offset, is_shared_cross_origin,
        isolate->global_context(), NULL, &script_data, options,
        i::NOT_NATIVES_CODE);
    has_pending_exception = result.is_null();
    if (has_pending_exception && script_data != NULL) {
      // This case won't happen during normal operation; we have compiled
      // successfully and produced cached data, and but the second compilation
      // of the same source code fails.
      delete script_data;
      script_data = NULL;
    }
    EXCEPTION_BAILOUT_CHECK(isolate, Local<UnboundScript>());
    raw_result = *result;
 
    if ((options == kProduceParserCache || options == kProduceCodeCache) &&
        script_data != NULL) {
      // script_data now contains the data that was generated. source will
      // take the ownership.
      source->cached_data = new CachedData(
          script_data->data(), script_data->length(), CachedData::BufferOwned);
      script_data->ReleaseDataOwnership();
    }
    delete script_data;
  }
  i::Handle<i::SharedFunctionInfo> result(raw_result, isolate);
  return ToApiHandle<UnboundScript>(result);
}

References v8::ScriptCompiler::CachedData::BufferOwned, v8::ScriptCompiler::Source::cached_data, v8::internal::Compiler::CompileScript(), v8::ScriptCompiler::CachedData::data, v8::internal::ScriptData::data(), DCHECK, ENTER_V8, EXCEPTION_BAILOUT_CHECK, EXCEPTION_PREAMBLE, v8::internal::Isolate::global_context(), v8::internal::Handle< T >::is_null(), kConsumeCodeCache, kConsumeParserCache, kNoCompileOptions, kProduceCodeCache, kProduceDataToCache, kProduceParserCache, v8::ScriptCompiler::CachedData::length, v8::internal::ScriptData::length(), LOG_API, v8::internal::NOT_NATIVES_CODE, NULL, ON_BAILOUT, v8::Utils::OpenHandle(), v8::internal::ScriptData::ReleaseDataOwnership(), v8::ScriptCompiler::Source::resource_column_offset, v8::ScriptCompiler::Source::resource_is_shared_cross_origin, v8::ScriptCompiler::Source::resource_line_offset, v8::ScriptCompiler::Source::resource_name, v8::ScriptCompiler::Source::source_string, and v8::True().

Referenced by Compile(), v8::Shell::CompileString(), and v8::Shell::RealmEval().

Here is the call graph for this function:

Here is the caller graph for this function:

StartStreamingScript()

ScriptCompiler::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.

Definition at line 1797 of file api.cc.

                                                                         {
  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
  if (!isolate->global_context().is_null() &&
      !isolate->global_context()->IsNativeContext()) {
    // The context chain is non-trivial, and constructing the corresponding
    // non-trivial Scope chain outside the V8 heap is not implemented. Don't
    // stream the script. This will only occur if Harmony scoping is enabled and
    // a previous script has introduced "let" or "const" variables. TODO(marja):
    // Implement externalizing ScopeInfos and constructing non-trivial Scope
    // chains independent of the V8 heap so that we can stream also in this
    // case.
    return NULL;
  }
  return new i::BackgroundParsingTask(source->impl(), options,
                                      i::FLAG_stack_size, isolate);
}

References v8::internal::Isolate::global_context(), v8::ScriptCompiler::StreamedSource::impl(), and NULL.

Here is the call graph for this function:

---

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

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