Introduce a switch for the new snapshot code and switch...

src/mksnapshot.cc

 // Copyright 2006-2008 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 91 matching lines @@
     return counter_table_[counter];
 
   Counter* ctr = counters->GetNextCounter();
   if (ctr == NULL) return NULL;
   int* ptr = ctr->Bind(name);
   counter_table_[counter] = ptr;
   return ptr;
 }
 
 
+class CppByteSink : public i::SnapshotByteSink {
+ public:
+  explicit CppByteSink(const char* snapshot_file) : bytes_written_(0) {
+    fp_ = i::OS::FOpen(snapshot_file, "wb");
+    if (fp_ == NULL) {
+      i::PrintF("Unable to write to snapshot file \"%s\"\n", snapshot_file);
+      exit(1);
+    }
+    fprintf(fp_, "// Autogenerated snapshot file. Do not edit.\n\n");
+    fprintf(fp_, "#include \"v8.h\"\n");
+    fprintf(fp_, "#include \"platform.h\"\n\n");
+    fprintf(fp_, "#include \"snapshot.h\"\n\n");
+    fprintf(fp_, "namespace v8 {\nnamespace internal {\n\n");
+    fprintf(fp_, "const byte Snapshot::data_[] = {");
+  }
+  virtual ~CppByteSink() {

[Mads Ager (chromium), 2009/10/30 10:17:11]

Space between the methods?

+    if (fp_ != NULL) {
+      fprintf(fp_, "};\n\n");
+      fprintf(fp_, "int Snapshot::size_ = %d;\n\n", bytes_written_);
+      fprintf(fp_, "} }  // namespace v8::internal\n");
+      fclose(fp_);
+    }
+  }
+  virtual void Put(int byte, const char* description) {
+    if (bytes_written_ != 0) {
+      fprintf(fp_, ",");
+    }
+    fprintf(fp_, "%d", byte);
+    bytes_written_++;
+    if ((bytes_written_ & 0x3f) == 0) {
+      fprintf(fp_, "\n");
+    }
+  }
+
+ private:
+  FILE* fp_;
+  int bytes_written_;
+};
+
+
 // Write C++ code that defines Snapshot::snapshot_ to contain the snapshot
 // to the file given by filename. Only the first size chars are written.
 static int WriteInternalSnapshotToFile(const char* filename,
                                        const v8::internal::byte* bytes,
                                        int size) {
   FILE* f = i::OS::FOpen(filename, "wb");
   if (f == NULL) {
-    i::OS::PrintError("Cannot open file %s for reading.\n", filename);
+    i::OS::PrintError("Cannot open file %s for writing.\n", filename);
     return 0;
   }
   fprintf(f, "// Autogenerated snapshot file. Do not edit.\n\n");
   fprintf(f, "#include \"v8.h\"\n");
   fprintf(f, "#include \"platform.h\"\n\n");
   fprintf(f, "#include \"snapshot.h\"\n\n");
   fprintf(f, "namespace v8 {\nnamespace internal {\n\n");
   fprintf(f, "const byte Snapshot::data_[] = {");
   int written = 0;
   written += fprintf(f, "0x%x", bytes[0]);
   for (int i = 1; i < size; ++i) {
     written += fprintf(f, ",0x%x", bytes[i]);
     // The following is needed to keep the line length low on Visual C++:
     if (i % 512 == 0) fprintf(f, "\n");
   }
   fprintf(f, "};\n\n");
   fprintf(f, "int Snapshot::size_ = %d;\n\n", size);
   fprintf(f, "} }  // namespace v8::internal\n");
   fclose(f);
   return written;
 }
 
 
+int main2(int argc, char** argv) {
+  i::Serializer::Enable();
+  Persistent<Context> context = v8::Context::New();
+  // Make sure all builtin scripts are cached.
+  { HandleScope scope;
+    for (int i = 0; i < i::Natives::GetBuiltinsCount(); i++) {
+      i::Bootstrapper::NativesSourceLookup(i);
+    }
+  }
+  context.Dispose();
+  CppByteSink sink(argv[1]);
+  i::Serializer2 ser(&sink);
+  ser.Serialize();
+  return 0;
+}
+
+
 int main(int argc, char** argv) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   // By default, log code create information in the snapshot.
   i::FLAG_log_code = true;
 #endif
   // Print the usage if an error occurs when parsing the command line
   // flags or if the help flag is set.
   int result = i::FlagList::SetFlagsFromCommandLine(&argc, argv, true);
   if (result > 0 || argc != 2 || i::FLAG_help) {
     ::printf("Usage: %s [flag] ... outfile\n", argv[0]);
     i::FlagList::PrintHelp();
     return !i::FLAG_help;
   }
 
+  if (i::FLAG_new_snapshot) {
+    return main2(argc, argv);
+  }
+
   v8::V8::SetCounterFunction(counter_callback);
   v8::HandleScope scope;
 
   const int kExtensionCount = 1;
   const char* extension_list[kExtensionCount] = { "v8/gc" };
   v8::ExtensionConfiguration extensions(kExtensionCount, extension_list);
 
   i::Serializer::Enable();
   v8::Context::New(&extensions);
 
@@ skipping 10 matching lines @@
   v8::internal::byte* bytes;
   int len;
   ser.Finalize(&bytes, &len);
 
   WriteInternalSnapshotToFile(argv[1], bytes, len);
 
   i::DeleteArray(bytes);
 
   return 0;
 }