Implemented _getFileSystemRepresentation for Windows

Modified the helper _getFileSystemRepresentation functions to return a
UTF16 Windows style path.

Author: gmittert

Foundation/FileManager+Win32.swift

@@ -637,8 +637,8 @@ extension FileManager {
         NSUnimplemented()
     }
 
-    internal func _lstatFile(atPath path: String, withFileSystemRepresentation fsRep: UnsafePointer<Int8>? = nil) throws -> stat {
-        let _fsRep: UnsafePointer<Int8>
+    internal func _lstatFile(atPath path: String, withFileSystemRepresentation fsRep: UnsafePointer<NativeFSRCharType>? = nil) throws -> stat {
+        let _fsRep: UnsafePointer<NativeFSRCharType>
         if fsRep == nil {
             _fsRep = try __fileSystemRepresentation(withPath: path)
         } else {
@@ -650,15 +650,13 @@ extension FileManager {
         }
 
         var statInfo = stat()
-        let h = path.withCString(encodedAs: UTF16.self) {
-            CreateFileW(/*lpFileName=*/$0,
-                        /*dwDesiredAccess=*/DWORD(0),
-                        /*dwShareMode=*/DWORD(FILE_SHARE_READ),
-                        /*lpSecurityAttributes=*/nil,
-                        /*dwCreationDisposition=*/DWORD(OPEN_EXISTING),
-                        /*dwFlagsAndAttributes=*/DWORD(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS),
-                        /*hTemplateFile=*/nil)
-        }
+        let h = CreateFileW(/*lpFileName=*/_fsRep,
+                            /*dwDesiredAccess=*/DWORD(0),
+                            /*dwShareMode=*/DWORD(FILE_SHARE_READ),
+                            /*lpSecurityAttributes=*/nil,
+                            /*dwCreationDisposition=*/DWORD(OPEN_EXISTING),
+                            /*dwFlagsAndAttributes=*/DWORD(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS),
+                            /*hTemplateFile=*/nil)
         if h == INVALID_HANDLE_VALUE {
             throw _NSErrorWithWindowsError(GetLastError(), reading: false, paths: [path])
         }
@@ -715,21 +713,16 @@ extension FileManager {
     }
 
     internal func _updateTimes(atPath path: String,
-                               withFileSystemRepresentation fsr: UnsafePointer<Int8>,
+                               withFileSystemRepresentation fsr: UnsafePointer<NativeFSRCharType>,
                                creationTime: Date? = nil,
                                accessTime: Date? = nil,
                                modificationTime: Date? = nil) throws {
       let stat = try _lstatFile(atPath: path, withFileSystemRepresentation: fsr)
 
-      var atime: FILETIME =
-          FILETIME(from: time_t((accessTime ?? stat.lastAccessDate).timeIntervalSince1970))
-      var mtime: FILETIME =
-          FILETIME(from: time_t((modificationTime ?? stat.lastModificationDate).timeIntervalSince1970))
+      var atime = FILETIME(from: time_t((accessTime ?? stat.lastAccessDate).timeIntervalSince1970))
+      var mtime = FILETIME(from: time_t((modificationTime ?? stat.lastModificationDate).timeIntervalSince1970))
 
-      let hFile: HANDLE = String(utf8String: fsr)!.withCString(encodedAs: UTF16.self) {
-        CreateFileW($0, DWORD(GENERIC_WRITE), DWORD(FILE_SHARE_WRITE),
-                    nil, DWORD(OPEN_EXISTING), 0, nil)
-      }
+      let hFile = CreateFileW(fsr, DWORD(GENERIC_WRITE), DWORD(FILE_SHARE_WRITE), nil, DWORD(OPEN_EXISTING), 0, nil)
       if hFile == INVALID_HANDLE_VALUE {
           throw _NSErrorWithWindowsError(GetLastError(), reading: true, paths: [path])
       }

Foundation/FileManager.swift

@@ -20,6 +20,14 @@ import CoreFoundation
 import MSVCRT
 #endif
 
+#if os(Windows)
+internal typealias NativeFSRCharType = WCHAR
+let NativeFSREncoding = String.Encoding.utf16LittleEndian.rawValue
+#else
+internal typealias NativeFSRCharType = CChar
+let NativeFSREncoding = String.Encoding.utf8.rawValue
+#endif
+
 open class FileManager : NSObject {
 
     /* Returns the default singleton instance.
@@ -383,7 +391,12 @@ open class FileManager : NSObject {
                     #elseif os(Linux) || os(Android) || os(Windows)
                         let modeT = number.uint32Value
                     #endif
-                    guard chmod(fsRep, mode_t(modeT)) == 0 else {
+#if os(Windows)
+                    let result = _wchmod(fsRep, mode_t(modeT))
+#else
+                    let result = chmod(fsRep, mode_t(modeT))
+#endif
+                    guard result == 0 else {
                         throw _NSErrorWithErrno(errno, reading: false, path: path)
                     }
 
@@ -992,15 +1005,31 @@ open class FileManager : NSObject {
      */
     open func fileSystemRepresentation(withPath path: String) -> UnsafePointer<Int8> {
         precondition(path != "", "Empty path argument")
+#if os(Windows)
+        return try! _fileSystemRepresentation(withPath: path) {
+            String(decodingCString: $0, as: UTF16.self).withCString() {
+                let sz = strnlen($0, Int(MAX_PATH))
+                let buf = UnsafeMutablePointer<Int8>.allocate(capacity: sz + 1)
+                buf.initialize(from: $0, count: sz + 1)
+                return UnsafePointer(buf)
+            }
+        }
+#else
         return try! __fileSystemRepresentation(withPath: path)
+#endif
     }
 
-    internal func __fileSystemRepresentation(withPath path: String) throws -> UnsafePointer<Int8> {
+    internal func __fileSystemRepresentation(withPath path: String) throws -> UnsafePointer<NativeFSRCharType> {
         let len = CFStringGetMaximumSizeOfFileSystemRepresentation(path._cfObject)
         if len != kCFNotFound {
-            let buf = UnsafeMutablePointer<Int8>.allocate(capacity: len)
+            let buf = UnsafeMutablePointer<NativeFSRCharType>.allocate(capacity: len)
             buf.initialize(repeating: 0, count: len)
-            if path._nsObject.getFileSystemRepresentation(buf, maxLength: len) {
+#if os(Windows)
+            let result = path._nsObject._getFileSystemRepresentation(buf, maxLength: len)
+#else
+            let result = path._nsObject.getFileSystemRepresentation(buf, maxLength: len)
+#endif
+            if result {
                 return UnsafePointer(buf)
             }
             buf.deinitialize(count: len)
@@ -1009,13 +1038,13 @@ open class FileManager : NSObject {
         throw NSError(domain: NSCocoaErrorDomain, code: CocoaError.fileReadInvalidFileName.rawValue, userInfo: [NSFilePathErrorKey: path])
     }
 
-    internal func _fileSystemRepresentation<ResultType>(withPath path: String, _ body: (UnsafePointer<Int8>) throws -> ResultType) throws -> ResultType {
+    internal func _fileSystemRepresentation<ResultType>(withPath path: String, _ body: (UnsafePointer<NativeFSRCharType>) throws -> ResultType) throws -> ResultType {
         let fsRep = try __fileSystemRepresentation(withPath: path)
         defer { fsRep.deallocate() }
         return try body(fsRep)
     }
 
-    internal func _fileSystemRepresentation<ResultType>(withPath path1: String, andPath path2: String, _ body: (UnsafePointer<Int8>, UnsafePointer<Int8>) throws -> ResultType) throws -> ResultType {
+    internal func _fileSystemRepresentation<ResultType>(withPath path1: String, andPath path2: String, _ body: (UnsafePointer<NativeFSRCharType>, UnsafePointer<NativeFSRCharType>) throws -> ResultType) throws -> ResultType {
         let fsRep1 = try __fileSystemRepresentation(withPath: path1)
         defer { fsRep1.deallocate() }
         let fsRep2 = try __fileSystemRepresentation(withPath: path2)
@@ -1029,7 +1058,11 @@ open class FileManager : NSObject {
     open func string(withFileSystemRepresentation str: UnsafePointer<Int8>, length len: Int) -> String {
         return NSString(bytes: str, length: len, encoding: String.Encoding.utf8.rawValue)!._swiftObject
     }
-    
+
+    internal func _string(withFileSystemRepresentation str: UnsafePointer<NativeFSRCharType>, length len: Int) -> String {
+        return NSString(bytes: str, length: len * MemoryLayout<NativeFSRCharType>.size, encoding: NativeFSREncoding)!._swiftObject
+    }
+
     /* -replaceItemAtURL:withItemAtURL:backupItemName:options:resultingItemURL:error: is for developers who wish to perform a safe-save without using the full NSDocument machinery that is available in the AppKit.
 
         The `originalItemURL` is the item being replaced.

Foundation/NSPathUtilities.swift

@@ -344,9 +344,26 @@ extension NSString {
     }
 
     public var standardizingPath: String {
+#if os(Windows)
+        // Convert to a posix style '/' separated path
+        var converted = self as String
+        if converted.isAbsolutePath {
+            // If there is anything before the drive letter, e.g. "\\?\, \\host\, \??\", remove it
+            if let idx = converted.firstIndex(of: ":") {
+              converted.removeSubrange(..<converted.index(before: idx))
+            }
+
+            if !(converted.starts(with: "/") || converted.starts(with: "\\")) {
+              converted = "/" + converted
+            }
+        }
+        converted = String(converted.map({ $0 == "\\" ? "/" : $0 }))
+        let expanded = converted.expandingTildeInPath
+#else
         let expanded = expandingTildeInPath
+#endif
         var resolved = expanded._bridgeToObjectiveC().resolvingSymlinksInPath
-        
+
         let automount = "/var/automount"
         resolved = resolved._tryToRemovePathPrefix(automount) ?? resolved
         return resolved
@@ -550,13 +567,61 @@ extension NSString {
     }
 
     public func getFileSystemRepresentation(_ cname: UnsafeMutablePointer<Int8>, maxLength max: Int) -> Bool {
+#if os(Windows)
+        let fsr = UnsafeMutablePointer<WCHAR>.allocate(capacity: max)
+        defer { fsr.deallocate() }
+        guard _getFileSystemRepresentation(fsr, maxLength: max) else { return false }
+        let str = String(decodingCString: fsr, as: UTF16.self)
+        return str.withCString() {
+            let chars = strnlen_s($0, max)
+            guard chars < max else {
+                return false
+            }
+            cname.assign(from: $0, count: chars + 1)
+            return true
+        }
+#else
         guard self.length > 0 else {
             return false
         }
-        
         return CFStringGetFileSystemRepresentation(self._cfObject, cname, max)
+#endif
     }
 
+#if os(Windows)
+    internal func _getFileSystemRepresentation(_ cname: UnsafeMutablePointer<NativeFSRCharType>, maxLength max: Int) -> Bool {
+        guard self.length > 0 else {
+            return false
+        }
+
+        var fsr = self._swiftObject
+        let idx = fsr.startIndex
+        // If we have an RFC 8089 style path /[drive-letter]:/....., drop the
+        // leading /, otherwise, a leading slash indicates a rooted path on the
+        // drive for the current working directory
+        if fsr.count >= 3 && fsr[idx] == "/" && fsr[fsr.index(after: idx)].isLetter && fsr[fsr.index(idx, offsetBy: 2)] == ":" {
+            fsr.removeFirst()
+        }
+
+        // Drop trailing slashes unless it follows a drive letter
+        while
+            fsr.count > 1
+            && (fsr[fsr.index(before: fsr.endIndex)] == "\\" || fsr[fsr.index(before: fsr.endIndex)] == "/")
+            && !(fsr.count == 3 && fsr[fsr.index(fsr.endIndex, offsetBy: -2)] == ":") {
+            fsr.removeLast()
+        }
+
+        return fsr.withCString(encodedAs: UTF16.self) {
+            let wchars = wcsnlen_s($0, max)
+            guard wchars < max else {
+                return false
+            }
+            cname.assign(from: $0, count: wchars + 1)
+            return true
+        }
+    }
+#endif
+
 }
 
 extension FileManager {

Foundation/NSURL.swift

@@ -29,10 +29,16 @@ internal let kCFURLPlatformPathStyle = kCFURLPOSIXPathStyle
 #endif
 
 private func _standardizedPath(_ path: String) -> String {
+#if os(Windows)
+    // Since Windows needs to support various types of paths, always attempt to
+    // standardize what ever we're passed
+    return path._nsObject.standardizingPath
+#else
     if !path.isAbsolutePath {
         return path._nsObject.standardizingPath
     }
     return path
+#endif
 }
 
 internal func _pathComponents(_ path: String?) -> [String]? {
@@ -360,12 +366,15 @@ open class NSURL : NSObject, NSSecureCoding, NSCopying {
     public init(fileURLWithPath path: String) {
         let thePath: String
         let pathString = NSString(string: path)
-        if !pathString.isAbsolutePath {
-            thePath = pathString.standardizingPath
-        } else {
+#if os(Windows)
+        thePath = pathString.standardizingPath
+#else
+        if pathString.isAbsolutePath {
             thePath = path
+        } else {
+            thePath = pathString.standardizingPath
         }
-
+#endif
         var isDir: ObjCBool = false
         if thePath.hasSuffix("/") {
             isDir = true
@@ -548,7 +557,7 @@ open class NSURL : NSObject, NSSecureCoding, NSCopying {
 
     open var path: String? {
         let absURL = CFURLCopyAbsoluteURL(_cfObject)
-        return CFURLCopyFileSystemPath(absURL, kCFURLPlatformPathStyle)?._swiftObject
+        return CFURLCopyFileSystemPath(absURL, kCFURLPOSIXPathStyle)?._swiftObject
     }
 
     open var fragment: String? {
@@ -565,7 +574,7 @@ open class NSURL : NSObject, NSSecureCoding, NSCopying {
 
     // The same as path if baseURL is nil
     open var relativePath: String? {
-        return CFURLCopyFileSystemPath(_cfObject, kCFURLPlatformPathStyle)?._swiftObject
+        return CFURLCopyFileSystemPath(_cfObject, kCFURLPOSIXPathStyle)?._swiftObject
     }
 
     /* Determines if a given URL string's path represents a directory (i.e. the path component in the URL string ends with a '/' character). This does not check the resource the URL refers to.