[gen_snapshot] Escape spaces when generating depfiles.

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 698 matching lines @@
   if (DartUtils::IsDartBuiltinLibURL(url)) {
     return Builtin::kBuiltinLibrary;
   }
   if (DartUtils::IsDartIOLibURL(url)) {
     return Builtin::kIOLibrary;
   }
   return Builtin::kInvalidLibrary;
 }
 
 
-static bool WriteDependencies(const char* target,
-                              File* file,
-                              MallocGrowableArray<char*>* dependencies) {
-  bool success = true;
-  success &= file->Print("%s: ", target);
+// Generates a depfile like gcc -M -MF. Must be consumable by Ninja.
+class DependenciesFileWriter : public ValueObject {
+ public:
+  DependenciesFileWriter() : dependencies_(NULL), file_(NULL), success_(true) {}
 
-  if (snapshot_kind == kScript) {
-    if (vm_snapshot_data_filename != NULL) {
-      success &= file->Print("%s ", vm_snapshot_data_filename);
-    }
-    if (vm_snapshot_instructions_filename != NULL) {
-      success &= file->Print("%s ", vm_snapshot_instructions_filename);
-    }
-    if (isolate_snapshot_data_filename != NULL) {
-      success &= file->Print("%s ", isolate_snapshot_data_filename);
-    }
-    if (isolate_snapshot_instructions_filename != NULL) {
-      success &= file->Print("%s ", isolate_snapshot_instructions_filename);
-    }
-  }
+  void WriteDependencies(MallocGrowableArray<char*>* dependencies) {
+    dependencies_ = dependencies;
 
-  for (intptr_t i = 0; i < dependencies->length(); i++) {
-    success &= file->Print("%s ", dependencies->At(i));
-  }
-
-  success &= file->Print("\n");
-  return success;
-}
-
-
-static void CreateAndWriteDependenciesFile() {
-  IsolateData* isolate_data =
-      reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
-  MallocGrowableArray<char*>* dependencies = isolate_data->dependencies();
-  if (dependencies == NULL) {
-    return;
-  }
-
-  Loader::ResolveDependenciesAsFilePaths();
-
-  ASSERT((dependencies_filename != NULL) || print_dependencies);
-  if (dependencies_filename != NULL) {
-    bool success = true;
-    File* file = File::Open(dependencies_filename, File::kWriteTruncate);
-    if (file == 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);
     }
 
     // Write dependencies for one of the output files.
     // TODO(https://github.com/ninja-build/ninja/issues/1184): Do this for all
     // output files.
     switch (snapshot_kind) {
       case kCore:
-        success &=
-            WriteDependencies(vm_snapshot_data_filename, file, dependencies);
-        // success &= WriteDependencies(isolate_snapshot_data_filename, file,
-        //                              dependencies);
+        WriteDependenciesWithTarget(vm_snapshot_data_filename);
+        // WriteDependenciesWithTarget(isolate_snapshot_data_filename);
         break;
       case kScript:
-        success &=
-            WriteDependencies(script_snapshot_filename, file, dependencies);
+        WriteDependenciesWithTarget(script_snapshot_filename);
         break;
       case kAppAOTAssembly:
-        success &= WriteDependencies(assembly_filename, file, dependencies);
+        WriteDependenciesWithTarget(assembly_filename);
         break;
       case kCoreJIT:
       case kAppAOTBlobs:
-        success &=
-            WriteDependencies(vm_snapshot_data_filename, file, dependencies);
-        // success &= WriteDependencies(vm_snapshot_instructions_filename, file,
-        //                              dependencies);
-        // success &= WriteDependencies(isolate_snapshot_data_filename, file,
-        //                              dependencies);
-        // success &= WriteDependencies(isolate_snapshot_instructions_filename,
-        //                              file, dependencies);
+        WriteDependenciesWithTarget(vm_snapshot_data_filename);
+        // WriteDependenciesWithTarget(vm_snapshot_instructions_filename);
+        // WriteDependenciesWithTarget(isolate_snapshot_data_filename);
+        // WriteDependenciesWithTarget(isolate_snapshot_instructions_filename);
         break;
     }
 
-    if (!success) {
+    if (!success_) {
       Log::PrintErr("Error: Unable to write dependencies file: %s\n\n",
                     dependencies_filename);
       exit(kErrorExitCode);
     }
-    file->Release();
+    file_->Release();
+  }
+
+ private:
+  void WriteDependenciesWithTarget(const char* target) {
+    WritePath(target);

[Chris Bracken, 2017/07/01 00:47:54]

It looks like we've just got one string for the target but IIRC, in Android ARM
AOT builds we emit multiple targets separated by spaces. Will this behave
correctly in that case?

[rmacnak, 2017/07/05 16:51:04]

Since all four files are generated by the same action, a build system that sees
any one of them as dirty should rerun the action. I've seen that this works in
Ninja.

+    Write(": ");
+
+    if (snapshot_kind == kScript) {
+      if (vm_snapshot_data_filename != NULL) {
+        WritePath(vm_snapshot_data_filename);
+      }
+      if (vm_snapshot_instructions_filename != NULL) {
+        WritePath(vm_snapshot_instructions_filename);
+      }
+      if (isolate_snapshot_data_filename != NULL) {
+        WritePath(isolate_snapshot_data_filename);
+      }
+      if (isolate_snapshot_instructions_filename != NULL) {
+        WritePath(isolate_snapshot_instructions_filename);
+      }
+    }
+
+    for (intptr_t i = 0; i < dependencies_->length(); i++) {
+      WritePath(dependencies_->At(i));
+    }
+
+    Write("\n");
+  }
+
+  char* EscapePath(const char* path) {
+    char* escaped_path = reinterpret_cast<char*>(malloc(strlen(path) * 2 + 1));
+    const char* read_cursor = path;
+    char* write_cursor = escaped_path;
+    while (*read_cursor != '\0') {
+      if ((*read_cursor == ' ') || (*read_cursor == '\\')) {
+        *write_cursor++ = '\\';
+      }
+      *write_cursor++ = *read_cursor++;
+    }
+    *write_cursor = '\0';
+    return escaped_path;
+  }
+
+  void WritePath(const char* path) {
+    char* escaped_path = EscapePath(path);
+    success_ &= file_->Print("%s ", escaped_path);
+    free(escaped_path);
+  }
+
+  void Write(const char* string) { success_ &= file_->Print("%s", string); }
+
+  MallocGrowableArray<char*>* dependencies_;
+  File* file_;
+  bool success_;
+};
+
+
+static void CreateAndWriteDependenciesFile() {
+  IsolateData* isolate_data =
+      reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
+  MallocGrowableArray<char*>* dependencies = isolate_data->dependencies();
+  if (dependencies == NULL) {
+    return;
+  }
+
+  Loader::ResolveDependenciesAsFilePaths();
+
+  ASSERT((dependencies_filename != NULL) || print_dependencies);
+  if (dependencies_filename != NULL) {
+    DependenciesFileWriter writer;
+    writer.WriteDependencies(dependencies);
   }
 
   if (print_dependencies) {
     Log::Print("%s\n", vm_snapshot_data_filename);
     if (snapshot_kind == kScript) {
       if (vm_snapshot_data_filename != NULL) {
         Log::Print("%s\n", vm_snapshot_data_filename);
       }
       if (vm_snapshot_instructions_filename != NULL) {
         Log::Print("%s\n", vm_snapshot_instructions_filename);
@@ skipping 1053 matching lines @@
   delete mapped_isolate_snapshot_instructions;
   return 0;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   return dart::bin::main(argc, argv);
 }