Add --print-dependencies to gen_snapshot

runtime/bin/gen_snapshot.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // Generate a snapshot file after loading all the scripts specified on the
 // command line.
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ skipping 62 matching lines @@
   kAppAOTAssembly,
 };
 static SnapshotKind snapshot_kind = kCore;
 static const char* vm_snapshot_data_filename = NULL;
 static const char* vm_snapshot_instructions_filename = NULL;
 static const char* isolate_snapshot_data_filename = NULL;
 static const char* isolate_snapshot_instructions_filename = NULL;
 static const char* assembly_filename = NULL;
 static const char* script_snapshot_filename = NULL;
 static bool dependencies_only = false;
+static bool print_dependencies = false;
 static const char* dependencies_filename = NULL;
 
 
 // Value of the --package-root flag.
 // (This pointer points into an argv buffer and does not need to be
 // free'd.)
 static const char* commandline_package_root = NULL;
 
 // Value of the --packages flag.
 // (This pointer points into an argv buffer and does not need to be
@@ skipping 231 matching lines @@
   if (name == NULL) {
     name = ProcessOption(option, "--dependencies-only");
   }
   if (name != NULL) {
     dependencies_only = true;
     return true;
   }
   return false;
 }
 
+static bool ProcessPrintDependenciesOption(const char* option) {
+  const char* name = ProcessOption(option, "--print_dependencies");
+  if (name == NULL) {
+    name = ProcessOption(option, "--print-dependencies");
+  }
+  if (name != NULL) {
+    print_dependencies = true;
+    return true;
+  }
+  return false;
+}
 
 static bool ProcessEmbedderEntryPointsManifestOption(const char* option) {
   const char* name = ProcessOption(option, "--embedder_entry_points_manifest=");
   if (name != NULL) {
     entry_points_files->AddArgument(name);
     return true;
   }
   return false;
 }
 
@@ skipping 55 matching lines @@
   while ((i < argc) && IsValidFlag(argv[i], kPrefix, kPrefixLen)) {
     if (ProcessSnapshotKindOption(argv[i]) ||
         ProcessVmSnapshotDataOption(argv[i]) ||
         ProcessVmSnapshotInstructionsOption(argv[i]) ||
         ProcessIsolateSnapshotDataOption(argv[i]) ||
         ProcessIsolateSnapshotInstructionsOption(argv[i]) ||
         ProcessAssemblyOption(argv[i]) ||
         ProcessScriptSnapshotOption(argv[i]) ||
         ProcessDependenciesOption(argv[i]) ||
         ProcessDependenciesOnlyOption(argv[i]) ||
+        ProcessPrintDependenciesOption(argv[i]) ||
         ProcessEmbedderEntryPointsManifestOption(argv[i]) ||
         ProcessURLmappingOption(argv[i]) || ProcessPackageRootOption(argv[i]) ||
         ProcessPackagesOption(argv[i]) || ProcessEnvironmentOption(argv[i])) {
       i += 1;
       continue;
     }
     vm_options->AddArgument(argv[i]);
     i += 1;
   }
 
@@ skipping 247 matching lines @@
 
 
 static void CreateAndWriteDependenciesFile() {
   IsolateData* isolate_data =
       reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
   MallocGrowableArray<char*>* dependencies = isolate_data->dependencies();
   if (dependencies == NULL) {
     return;
   }
 
-  ASSERT(dependencies_filename != NULL);
-  File* file = File::Open(dependencies_filename, File::kWriteTruncate);
-  if (file == NULL) {
-    Log::PrintErr("Error: Unable to open dependencies file: %s\n\n",
-                  dependencies_filename);
-    exit(kErrorExitCode);
+  ASSERT((dependencies_filename != NULL) || print_dependencies);
+  bool success = true;
+  File* file = NULL;
+  if (dependencies_filename != NULL) {
+    file = File::Open(dependencies_filename, File::kWriteTruncate);
+    if (file == NULL) {
+      Log::PrintErr("Error: Unable to open dependencies file: %s\n\n",
+                    dependencies_filename);
+      exit(kErrorExitCode);
+    }
+
+    // Targets:
+    switch (snapshot_kind) {
+      case kCore:
+        success &= file->Print("%s ", vm_snapshot_data_filename);
+        success &= file->Print("%s ", isolate_snapshot_data_filename);
+        break;
+      case kScript:
+        success &= file->Print("%s ", script_snapshot_filename);
+        break;
+      case kAppAOTAssembly:
+        success &= file->Print("%s ", assembly_filename);
+        break;
+      case kAppAOTBlobs:
+        success &= file->Print("%s ", vm_snapshot_data_filename);
+        success &= file->Print("%s ", vm_snapshot_instructions_filename);
+        success &= file->Print("%s ", isolate_snapshot_data_filename);
+        success &= file->Print("%s ", isolate_snapshot_instructions_filename);
+        break;
+    }
+
+    success &= file->Print(": ");
   }
-  bool success = true;
-
-  // Targets:
-  switch (snapshot_kind) {
-    case kCore:
-      success &= file->Print("%s ", vm_snapshot_data_filename);
-      success &= file->Print("%s ", isolate_snapshot_data_filename);
-      break;
-    case kScript:
-      success &= file->Print("%s ", script_snapshot_filename);
-      break;
-    case kAppAOTAssembly:
-      success &= file->Print("%s ", assembly_filename);
-      break;
-    case kAppAOTBlobs:
-      success &= file->Print("%s ", vm_snapshot_data_filename);
-      success &= file->Print("%s ", vm_snapshot_instructions_filename);
-      success &= file->Print("%s ", isolate_snapshot_data_filename);
-      success &= file->Print("%s ", isolate_snapshot_instructions_filename);
-      break;
-  }
-
-  success &= file->Print(": ");
 
   // Sources:
   if (snapshot_kind == kScript) {
-    success &= file->Print("%s ", vm_snapshot_data_filename);
-    success &= file->Print("%s ", isolate_snapshot_data_filename);
+    if (dependencies_filename != NULL) {
+      success &= file->Print("%s ", vm_snapshot_data_filename);
+      success &= file->Print("%s ", isolate_snapshot_data_filename);
+    }
+    if (print_dependencies) {
+      Log::Print("%s\n", vm_snapshot_data_filename);
+      Log::Print("%s\n", isolate_snapshot_data_filename);
+    }
   }
   for (intptr_t i = 0; i < dependencies->length(); i++) {
     char* dep = dependencies->At(i);
-    success &= file->Print("%s ", dep);
+    if (dependencies_filename != NULL) {
+      success &= file->Print("%s ", dep);
+    }
+    if (print_dependencies) {
+      Log::Print("%s\n", dep);
+    }
     free(dep);
   }
-  success &= file->Print("\n");
 
-  if (!success) {
-    Log::PrintErr("Error: Unable to write dependencies file: %s\n\n",
-                  dependencies_filename);
-    exit(kErrorExitCode);
+  if (dependencies_filename != NULL) {
+    success &= file->Print("\n");
+
+    if (!success) {
+      Log::PrintErr("Error: Unable to write dependencies file: %s\n\n",
+                    dependencies_filename);
+      exit(kErrorExitCode);
+    }
+    file->Release();
   }
-  file->Release();
   delete dependencies;
   isolate_data->set_dependencies(NULL);
 }
 
 
 static Dart_Handle CreateSnapshotLibraryTagHandler(Dart_LibraryTag tag,
                                                    Dart_Handle library,
                                                    Dart_Handle url) {
   if (!Dart_IsLibrary(library)) {
     return Dart_NewApiError("not a library");
@@ skipping 97 matching lines @@
 "                                 package:...  imports.                      \n"
 "                                                                            \n"
 "   --packages=<packages_file>    Where to find a package spec file          \n"
 "                                                                            \n"
 "   --url_mapping=<mapping>       Uses the URL mapping(s) specified on       \n"
 "                                 the command line to load the               \n"
 "                                 libraries.                                 \n"
 "   --dependencies=<output-file>  Generates a Makefile with snapshot output  \n"
 "                                 files as targets and all transitive imports\n"
 "                                 as sources.                                \n"
+"   --print_dependencies          Prints all transitive imports to stdout.   \n"
 "   --dependencies_only           Don't create and output the snapshot.      \n"
 "                                                                            \n"
 " To create a core snapshot:                                                 \n"
 "   --snapshot_kind=core                                                     \n"
 "   --vm_snapshot_data=<output-file>                                         \n"
 "   --isolate_snapshot_data=<output-file>                                    \n"
 "   [<dart-script-file>]                                                     \n"
 "                                                                            \n"
 " Writes a snapshot of <dart-script-file> to the specified snapshot files.   \n"
 " If no <dart-script-file> is passed, a generic snapshot of all the corelibs \n"
@@ skipping 706 matching lines @@
     Dart_ExitIsolate();
 
     // Now we create an isolate into which we load all the code that needs to
     // be in the snapshot.
     isolate_data = new IsolateData(NULL, NULL, NULL, NULL);
     const uint8_t* kernel = NULL;
     intptr_t kernel_length = 0;
     const bool is_kernel_file =
         TryReadKernel(app_script_name, &kernel, &kernel_length);
 
-    if (dependencies_filename != NULL) {
+    if ((dependencies_filename != NULL) || print_dependencies) {
       isolate_data->set_dependencies(new MallocGrowableArray<char*>());
     }
 
     void* kernel_program = NULL;
     if (is_kernel_file) {
       kernel_program = Dart_ReadKernelBinary(kernel, kernel_length);
       free(const_cast<uint8_t*>(kernel));
     }
 
     Dart_Isolate isolate =
@@ skipping 92 matching lines @@
   delete mapped_isolate_snapshot_data;
   return 0;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   return dart::bin::main(argc, argv);
 }