Fix Ninja Output for Windows

- Ninja requires that `:`s in filenames be escaped as `$:`
- Explicitly call cmd.exe /C on Windows
- In addition, escape spaces for the command that we pass to cmd.exe

Author: gmittert

Sources/ISDBTibs/TibsBuilder.swift

@@ -257,6 +257,82 @@ extension TibsBuilder {
     return result
   }
 
+#if os(Windows)
+  private func quoteWindowsCommandLine(_ commandLine: [String]) -> String {
+    func quoteWindowsCommandArg(arg: String) -> String {
+      // Windows escaping, adapted from Daniel Colascione's "Everyone quotes
+      // command line arguments the wrong way" - Microsoft Developer Blog
+      if !arg.contains(where: {" \t\n\"".contains($0)}) {
+        return arg
+      }
+
+      // To escape the command line, we surround the argument with quotes. However
+      // the complication comes due to how the Windows command line parser treats
+      // backslashes (\) and quotes (")
+      //
+      // - \ is normally treated as a literal backslash
+      //     - e.g. foo\bar\baz => foo\bar\baz
+      // - However, the sequence \" is treated as a literal "
+      //     - e.g. foo\"bar => foo"bar
+      //
+      // But then what if we are given a path that ends with a \? Surrounding
+      // foo\bar\ with " would be "foo\bar\" which would be an unterminated string
+
+      // since it ends on a literal quote. To allow this case the parser treats:
+      //
+      // - \\" as \ followed by the " metachar
+      // - \\\" as \ followed by a literal "
+      // - In general:
+      //     - 2n \ followed by " => n \ followed by the " metachar
+      //     - 2n+1 \ followed by " => n \ followed by a literal "
+      var quoted = "\""
+      var unquoted = arg.unicodeScalars
+
+      while !unquoted.isEmpty {
+        guard let firstNonBackslash = unquoted.firstIndex(where: { $0 != "\\" }) else {
+          // String ends with a backslash e.g. foo\bar\, escape all the backslashes
+          // then add the metachar " below
+          let backslashCount = unquoted.count
+          quoted.append(String(repeating: "\\", count: backslashCount * 2))
+          break
+        }
+        let backslashCount = unquoted.distance(from: unquoted.startIndex, to: firstNonBackslash)
+        if (unquoted[firstNonBackslash] == "\"") {
+          // This is  a string of \ followed by a " e.g. foo\"bar. Escape the
+          // backslashes and the quote
+          quoted.append(String(repeating: "\\", count: backslashCount * 2 + 1))
+          quoted.append(String(unquoted[firstNonBackslash]))
+        } else {
+          // These are just literal backslashes
+          quoted.append(String(repeating: "\\", count: backslashCount))
+          quoted.append(String(unquoted[firstNonBackslash]))
+        }
+        // Drop the backslashes and the following character
+        unquoted.removeFirst(backslashCount + 1)
+      }
+      quoted.append("\"")
+      return quoted
+    }
+    return commandLine.map(quoteWindowsCommandArg).joined(separator: " ")
+  }
+#endif
+
+  private func escapeCommand(_ args: [String]) -> String {
+    let escaped: String
+#if os(Windows)
+    escaped = quoteWindowsCommandLine(args)
+#else
+    escaped = args.joined(separator: " ")
+#endif
+    return escapePath(path: escaped)
+  }
+
+  private func escapePath(path: String) -> String {
+    // Ninja escapes using $, this only matters during build lines
+    // since those are terminated by a :
+    return path.replacingOccurrences(of: ":", with: "$:")
+  }
+
   public func writeNinja<Output: TextOutputStream>(to stream: inout Output) {
     writeNinjaHeader(to: &stream)
     stream.write("\n\n")
@@ -276,23 +352,36 @@ extension TibsBuilder {
   }
 
   public func writeNinjaRules<Output: TextOutputStream>(to stream: inout Output) {
+#if os(Windows)
+    let callCmd = "cmd.exe /C "
+#else
+    let callCmd = ""
+#endif
+    let swiftIndexCommand = callCmd + """
+\(escapeCommand([toolchain.swiftc.path])) $in $IMPORT_PATHS -module-name $MODULE_NAME \
+-index-store-path index -index-ignore-system-modules \
+-output-file-map $OUTPUT_FILE_MAP \
+-emit-module -emit-module-path $MODULE_PATH -emit-dependencies \
+-pch-output-dir pch -module-cache-path ModuleCache \
+$EMIT_HEADER $BRIDGING_HEADER $EXTRA_ARGS \
+&& \(toolchain.tibs.path) swift-deps-merge $out $DEP_FILES > $out.d
+"""
+    let ccIndexCommand = callCmd + """
+\(escapeCommand([toolchain.clang.path])) -fsyntax-only $in $IMPORT_PATHS -index-store-path index \
+-index-ignore-system-symbols -fmodules -fmodules-cache-path=ModuleCache \
+-MMD -MF $OUTPUT_NAME.d -o $out $EXTRA_ARGS && touch $out
+"""
     stream.write("""
       rule swiftc_index
         description = Indexing Swift Module $MODULE_NAME
-        command = \(toolchain.swiftc.path) $in $IMPORT_PATHS -module-name $MODULE_NAME \
-          -index-store-path index -index-ignore-system-modules \
-          -output-file-map $OUTPUT_FILE_MAP \
-          -emit-module -emit-module-path $MODULE_PATH -emit-dependencies \
-          -pch-output-dir pch -module-cache-path ModuleCache \
-          $EMIT_HEADER $BRIDGING_HEADER $EXTRA_ARGS \
-          && \(toolchain.tibs.path) swift-deps-merge $out $DEP_FILES > $out.d
+        command = \(swiftIndexCommand)
         depfile = $out.d
         deps = gcc
         restat = 1 # Swift doesn't rewrite modules that haven't changed
 
       rule cc_index
         description = Indexing $in
-        command = \(toolchain.clang.path) -fsyntax-only $in $IMPORT_PATHS -index-store-path index -index-ignore-system-symbols -fmodules -fmodules-cache-path=ModuleCache -MMD -MF $OUTPUT_NAME.d -o $out $EXTRA_ARGS && touch $out
+        command = \(ccIndexCommand)
         depfile = $out.d
         deps = gcc
       """)
@@ -324,9 +413,9 @@ extension TibsBuilder {
     }
 
     stream.write("""
-      build \(outputs.joined(separator: " ")) : \
-      swiftc_index \(module.sources.map { $0.path }.joined(separator: " ")) \
-      | \(deps.joined(separator: " "))
+      build \(escapePath(path: outputs.joined(separator: " "))) : \
+      swiftc_index \(module.sources.map { escapePath(path: $0.path) }.joined(separator: " ")) \
+      | \(escapePath(path: deps.joined(separator: " ")))
         MODULE_NAME = \(module.name)
         MODULE_PATH = \(module.emitModulePath)
         IMPORT_PATHS = \(module.importPaths.map { "-I \($0)" }.joined(separator: " "))
@@ -341,8 +430,8 @@ extension TibsBuilder {
   public func writeNinjaSnippet<Output: TextOutputStream>(for tu: TibsResolvedTarget.ClangTU, to stream: inout Output) {
 
     stream.write("""
-      build \(tu.outputPath): \
-      cc_index \(tu.source.path) | \(toolchain.clang.path) \(tu.generatedHeaderDep ?? "")
+      build \(escapePath(path: tu.outputPath)): \
+      cc_index \(escapePath(path: tu.source.path)) | \(escapePath(path: toolchain.clang.path)) \(tu.generatedHeaderDep ?? "")
         IMPORT_PATHS = \(tu.importPaths.map { "-I \($0)" }.joined(separator: " "))
         OUTPUT_NAME = \(tu.outputPath)
         EXTRA_ARGS = \(tu.extraArgs.joined(separator: " "))