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 49 matching lines @@
 
 
 // The core snapshot to use when creating isolates. Normally NULL, but loaded
 // from a file when creating script snapshots.
 const uint8_t* isolate_snapshot_data = NULL;
 
 
 // Global state that indicates whether a snapshot is to be created and
 // if so which file to write the snapshot into.
 enum SnapshotKind {
-  kNone,
   kCore,
   kScript,
   kAppAOTBlobs,
   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 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 108 matching lines @@
   if (strncmp(option, name, length) == 0) {
     return (option + length);
   }
   return NULL;
 }
 
 
 static bool ProcessSnapshotKindOption(const char* option) {
   const char* kind = ProcessOption(option, "--snapshot_kind=");
   if (kind == NULL) {
+    kind = ProcessOption(option, "--snapshot-kind=");
+  }

[siva, 2017/02/27 22:03:37]

With these changes of accepting '-' and '_' gen_snapshot is not consistent with
command line dart, we should reconcile this in command line dart too.

[rmacnak, 2017/02/27 23:18:00]

Agreed

+  if (kind == NULL) {
     return false;
   }
-  if (strcmp(kind, "none") == 0) {
-    snapshot_kind = kNone;
-    return true;
-  } else if (strcmp(kind, "core") == 0) {
+  if (strcmp(kind, "core") == 0) {
     snapshot_kind = kCore;
     return true;
   } else if (strcmp(kind, "script") == 0) {
     snapshot_kind = kScript;
     return true;
   } else if (strcmp(kind, "app-aot-blobs") == 0) {
     snapshot_kind = kAppAOTBlobs;
     return true;
   } else if (strcmp(kind, "app-aot-assembly") == 0) {
     snapshot_kind = kAppAOTAssembly;
     return true;
   }
   Log::PrintErr(
       "Unrecognized snapshot kind: '%s'\nValid kinds are: "
       "core, script, app-aot-blobs, app-aot-assembly\n",
       kind);
   return false;
 }
 
 
 static bool ProcessVmSnapshotDataOption(const char* option) {
   const char* name = ProcessOption(option, "--vm_snapshot_data=");
+  if (name == NULL) {
+    name = ProcessOption(option, "--vm-snapshot-data=");
+  }
   if (name != NULL) {
     vm_snapshot_data_filename = name;
     return true;
   }
   return false;
 }
 
 
 static bool ProcessVmSnapshotInstructionsOption(const char* option) {
   const char* name = ProcessOption(option, "--vm_snapshot_instructions=");
+  if (name == NULL) {
+    name = ProcessOption(option, "--vm-snapshot-instructions=");
+  }
   if (name != NULL) {
     vm_snapshot_instructions_filename = name;
     return true;
   }
   return false;
 }
 
 
 static bool ProcessIsolateSnapshotDataOption(const char* option) {
   const char* name = ProcessOption(option, "--isolate_snapshot_data=");
+  if (name == NULL) {
+    name = ProcessOption(option, "--isolate-snapshot-data=");
+  }
   if (name != NULL) {
     isolate_snapshot_data_filename = name;
     return true;
   }
   return false;
 }
 
 
 static bool ProcessIsolateSnapshotInstructionsOption(const char* option) {
   const char* name = ProcessOption(option, "--isolate_snapshot_instructions=");
+  if (name == NULL) {
+    name = ProcessOption(option, "--isolate-snapshot-instructions=");
+  }
   if (name != NULL) {
     isolate_snapshot_instructions_filename = name;
     return true;
   }
   return false;
 }
 
 
 static bool ProcessAssemblyOption(const char* option) {
   const char* name = ProcessOption(option, "--assembly=");
   if (name != NULL) {
     assembly_filename = name;
     return true;
   }
   return false;
 }
 
 
 static bool ProcessScriptSnapshotOption(const char* option) {
   const char* name = ProcessOption(option, "--script_snapshot=");
+  if (name == NULL) {
+    name = ProcessOption(option, "--script-snapshot=");
+  }
   if (name != NULL) {
     script_snapshot_filename = name;
     return true;
   }
   return false;
 }
 
 
 static bool ProcessDependenciesOption(const char* option) {
   const char* name = ProcessOption(option, "--dependencies=");
   if (name != NULL) {
     dependencies_filename = name;
     return true;
   }
   return false;
 }
 
 
+static bool ProcessDependenciesOnlyOption(const char* option) {
+  const char* name = ProcessOption(option, "--dependencies_only");
+  if (name == NULL) {
+    name = ProcessOption(option, "--dependencies-only");
+  }
+  if (name != NULL) {
+    dependencies_only = 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 53 matching lines @@
   // Parse out the vm options.
   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]) ||
         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;
   }
 
   // Get the script name.
   if (i < argc) {
     *script_name = argv[i];
     i += 1;
   } else {
     *script_name = NULL;
   }
 
   // Verify consistency of arguments.
   if ((commandline_package_root != NULL) &&
       (commandline_packages_file != NULL)) {
     Log::PrintErr(
         "Specifying both a packages directory and a packages "
         "file is invalid.\n\n");
     return -1;
   }
 
   switch (snapshot_kind) {
-    case kNone: {
-      if (*script_name == NULL) {
-        Log::PrintErr(
-            "Building without snapshot generation requires a Dart "
-            "script.\n\n");
-        return -1;
-      }
-      break;
-    }
     case kCore: {
       if ((vm_snapshot_data_filename == NULL) ||
           (isolate_snapshot_data_filename == NULL)) {
         Log::PrintErr(
             "Building a core snapshot requires specifying output files for "
             "--vm_snapshot_data and --isolate_snapshot_data.\n\n");
         return -1;
       }
       break;
     }
     case kScript: {
       if ((vm_snapshot_data_filename == NULL) ||
           (isolate_snapshot_data_filename == NULL) ||
           (script_snapshot_filename == NULL) || (*script_name == NULL)) {
         Log::PrintErr(
             "Building a script snapshot requires specifying input files for "
             "--vm_snapshot_data and --isolate_snapshot_data, an output file "
-            "for --script-snapshot, and a Dart script.\n\n");
+            "for --script_snapshot, and a Dart script.\n\n");
         return -1;
       }
       break;
     }
     case kAppAOTBlobs: {
       if ((vm_snapshot_data_filename == NULL) ||
           (vm_snapshot_instructions_filename == NULL) ||
           (isolate_snapshot_data_filename == NULL) ||
           (isolate_snapshot_instructions_filename == NULL) ||
           (*script_name == NULL)) {
@@ skipping 211 matching lines @@
   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);
   }
   bool success = true;
 
   // Targets:
-  if (vm_snapshot_data_filename != NULL) {
-    success &=
-        file->Print("%s ", File::GetCanonicalPath(vm_snapshot_data_filename));
-  }
-  if (vm_snapshot_instructions_filename != NULL) {
-    success &= file->Print(
-        "%s ", File::GetCanonicalPath(vm_snapshot_instructions_filename));
-  }
-  if (isolate_snapshot_data_filename != NULL) {
-    success &= file->Print(
-        "%s ", File::GetCanonicalPath(isolate_snapshot_data_filename));
-  }
-  if (isolate_snapshot_instructions_filename != NULL) {
-    success &= file->Print(
-        "%s ", File::GetCanonicalPath(isolate_snapshot_instructions_filename));
-  }
-  if (assembly_filename != NULL) {
-    success &= file->Print("%s ", File::GetCanonicalPath(assembly_filename));
-  }
-  if (script_snapshot_filename != NULL) {
-    success &=
-        file->Print("%s ", File::GetCanonicalPath(script_snapshot_filename));
+  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);
+  }
   for (intptr_t i = 0; i < dependencies->length(); i++) {
     char* dep = dependencies->At(i);
     success &= file->Print("%s ", dep);
     free(dep);
   }
   success &= file->Print("\n");
 
   if (!success) {
     Log::PrintErr("Error: Unable to write dependencies file: %s\n\n",
                   dependencies_filename);
@@ skipping 110 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"
-"                                                                            \n"
-" To discover dependencies without generating a snapshot:                    \n"
-"   --snapshot_kind=none                                                     \n"
-"   --dependencies=<output-file>                                             \n"
-"   <dart-script-file>                                                       \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"
 " is created.                                                                \n"
@@ skipping 768 matching lines @@
       library = LoadSnapshotCreationScript(app_script_name);
       CHECK_RESULT(library);
 
       ImportNativeEntryPointLibrariesIntoRoot(entry_points);
     }
 
     // Ensure that we mark all libraries as loaded.
     result = Dart_FinalizeLoading(false);
     CHECK_RESULT(result);
 
-    switch (snapshot_kind) {
-      case kNone:
-        break;
-      case kCore:
-        CreateAndWriteCoreSnapshot();
-        break;
-      case kScript:
-        CreateAndWriteScriptSnapshot();
-        break;
-      case kAppAOTBlobs:
-      case kAppAOTAssembly:
-        CreateAndWritePrecompiledSnapshot(entry_points);
-        break;
-      default:
-        UNREACHABLE();
+    if (!dependencies_only) {
+      switch (snapshot_kind) {
+        case kCore:
+          CreateAndWriteCoreSnapshot();
+          break;
+        case kScript:
+          CreateAndWriteScriptSnapshot();
+          break;
+        case kAppAOTBlobs:
+        case kAppAOTAssembly:
+          CreateAndWritePrecompiledSnapshot(entry_points);
+          break;
+        default:
+          UNREACHABLE();
+      }
     }
 
     CreateAndWriteDependenciesFile();
 
     Dart_ExitScope();
     Dart_ShutdownIsolate();
 
     CleanupEntryPointsCollection(entry_points);
 
     Dart_EnterIsolate(UriResolverIsolateScope::isolate);
@@ skipping 15 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);
 }