Implement SignalHandler on Windows

Author: gmittert

Sources/SPMUtility/InterruptHandler.swift

@@ -14,28 +14,54 @@ import Basic
 /// Interrupt signal handling global variables
 private var wasInterrupted = false
 private var wasInterruptedLock = Lock()
+#if os(Windows)
+private var signalWatchingPipe: [HANDLE] = [INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE]
+#else
 private var signalWatchingPipe: [Int32] = [0, 0]
 private var oldAction = sigaction()
+#endif
 
 /// This class can be used by command line tools to install a handler which
 /// should be called when a interrupt signal is delivered to the process.
 public final class InterruptHandler {
 
     /// The thread which waits to be notified when a signal is received.
     let thread: Thread
+  #if os(Windows)
+    let signalHandler: @convention(c)(UInt32) -> Int32
+  #else
+    let signalHandler: @convention(c)(Int32) -> Void
+  #endif
 
     /// Start watching for interrupt signal and call the handler whenever the signal is received.
     public init(_ handler: @escaping () -> Void) throws {
         // Create a signal handler.
-        let signalHandler: @convention(c)(Int32) -> Void = { _ in
+        signalHandler = { _ in
             // Turn on the interrupt bool.
             wasInterruptedLock.withLock {
                 wasInterrupted = true
             }
             // Write on pipe to notify the watching thread.
             var byte: UInt8 = 0
+          #if os(Windows)
+            var bytesWritten: DWORD = 0
+            WriteFile(signalWatchingPipe[1], &byte, 1, &bytesWritten, nil) 
+            return TRUE
+          #else
             write(signalWatchingPipe[1], &byte, 1)
+          #endif
         }
+      #if os(Windows)
+        SetConsoleCtrlHandler(signalHandler, TRUE)
+
+        var readPipe: HANDLE?
+        var writePipe: HANDLE?
+        let rv = CreatePipe(&readPipe, &writePipe, nil, 1)
+        signalWatchingPipe = [readPipe!, writePipe!]
+        guard rv != FALSE else {
+            throw SystemError.pipe(rv)
+        }
+      #else
         var action = sigaction()
       #if canImport(Darwin)
         action.__sigaction_u.__sa_handler = signalHandler
@@ -51,13 +77,19 @@ public final class InterruptHandler {
         guard rv == 0 else {
             throw SystemError.pipe(rv)
         }
+      #endif
 
         // This thread waits to be notified via pipe. If something is read from pipe, check the interrupt bool
         // and send termination signal to all spawned processes in the process group.
         thread = Thread {
             while true {
                 var buf: Int8 = 0
+              #if os(Windows)
+                var n: DWORD = 0
+                ReadFile(signalWatchingPipe[1], &buf, 1, &n, nil)
+              #else
                 let n = read(signalWatchingPipe[0], &buf, 1)
+              #endif
                 // Pipe closed, nothing to do.
                 if n == 0 { break }
                 // Read the value of wasInterrupted and set it to false.
@@ -71,15 +103,24 @@ public final class InterruptHandler {
                     handler()
                 }
             }
+          #if os(Windows)
+            CloseHandle(signalWatchingPipe[0])
+          #else
             close(signalWatchingPipe[0])
+          #endif
         }
         thread.start()
     }
 
     deinit {
+      #if os(Windows)
+        SetConsoleCtrlHandler(signalHandler, FALSE)
+        CloseHandle(signalWatchingPipe[1])
+      #else
         // Restore the old action and close the write end of pipe.
         sigaction(SIGINT, &oldAction, nil)
         close(signalWatchingPipe[1])
+      #endif
         thread.join()
     }
 }