Support lazy parsing of inner functions

src/preparse-data.cc

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "src/ast-value-factory.h"
 #include "src/base/logging.h"
 #include "src/compiler.h"
 #include "src/globals.h"
 #include "src/hashmap.h"
 #include "src/preparse-data.h"
 #include "src/preparse-data-format.h"
 
 namespace v8 {
 namespace internal {
 
 
 CompleteParserRecorder::CompleteParserRecorder()
-    : function_store_(0) {
+    : function_store_(0), next_function_calls_eval_(false) {
   preamble_[PreparseDataConstants::kMagicOffset] =
       PreparseDataConstants::kMagicNumber;
   preamble_[PreparseDataConstants::kVersionOffset] =
       PreparseDataConstants::kCurrentVersion;
   preamble_[PreparseDataConstants::kHasErrorOffset] = false;
   preamble_[PreparseDataConstants::kFunctionsSizeOffset] = 0;
   preamble_[PreparseDataConstants::kSizeOffset] = 0;
   DCHECK_EQ(5, PreparseDataConstants::kHeaderSize);
 #ifdef DEBUG
   prev_start_ = -1;
@@ skipping 24 matching lines @@
 
 
 void CompleteParserRecorder::WriteString(Vector<const char> str) {
   function_store_.Add(str.length());
   for (int i = 0; i < str.length(); i++) {
     function_store_.Add(str[i]);
   }
 }
 
 
+void CompleteParserRecorder::WriteString(const AstRawString* str) {
+  const bool is_one_byte = str->is_one_byte();
+  function_store_.Add(is_one_byte);
+  int byte_length = str->length();
+  if (!is_one_byte) {
+    byte_length *= 2;
+  }
+  function_store_.Add(byte_length);
+  DCHECK(byte_length > 0);
+  const int word_length =
+      1 + (((byte_length * sizeof(unsigned char)) - 1) / sizeof(unsigned));
+  Vector<unsigned char> dest =
+      Vector<unsigned char>::cast(function_store_.AddBlock(word_length, 0));
+  MemCopy(dest.start(), str->raw_data(), byte_length);
+}
+
+
 ScriptData* CompleteParserRecorder::GetScriptData() {
   int function_size = function_store_.size();
   int total_size = PreparseDataConstants::kHeaderSize + function_size;
   unsigned* data = NewArray<unsigned>(total_size);
   preamble_[PreparseDataConstants::kFunctionsSizeOffset] = function_size;
   MemCopy(data, preamble_, sizeof(preamble_));
   if (function_size > 0) {
     function_store_.WriteTo(Vector<unsigned>(
         data + PreparseDataConstants::kHeaderSize, function_size));
   }
   DCHECK(IsAligned(reinterpret_cast<intptr_t>(data), kPointerAlignment));
   ScriptData* result = new ScriptData(reinterpret_cast<byte*>(data),
                                       total_size * sizeof(unsigned));
   result->AcquireDataOwnership();
   return result;
 }
 
 
 } }  // namespace v8::internal.