Revert "Support external startup data in V8."

tools/js2c.py

 #!/usr/bin/env python
 #
 # 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
@@ skipping 379 matching lines @@
     result.modules.append(lines);
 
     is_debugger = IsDebuggerFile(source)
     result.is_debugger_id.append(is_debugger);
 
     name = os.path.basename(source)[:-3]
     result.names.append(name if not is_debugger else name[:-9]);
   return result
 
 
-def BuildMetadata(sources, source_bytes, native_type):
+def BuildMetadata(sources, source_bytes, native_type, omit):
   """Build the meta data required to generate a libaries file.
 
   Args:
     sources: A Sources instance with the prepared sources.
     source_bytes: A list of source bytes.
         (The concatenation of all sources; might be compressed.)
     native_type: The parameter for the NativesCollection template.
+    omit: bool, whether we should omit the sources in the output.
 
   Returns:
     A dictionary for use with HEADER_TEMPLATE.
   """
   total_length = len(source_bytes)
   raw_sources = "".join(sources.modules)
 
   # The sources are expected to be ASCII-only.
   assert not filter(lambda value: ord(value) >= 128, raw_sources)
 
@@ skipping 12 matching lines @@
         "offset": offset,
         "raw_length": len(sources.modules[i]),
     }
     get_index_cases.append(GET_INDEX_CASE % d)
     get_script_name_cases.append(GET_SCRIPT_NAME_CASE % d)
     get_raw_script_source_cases.append(GET_RAW_SCRIPT_SOURCE_CASE % d)
     offset += len(sources.modules[i])
   assert offset == len(raw_sources)
 
   # If we have the raw sources we can declare them accordingly.
-  have_raw_sources = source_bytes == raw_sources
+  have_raw_sources = source_bytes == raw_sources and not omit
   raw_sources_declaration = (RAW_SOURCES_DECLARATION
       if have_raw_sources else RAW_SOURCES_COMPRESSION_DECLARATION)
 
   metadata = {
     "builtin_count": len(sources.modules),
     "debugger_count": sum(sources.is_debugger_id),
     "sources_declaration": SOURCES_DECLARATION % ToCArray(source_bytes),
+    "sources_data": ToCArray(source_bytes) if not omit else "",
     "raw_sources_declaration": raw_sources_declaration,
     "raw_total_length": sum(map(len, sources.modules)),
     "total_length": total_length,
     "get_index_cases": "".join(get_index_cases),
     "get_raw_script_source_cases": "".join(get_raw_script_source_cases),
     "get_script_name_cases": "".join(get_script_name_cases),
     "type": native_type,
   }
   return metadata
 
@@ skipping 10 matching lines @@
   """
   sources_bytes = "".join(sources.modules)
   if compression_type == "off":
     return sources_bytes
   elif compression_type == "bz2":
     return bz2.compress(sources_bytes)
   else:
     raise Error("Unknown compression type %s." % compression_type)
 
 
-def PutInt(blob_file, value):
-  assert(value >= 0 and value < (1 << 20))
-  size = 1 if (value < 1 << 6) else (2 if (value < 1 << 14) else 3)
-  value_with_length = (value << 2) | size
-
-  byte_sequence = bytearray()
-  for i in xrange(size):
-    byte_sequence.append(value_with_length & 255)
-    value_with_length >>= 8;
-  blob_file.write(byte_sequence)
-
-
-def PutStr(blob_file, value):
-  PutInt(blob_file, len(value));
-  blob_file.write(value);
-
-
-def WriteStartupBlob(sources, startup_blob):
-  """Write a startup blob, as expected by V8 Initialize ...
-    TODO(vogelheim): Add proper method name.
-
-  Args:
-    sources: A Sources instance with the prepared sources.
-    startup_blob_file: Name of file to write the blob to.
-  """
-  output = open(startup_blob, "wb")
-
-  debug_sources = sum(sources.is_debugger_id);
-  PutInt(output, debug_sources)
-  for i in xrange(debug_sources):
-    PutStr(output, sources.names[i]);
-    PutStr(output, sources.modules[i]);
-
-  PutInt(output, len(sources.names) - debug_sources)
-  for i in xrange(debug_sources, len(sources.names)):
-    PutStr(output, sources.names[i]);
-    PutStr(output, sources.modules[i]);
-
-  output.close()
-
-
-def JS2C(source, target, native_type, compression_type, raw_file, startup_blob):
+def JS2C(source, target, native_type, compression_type, raw_file, omit):
   sources = PrepareSources(source)
   sources_bytes = CompressMaybe(sources, compression_type)
-  metadata = BuildMetadata(sources, sources_bytes, native_type)
+  metadata = BuildMetadata(sources, sources_bytes, native_type, omit)
 
   # Optionally emit raw file.
   if raw_file:
     output = open(raw_file, "w")
     output.write(sources_bytes)
     output.close()
 
-  if startup_blob:
-    WriteStartupBlob(sources, startup_blob);
-
   # Emit resulting source file.
   output = open(target, "w")
   output.write(HEADER_TEMPLATE % metadata)
   output.close()
 
 
 def main():
   parser = optparse.OptionParser()
   parser.add_option("--raw", action="store",
-                    help="file to write the processed sources array to.")
-  parser.add_option("--startup_blob", action="store",
-                    help="file to write the startup blob to.")
+                      help="file to write the processed sources array to.")
+  parser.add_option("--omit", dest="omit", action="store_true",
+                    help="Omit the raw sources from the generated code.")
   parser.set_usage("""js2c out.cc type compression sources.js ...
       out.cc: C code to be generated.
       type: type parameter for NativesCollection template.
       compression: type of compression used. [off|bz2]
       sources.js: JS internal sources or macros.py.""")
   (options, args) = parser.parse_args()
 
-  JS2C(args[3:], args[0], args[1], args[2], options.raw, options.startup_blob)
+  JS2C(args[3:], args[0], args[1], args[2], options.raw, options.omit)
 
 
 if __name__ == "__main__":
   main()