Proof of concept: API for doing only one parsing pass instead of first preparsing and then parsing.

src/api.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1599 matching lines @@
       i::Vector<unsigned>(deserialized_data, deserialized_data_length));
 }
 
 
 // --- S c r i p t ---
 
 
 Local<Script> Script::New(v8::Handle<String> source,
                           v8::ScriptOrigin* origin,
                           v8::ScriptData* pre_data) {
+  if (pre_data) {
+    return NewAndGenerateScriptDataIfNeeded(source, origin, &pre_data);
+  }
+  // Don't generate ScriptData; we're not going to pass it to the caller.
+  return NewAndGenerateScriptDataIfNeeded(source, origin, NULL);
+}
+
+
+Local<Script> Script::NewAndGenerateScriptDataIfNeeded(
+    v8::Handle<String> source, v8::ScriptOrigin* origin,
+    v8::ScriptData** pre_data) {
+  // pre_data == NULL: we don't have ScriptData and we don't want to.
+  // pre_data != NULL and *pre_data == NULL: we don't have ScriptData yet, but
+  //   we want it to be produced
+  // pre_data != NULL and *pre_data != NULL; we already have ScriptData and it
+  //   should be used when parsing.
   i::Handle<i::String> str = Utils::OpenHandle(*source);
   i::Isolate* isolate = str->GetIsolate();
   ON_BAILOUT(isolate, "v8::Script::New()", return Local<Script>());
   LOG_API(isolate, "Script::New");
   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 (origin != NULL) {
       if (!origin->ResourceName().IsEmpty()) {
         name_obj = Utils::OpenHandle(*origin->ResourceName());
       }
       if (!origin->ResourceLineOffset().IsEmpty()) {
         line_offset = static_cast<int>(origin->ResourceLineOffset()->Value());
       }
       if (!origin->ResourceColumnOffset().IsEmpty()) {
         column_offset =
             static_cast<int>(origin->ResourceColumnOffset()->Value());
       }
       if (!origin->ResourceIsSharedCrossOrigin().IsEmpty()) {
         v8::Isolate* v8_isolate = reinterpret_cast<v8::Isolate*>(isolate);
         is_shared_cross_origin =
             origin->ResourceIsSharedCrossOrigin() == v8::True(v8_isolate);
       }
     }
     EXCEPTION_PREAMBLE(isolate);
-    i::ScriptDataImpl* pre_data_impl =
-        static_cast<i::ScriptDataImpl*>(pre_data);
+    i::ScriptDataImpl* pre_data_impl = pre_data ?
+        static_cast<i::ScriptDataImpl*>(*pre_data) : NULL;
     // We assert that the pre-data is sane, even though we can actually
     // handle it if it turns out not to be in release mode.
     ASSERT(pre_data_impl == NULL || pre_data_impl->SanityCheck());
-    // If the pre-data isn't sane we simply ignore it
+    // If the pre-data isn't sane we simply ignore it. Careful: don't nullify
+    // the caller's pointer, since the caller owns the invalid ScriptData.
     if (pre_data_impl != NULL && !pre_data_impl->SanityCheck()) {
       pre_data_impl = NULL;
     }
     i::Handle<i::SharedFunctionInfo> result =
         i::Compiler::CompileScript(str,
                                    name_obj,
                                    line_offset,
                                    column_offset,
                                    is_shared_cross_origin,
                                    isolate->global_context(),
                                    NULL,
-                                   pre_data_impl,
+                                   pre_data ? &pre_data_impl : NULL,
                                    i::NOT_NATIVES_CODE);
     has_pending_exception = result.is_null();
     EXCEPTION_BAILOUT_CHECK(isolate, Local<Script>());
     raw_result = *result;
+    if (pre_data != NULL && *pre_data == NULL) {
+      // Caller wanted us to generate ScriptData.
+      *pre_data = pre_data_impl;
+    }
   }
   i::Handle<i::SharedFunctionInfo> result(raw_result, isolate);
   return ToApiHandle<Script>(result);
 }
 
 
 Local<Script> Script::New(v8::Handle<String> source,
                           v8::Handle<Value> file_name) {
   ScriptOrigin origin(file_name);
   return New(source, &origin);
@@ skipping 15 matching lines @@
   i::Handle<i::SharedFunctionInfo> function =
       i::Handle<i::SharedFunctionInfo>(i::SharedFunctionInfo::cast(*obj));
   i::Handle<i::JSFunction> result =
       isolate->factory()->NewFunctionFromSharedFunctionInfo(
           function,
           isolate->global_context());
   return ToApiHandle<Script>(result);
 }
 
 
+Local<Script> Script::CompileAndGenerateScriptDataIfNeeded(
+    v8::Handle<String> source, v8::ScriptOrigin* origin,
+    v8::ScriptData** cached_data) {
+  i::Handle<i::String> str = Utils::OpenHandle(*source);
+  i::Isolate* isolate = str->GetIsolate();
+  ON_BAILOUT(isolate, "v8::Script::Compile()", return Local<Script>());
+  LOG_API(isolate, "Script::Compile");
+  ENTER_V8(isolate);
+  Local<Script> generic =
+      NewAndGenerateScriptDataIfNeeded(source, origin, cached_data);
+  if (generic.IsEmpty()) return generic;
+  i::Handle<i::Object> obj = Utils::OpenHandle(*generic);
+  i::Handle<i::SharedFunctionInfo> function =
+      i::Handle<i::SharedFunctionInfo>(i::SharedFunctionInfo::cast(*obj));
+  i::Handle<i::JSFunction> result =
+      isolate->factory()->NewFunctionFromSharedFunctionInfo(
+          function,
+          isolate->global_context());
+  return ToApiHandle<Script>(result);
+}
+
+
 Local<Script> Script::Compile(v8::Handle<String> source,
                               v8::Handle<Value> file_name) {
   ScriptOrigin origin(file_name);
   return Compile(source, &origin);
 }
 
 
 Local<Value> Script::Run() {
   // If execution is terminating, Compile(script)->Run() requires this check.
   if (this == NULL) return Local<Value>();
@@ skipping 5739 matching lines @@
   Isolate* isolate = reinterpret_cast<Isolate*>(info.GetIsolate());
   Address callback_address =
       reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback));
   VMState<EXTERNAL> state(isolate);
   ExternalCallbackScope call_scope(isolate, callback_address);
   callback(info);
 }
 
 
 } }  // namespace v8::internal