GN Build fixes for Flutter + gen_snapshot fix

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 23 matching lines @@
     Dart_ShutdownIsolate();                                                    \
     exit(255);                                                                 \
   }                                                                            \
 
 
 // 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* instructions_snapshot_filename = NULL;
-static const char* embedder_entry_points_manifest = NULL;
 static const char* package_root = 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;
 
+// Global state that captures the entry point manifest files specified on the
+// command line.
+static CommandLineOptions* entry_points_files = NULL;
+
 static bool IsValidFlag(const char* name,
                         const char* prefix,
                         intptr_t prefix_length) {
   intptr_t name_length = strlen(name);
   return ((name_length > prefix_length) &&
           (strncmp(name, prefix, prefix_length) == 0));
 }
 
 
 static const char* ProcessOption(const char* option, const char* name) {
@@ skipping 31 matching lines @@
     instructions_snapshot_filename = name;
     return true;
   }
   return false;
 }
 
 
 static bool ProcessEmbedderEntryPointsManifestOption(const char* option) {
   const char* name = ProcessOption(option, "--embedder_entry_points_manifest=");
   if (name != NULL) {
-    embedder_entry_points_manifest = name;
+    entry_points_files->AddArgument(name);
     return true;
   }
   return false;
 }
 
 
 static bool ProcessPackageRootOption(const char* option) {
   const char* name = ProcessOption(option, "--package_root=");
   if (name != NULL) {
     package_root = name;
@@ skipping 55 matching lines @@
     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;
   }
 
   if ((instructions_snapshot_filename != NULL) &&
-      (embedder_entry_points_manifest == NULL)) {
+      (entry_points_files->count() == 0)) {
     Log::PrintErr(
         "Specifying an instructions snapshot filename indicates precompilation"
         ". But no embedder entry points manifest was specified.\n\n");
     return -1;
   }
 
-  if ((embedder_entry_points_manifest != NULL) &&
+  if ((entry_points_files->count() > 0) &&
       (instructions_snapshot_filename == NULL)) {
     Log::PrintErr(
         "Specifying the embedder entry points manifest indicates "
         "precompilation. But no instuctions snapshot was specified.\n\n");
     return -1;
   }
 
   return 0;
 }
 
 
 static bool IsSnapshottingForPrecompilation(void) {
-  return embedder_entry_points_manifest != NULL &&
-         instructions_snapshot_filename != NULL;
+  return (entry_points_files->count() > 0) &&
+         (instructions_snapshot_filename != NULL);
 }
 
 
 static void WriteSnapshotFile(const char* filename,
                               const uint8_t* buffer,
                               const intptr_t size) {
   File* file = File::Open(filename, File::kWriteTruncate);
   ASSERT(file != NULL);
   if (!file->WriteFully(buffer, size)) {
     Log::PrintErr("Error: Failed to write snapshot file.\n\n");
@@ skipping 558 matching lines @@
 
     entries++;
   }
 
   free(line);
 
   return entries;
 }
 
 
-static Dart_QualifiedFunctionName* ParseEntryPointsManifestFile(
-    const char* path) {
-  if (path == NULL) {
-    return NULL;
+static Dart_QualifiedFunctionName* ParseEntryPointsManifestFiles() {
+  // Total number of entries across all manifest files.
+  int64_t entry_count = 0;

[Florian Schneider, 2016/04/19 22:05:23]

intptr_t

+
+  // Parse the files once but don't store the results. This is done to first
+  // determine the number of entries in the manifest
+  for (intptr_t i = 0; i < entry_points_files->count(); i++) {
+    const char* path = entry_points_files->GetArgument(i);
+
+    FILE* file = fopen(path, "r");
+
+    if (file == NULL) {
+      Log::PrintErr("Could not open entry points manifest file `%s`\n", path);
+      return NULL;
+    }
+
+    int64_t entries = ParseEntryPointsManifestLines(file, NULL);

[Florian Schneider, 2016/04/19 22:05:23]

intptr_t

+    fclose(file);
+
+    if (entries <= 0) {
+      Log::PrintErr(
+          "Manifest file `%s` specified is invalid or contained no entries\n",
+          path);
+      return NULL;
+    }
+
+    entry_count += entries;
   }
 
-  FILE* file = fopen(path, "r");
-
-  if (file == NULL) {
-    Log::PrintErr("Could not open entry points manifest file\n");
-    return NULL;
-  }
-
-  // Parse the file once but don't store the results. This is done to first
-  // determine the number of entries in the manifest
-  int64_t entry_count = ParseEntryPointsManifestLines(file, NULL);
-
-  if (entry_count <= 0) {
-    Log::PrintErr(
-        "Manifest file specified is invalid or contained no entries\n");
-    fclose(file);
-    return NULL;
-  }
-
-  rewind(file);
-
   // Allocate enough storage for the entries in the file plus a termination
   // sentinel and parse it again to populate the allocation
   Dart_QualifiedFunctionName* entries =
       reinterpret_cast<Dart_QualifiedFunctionName*>(
           calloc(entry_count + 1, sizeof(Dart_QualifiedFunctionName)));
 
-  int64_t parsed_entry_count = ParseEntryPointsManifestLines(file, entries);
+  int64_t parsed_entry_count = 0;

[Florian Schneider, 2016/04/19 22:05:23]

intptr_t

+  for (intptr_t i = 0; i < entry_points_files->count(); i++) {
+    const char* path = entry_points_files->GetArgument(i);
+    FILE* file = fopen(path, "r");

[Florian Schneider, 2016/04/19 22:05:23]

Check return value of fopen.

+    parsed_entry_count +=
+        ParseEntryPointsManifestLines(file, &entries[parsed_entry_count]);
+    fclose(file);
+  }
+
   ASSERT(parsed_entry_count == entry_count);
 
-  fclose(file);
-
   // The entries allocation must be explicitly cleaned up via
   // |CleanupEntryPointsCollection|
   return entries;
 }
 
 
 static Dart_QualifiedFunctionName* ParseEntryPointsManifestIfPresent() {
-  Dart_QualifiedFunctionName* entries =
-      ParseEntryPointsManifestFile(embedder_entry_points_manifest);
+  Dart_QualifiedFunctionName* entries = ParseEntryPointsManifestFiles();
   if ((entries == NULL) && IsSnapshottingForPrecompilation()) {
     Log::PrintErr(
         "Could not find native embedder entry points during precompilation\n");
     exit(255);
   }
   return entries;
 }
 
 
 static void CreateAndWriteSnapshot() {
@@ skipping 151 matching lines @@
 
 
 int main(int argc, char** argv) {
   const int EXTRA_VM_ARGUMENTS = 2;
   CommandLineOptions vm_options(argc + EXTRA_VM_ARGUMENTS);
 
   // Initialize the URL mapping array.
   CommandLineOptions url_mapping_array(argc);
   url_mapping = &url_mapping_array;
 
+  // Initialize the entrypoints array.
+  CommandLineOptions entry_points_files_array(argc);
+  entry_points_files = &entry_points_files_array;
+
   // Parse command line arguments.
   if (ParseArguments(argc,
                      argv,
                      &vm_options,
                      &app_script_name) < 0) {
     PrintUsage();
     return 255;
   }
 
   Thread::InitOnce();
@@ skipping 141 matching lines @@
   EventHandler::Stop();
   return 0;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   return dart::bin::main(argc, argv);
 }