Add --packages option to gen_snapshot in order to accept package map files (see https://github.com/…

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 45 matching lines @@
   }
 
 
 // Global state that indicates whether a snapshot is to be created and
 // if so which file to write the snapshot into.
 static const char* vm_isolate_snapshot_filename = NULL;
 static const char* isolate_snapshot_filename = NULL;
 static const char* assembly_filename = NULL;
 static const char* instructions_blob_filename = NULL;
 static const char* rodata_blob_filename = NULL;
-static const char* package_root = 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
+// free'd.)
+static const char* commandline_packages_file = NULL;
 
 
 // Global state which contains a pointer to the script name for which
 // a snapshot needs to be created (NULL would result in the creation
 // of a generic snapshot that contains only the corelibs).
 static char* app_script_name = NULL;
 
 
 // Global state that captures the URL mappings specified on the command line.
 static CommandLineOptions* url_mapping = NULL;
@@ skipping 165 matching lines @@
   return false;
 }
 
 
 static bool ProcessPackageRootOption(const char* option) {
   const char* name = ProcessOption(option, "--package_root=");
   if (name == NULL) {
     name = ProcessOption(option, "--package-root=");
   }
   if (name != NULL) {
-    package_root = name;
+    commandline_package_root = name;
     return true;
   }
   return false;
+}
+
+
+static bool ProcessPackagesOption(const char* option) {
+  const char* name = ProcessOption(option, "--packages=");
+  if (name != NULL) {
+    commandline_packages_file = name;
+    return true;
+  }
+  return false;
 }
 
 
 static bool ProcessURLmappingOption(const char* option) {
   const char* mapping = ProcessOption(option, "--url_mapping=");
   if (mapping == NULL) {
     mapping = ProcessOption(option, "--url-mapping=");
   }
   if (mapping != NULL) {
     url_mapping->AddArgument(mapping);
@@ skipping 23 matching lines @@
   // Parse out the vm options.
   while ((i < argc) && IsValidFlag(argv[i], kPrefix, kPrefixLen)) {
     if (ProcessVmIsolateSnapshotOption(argv[i]) ||
         ProcessIsolateSnapshotOption(argv[i]) ||
         ProcessAssemblyOption(argv[i]) ||
         ProcessInstructionsBlobOption(argv[i]) ||
         ProcessRodataBlobOption(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");
+    return -1;
+  }
+
   if (vm_isolate_snapshot_filename == NULL) {
     Log::PrintErr("No vm isolate snapshot output file specified.\n\n");
     return -1;
   }
 
   if (isolate_snapshot_filename == NULL) {
     Log::PrintErr("No isolate snapshot output file specified.\n\n");
     return -1;
   }
 
@@ skipping 314 matching lines @@
 "                                                                            \n"
 "  Supported options:                                                        \n"
 "    --vm_isolate_snapshot=<file>      A full snapshot is a compact          \n"
 "    --isolate_snapshot=<file>         representation of the dart vm isolate \n"
 "                                      heap and dart isolate heap states.    \n"
 "                                      Both these options are required       \n"
 "                                                                            \n"
 "    --package_root=<path>             Where to find packages, that is,      \n"
 "                                      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"
 "                                                                            \n"
 "    --assembly=<file>                 (Precompilation only) Contains the    \n"
 "                                      assembly that must be linked into     \n"
 "                                      the target binary                     \n"
 "                                                                            \n"
 "    --instructions_blob=<file>        (Precompilation only) Contains the    \n"
 "    --rodata_blob=<file>              instructions and read-only data that  \n"
@@ skipping 620 matching lines @@
     // Set up 'package root' for URI resolution.
     result = DartUtils::PrepareForScriptLoading(false, false);
     CHECK_RESULT(result);
 
     // Set up the load port provided by the service isolate so that we can
     // load scripts.
     result = DartUtils::SetupServiceLoadPort();
     CHECK_RESULT(result);
 
     // Setup package root if specified.
-    result = DartUtils::SetupPackageRoot(package_root, NULL);
+    result = DartUtils::SetupPackageRoot(commandline_package_root,
+                                         commandline_packages_file);
     CHECK_RESULT(result);
 
     Dart_ExitScope();
     Dart_ExitIsolate();
 
     UriResolverIsolateScope::isolate = isolate;
 
     // 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);
@@ skipping 49 matching lines @@
   EventHandler::Stop();
   return 0;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   return dart::bin::main(argc, argv);
 }