Merge branch 'master' of github.com:hpux735/swift-corelibs-foundation

Author: hpux735

CoreFoundation/Base.subproj/ForSwiftFoundationOnly.h

@@ -177,6 +177,10 @@ struct _NSXMLParserBridge {
                            const unsigned char *SystemID);
 };
 
+struct _NSRunLoop {
+    _Nonnull CFTypeRef (*_Nonnull _new)(CFRunLoopRef rl);
+};
+
 struct _CFSwiftBridge {
     struct _NSObjectBridge NSObject;
     struct _NSArrayBridge NSArray;
@@ -188,6 +192,7 @@ struct _CFSwiftBridge {
     struct _NSStringBridge NSString;
     struct _NSMutableStringBridge NSMutableString;
     struct _NSXMLParserBridge NSXMLParser;
+    struct _NSRunLoop NSRunLoop;
 };
 
 __attribute__((__visibility__("hidden"))) extern struct _CFSwiftBridge __CFSwiftBridge;
@@ -264,6 +269,8 @@ extern void *_CFReallocf(void *ptr, size_t size);
 
 CFHashCode CFStringHashNSString(CFStringRef str);
 
+extern CFTypeRef _CFRunLoopGet2(CFRunLoopRef rl);
+
 extern CFIndex __CFStringEncodeByteStream(CFStringRef string, CFIndex rangeLoc, CFIndex rangeLen, Boolean generatingExternalFile, CFStringEncoding encoding, uint8_t lossByte,  UInt8 * _Nullable buffer, CFIndex max, CFIndex * _Nullable usedBufLen);
 
 typedef	unsigned char __cf_uuid[16];

CoreFoundation/RunLoop.subproj/CFRunLoop.c

@@ -1526,7 +1526,12 @@ CF_PRIVATE void __CFFinalizeRunLoop(uintptr_t data) {
     }
     if (rl && CFRunLoopGetMain() != rl) { // protect against cooperative threads
         if (NULL != rl->_counterpart) {
+#if DEPLOYMENT_RUNTIME_SWIFT
+            extern void swift_release(void *);
+            swift_release((void *)rl->_counterpart);
+#else
             CFRelease(rl->_counterpart);
+#endif
 	    rl->_counterpart = NULL;
         }
 	// purge all sources before deallocation
@@ -1549,6 +1554,12 @@ pthread_t _CFRunLoopGet1(CFRunLoopRef rl) {
 CF_EXPORT CFTypeRef _CFRunLoopGet2(CFRunLoopRef rl) {
     CFTypeRef ret = NULL;
     __CFLock(&loopsLock);
+#if DEPLOYMENT_RUNTIME_SWIFT
+    if (rl->_counterpart == NULL) {
+        CFTypeRef ns = __CFSwiftBridge.NSRunLoop._new(rl); // returns retained so we will claim ownership of that return value by just assigning (the release is balanced in the destruction of the CFRunLoop
+        rl->_counterpart = ns;
+    }
+#endif
     ret = rl->_counterpart;
     __CFUnlock(&loopsLock);
     return ret;

Foundation/NSArray.swift

@@ -393,13 +393,18 @@ public class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NS
     }
 
     internal func sortedArrayFromRange(range: NSRange, options: NSSortOptions, usingComparator cmptr: NSComparator) -> [AnyObject] {
+        // The sort options are not available. We use the Array's sorting algorithm. It is not stable neither concurrent.
+        guard options.isEmpty else {
+            NSUnimplemented()
+        }
+
         let count = self.count
         if range.length == 0 || count == 0 {
             return []
         }
 
         return allObjects.sort { lhs, rhs in
-            return cmptr(lhs, rhs) == .OrderedSame
+            return cmptr(lhs, rhs) == .OrderedAscending
         }
     }
 
@@ -412,22 +417,44 @@ public class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NS
     }
 
     public func indexOfObject(obj: AnyObject, inSortedRange r: NSRange, options opts: NSBinarySearchingOptions, usingComparator cmp: NSComparator) -> Int {
-        guard (r.location + r.length) <= count else {
-            NSInvalidArgument("range \(r) extends beyond bounds [0 .. \(count - 1)]")
+        let lastIndex = r.location + r.length - 1
+        
+        // argument validation
+        guard lastIndex < count else {
+            let bounds = count == 0 ? "for empty array" : "[0 .. \(count - 1)]"
+            NSInvalidArgument("range \(r) extends beyond bounds \(bounds)")
         }
 
         if opts.contains(.FirstEqual) && opts.contains(.LastEqual) {
             NSInvalidArgument("both NSBinarySearching.FirstEqual and NSBinarySearching.LastEqual options cannot be specified")
         }
 
+        let searchForInsertionIndex = opts.contains(.InsertionIndex)
+        
+        // fringe cases
+        if r.length == 0 {
+            return  searchForInsertionIndex ? r.location : NSNotFound
+        }
+        
+        let leastObj = objectAtIndex(r.location)
+        if cmp(obj, leastObj) == .OrderedAscending {
+            return searchForInsertionIndex ? r.location : NSNotFound
+        }
+        
+        let greatestObj = objectAtIndex(lastIndex)
+        if cmp(obj, greatestObj) == .OrderedDescending {
+            return searchForInsertionIndex ? lastIndex + 1 : NSNotFound
+        }
+        
+        // common processing
         let firstEqual = opts.contains(.FirstEqual)
         let lastEqual = opts.contains(.LastEqual)
         let anyEqual = !(firstEqual || lastEqual)
 
         var result = NSNotFound
         var indexOfLeastGreaterThanObj = NSNotFound
         var start = r.location
-        var end = r.location + r.length - 1
+        var end = lastIndex
 
         loop: while start <= end {
             let middle = start + (end - start) / 2
@@ -459,18 +486,14 @@ public class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NS
             }
         }
 
-        guard opts.contains(.InsertionIndex) && lastEqual else {
+        guard searchForInsertionIndex && lastEqual else {
             return result
         }
 
         guard result == NSNotFound else {
             return result + 1
         }
 
-        guard indexOfLeastGreaterThanObj != NSNotFound else {
-            return count
-        }
-        
         return indexOfLeastGreaterThanObj
     }
 

Foundation/NSDecimalNumber.swift

@@ -84,7 +84,7 @@ public class NSDecimalNumber : NSNumber {
     public func decimalNumberByRoundingAccordingToBehavior(behavior: NSDecimalNumberBehaviors?) -> NSDecimalNumber { NSUnimplemented() }
     // Round to the scale of the behavior.
 
-    public func compare(decimalNumber: NSNumber) -> NSComparisonResult { NSUnimplemented() }
+    public override func compare(decimalNumber: NSNumber) -> NSComparisonResult { NSUnimplemented() }
     // compare two NSDecimalNumbers
 
     public class func setDefaultBehavior(behavior: NSDecimalNumberBehaviors) { NSUnimplemented() }

Foundation/NSFileManager.swift

@@ -191,20 +191,115 @@ public class NSFileManager : NSObject {
         }
     }
 
-    /* contentsOfDirectoryAtPath:error: returns an NSArray of NSStrings representing the filenames of the items in the directory. If this method returns 'nil', an NSError will be returned by reference in the 'error' parameter. If the directory contains no items, this method will return the empty array.
+    /**
+     Performs a shallow search of the specified directory and returns the paths of any contained items.
 
-        This method replaces directoryContentsAtPath:
+     This method performs a shallow search of the directory and therefore does not traverse symbolic links or return the contents of any subdirectories. This method also does not return URLs for the current directory (“.”), parent directory (“..”) but it does return other hidden files (files that begin with a period character).
+     
+     The order of the files in the returned array is undefined.
+     
+     - Parameter path: The path to the directory whose contents you want to enumerate.
+     
+     - Throws: `NSError` if the directory does not exist, this error is thrown with the associated error code.
+     
+     - Returns: An array of String each of which identifies a file, directory, or symbolic link contained in `path`. The order of the files returned is undefined.
      */
     public func contentsOfDirectoryAtPath(path: String) throws -> [String] {
-        NSUnimplemented()
+        var contents : [String] = [String]()
+        
+        let dir = opendir(path)
+        
+        if dir == nil {
+            throw NSError(domain: NSCocoaErrorDomain, code: NSCocoaError.FileReadNoSuchFileError.rawValue, userInfo: [NSFilePathErrorKey: path])
+        }
+        
+        defer {
+            closedir(dir)
+        }
+        
+        var entry: UnsafeMutablePointer<dirent> = readdir(dir)
+        
+        while entry != nil {
+            if let entryName = withUnsafePointer(&entry.memory.d_name, { (ptr) -> String? in
+                let int8Ptr = unsafeBitCast(ptr, UnsafePointer<Int8>.self)
+                return String.fromCString(int8Ptr)
+            }) {
+                // TODO: `entryName` should be limited in length to `entry.memory.d_namlen`.
+                if entryName != "." && entryName != ".." {
+                    contents.append(entryName)
+                }
+            }
+            
+            entry = readdir(dir)
+        }
+        
+        return contents
     }
 
-    /* subpathsOfDirectoryAtPath:error: returns an NSArray of NSStrings representing the filenames of the items in the specified directory and all its subdirectories recursively. If this method returns 'nil', an NSError will be returned by reference in the 'error' parameter. If the directory contains no items, this method will return the empty array.
-     
-        This method replaces subpathsAtPath:
-     */
+    /**
+    Performs a deep enumeration of the specified directory and returns the paths of all of the contained subdirectories.
+    
+    This method recurses the specified directory and its subdirectories. The method skips the “.” and “..” directories at each level of the recursion.
+    
+    Because this method recurses the directory’s contents, you might not want to use it in performance-critical code. Instead, consider using the enumeratorAtURL:includingPropertiesForKeys:options:errorHandler: or enumeratorAtPath: method to enumerate the directory contents yourself. Doing so gives you more control over the retrieval of items and more opportunities to abort the enumeration or perform other tasks at the same time.
+    
+    - Parameter path: The path of the directory to list.
+    
+    - Throws: `NSError` if the directory does not exist, this error is thrown with the associated error code.
+    
+    - Returns: An array of NSString objects, each of which contains the path of an item in the directory specified by path. If path is a symbolic link, this method traverses the link. This method returns nil if it cannot retrieve the device of the linked-to file.
+    */
     public func subpathsOfDirectoryAtPath(path: String) throws -> [String] {
-        NSUnimplemented()
+        var contents : [String] = [String]()
+        
+        let dir = opendir(path)
+        
+        if dir == nil {
+            throw NSError(domain: NSCocoaErrorDomain, code: NSCocoaError.FileReadNoSuchFileError.rawValue, userInfo: [NSFilePathErrorKey: path])
+        }
+        
+        defer {
+            closedir(dir)
+        }
+        
+        var entry = readdir(dir)
+        
+        while entry != nil {
+            if let entryName = withUnsafePointer(&entry.memory.d_name, { (ptr) -> String? in
+                let int8Ptr = unsafeBitCast(ptr, UnsafePointer<Int8>.self)
+                return String.fromCString(int8Ptr)
+            }) {
+                // TODO: `entryName` should be limited in length to `entry.memory.d_namlen`.
+                if entryName != "." && entryName != ".." {
+                    contents.append(entryName)
+                    
+                    if let entryType = withUnsafePointer(&entry.memory.d_type, { (ptr) -> Int32? in
+                        let int32Ptr = unsafeBitCast(ptr, UnsafePointer<UInt8>.self)
+                        return Int32(int32Ptr.memory)
+                    }) {
+                        #if os(OSX) || os(iOS)
+                            if entryType == DT_DIR {
+                                let subPath: String = path + "/" + entryName
+                                
+                                let entries =  try subpathsOfDirectoryAtPath(subPath)
+                                contents.appendContentsOf(entries.map({file in "\(entryName)/\(file)"}))
+                            }
+                        #elseif os(Linux)
+                            if Int(entryType) == DT_DIR {
+                                let subPath: String = path + "/" + entryName
+                                
+                                let entries =  try subpathsOfDirectoryAtPath(subPath)
+                                contents.appendContentsOf(entries.map({file in "\(entryName)/\(file)"}))
+                            }
+                        #endif
+                    }
+                }
+            }
+            
+            entry = readdir(dir)
+        }
+        
+        return contents
     }
 
     /* attributesOfItemAtPath:error: returns an NSDictionary of key/value pairs containing the attributes of the item (file, directory, symlink, etc.) at the path in question. If this method returns 'nil', an NSError will be returned by reference in the 'error' parameter. This method does not traverse a terminal symlink.

Foundation/NSGeometry.swift

@@ -485,7 +485,50 @@ public func NSOffsetRect(aRect: NSRect, _ dX: CGFloat, _ dY: CGFloat) -> NSRect
     return result
 }
 
-public func NSDivideRect(inRect: NSRect, _ slice: UnsafeMutablePointer<NSRect>, _ rem: UnsafeMutablePointer<NSRect>, _ amount: CGFloat, _ edge: NSRectEdge) { NSUnimplemented() }
+public func NSDivideRect(inRect: NSRect, _ slice: UnsafeMutablePointer<NSRect>, _ rem: UnsafeMutablePointer<NSRect>, _ amount: CGFloat, _ edge: NSRectEdge) {
+    if NSIsEmptyRect(inRect) {
+        slice.memory = NSZeroRect
+        rem.memory = NSZeroRect
+        return
+    }
+
+    let width = NSWidth(inRect)
+    let height = NSHeight(inRect)
+
+    switch (edge, amount) {
+    case (.MinX, let amount) where amount > width:
+        slice.memory = inRect
+        rem.memory = NSMakeRect(NSMaxX(inRect), NSMinY(inRect), CGFloat(0.0), height)
+
+    case (.MinX, _):
+        slice.memory = NSMakeRect(NSMinX(inRect), NSMinY(inRect), amount, height)
+        rem.memory = NSMakeRect(NSMaxX(slice.memory), NSMinY(inRect), NSMaxX(inRect) - NSMaxX(slice.memory), height)
+
+    case (.MinY, let amount) where amount > height:
+        slice.memory = inRect
+        rem.memory = NSMakeRect(NSMinX(inRect), NSMaxY(inRect), width, CGFloat(0.0))
+
+    case (.MinY, _):
+        slice.memory = NSMakeRect(NSMinX(inRect), NSMinY(inRect), width, amount)
+        rem.memory = NSMakeRect(NSMinX(inRect), NSMaxY(slice.memory), width, NSMaxY(inRect) - NSMaxY(slice.memory))
+
+    case (.MaxX, let amount) where amount > width:
+        slice.memory = inRect
+        rem.memory = NSMakeRect(NSMinX(inRect), NSMinY(inRect), CGFloat(0.0), height)
+
+    case (.MaxX, _):
+        slice.memory = NSMakeRect(NSMaxX(inRect) - amount, NSMinY(inRect), amount, height)
+        rem.memory = NSMakeRect(NSMinX(inRect), NSMinY(inRect), NSMinX(slice.memory) - NSMinX(inRect), height)
+
+    case (.MaxY, let amount) where amount > height:
+        slice.memory = inRect
+        rem.memory = NSMakeRect(NSMinX(inRect), NSMinY(inRect), width, CGFloat(0.0))
+
+    case (.MaxY, _):
+        slice.memory = NSMakeRect(NSMinX(inRect), NSMaxY(inRect) - amount, width, amount)
+        rem.memory = NSMakeRect(NSMinX(inRect), NSMinY(inRect), width, NSMinY(slice.memory) - NSMinY(inRect))
+    }
+}
 
 public func NSPointInRect(aPoint: NSPoint, _ aRect: NSRect) -> Bool {
     return NSMouseInRect(aPoint, aRect, true)

Foundation/NSHost.swift

@@ -84,9 +84,11 @@ public class NSHost : NSObject {
             if r != 0 {
                 return
             }
-            for var res: UnsafeMutablePointer<addrinfo> = res0; res != nil; res = res.memory.ai_next {
+            var res: UnsafeMutablePointer<addrinfo> = res0
+            while res != nil {
                 let family = res.memory.ai_family
                 if family != AF_INET && family != AF_INET6 {
+                    res = res.memory.ai_next
                     continue
                 }
                 let sa_len: socklen_t = socklen_t((family == AF_INET6) ? sizeof(sockaddr_in6) : sizeof(sockaddr_in))
@@ -101,6 +103,7 @@ public class NSHost : NSObject {
                 lookupInfo(&_addresses, NI_NUMERICHOST)
                 lookupInfo(&_names, NI_NAMEREQD)
                 lookupInfo(&_names, NI_NOFQDN|NI_NAMEREQD)
+                res = res.memory.ai_next
             }
 
             freeaddrinfo(res0)

Foundation/NSIndexSet.swift

@@ -556,7 +556,7 @@ public class NSMutableIndexSet : NSIndexSet {
                 // Nothing to add
                 return
             } else if range.location >= curRange.location && range.location <= curEnd && addEnd > curEnd {
-                _replaceRangeAtIndex(rangeIndex, withRange: NSMakeRange(addEnd - curRange.location, curRange.location))
+                _replaceRangeAtIndex(rangeIndex, withRange: NSMakeRange(curRange.location, addEnd - curRange.location))
                 replacedRangeIndex = rangeIndex
                 // Proceed to merging
                 break

Foundation/NSNumber.swift

@@ -381,6 +381,10 @@ public class NSNumber : NSValue {
     public required convenience init(booleanLiteral value: Bool) {
         self.init(bool: value)
     }
+
+    public func compare(otherNumber: NSNumber) -> NSComparisonResult {
+        return ._fromCF(CFNumberCompare(_cfObject, otherNumber._cfObject, nil))
+    }
 
     override internal var _cfTypeID: CFTypeID {
         return CFNumberGetTypeID()

Foundation/NSObjCRuntime.swift

@@ -80,7 +80,7 @@ public let NSNotFound: Int = Int.max
     fatalError("\(fn) is not yet implemented")
 }
 
-@noreturn func NSInvalidArgument(message: String, method: String = __FUNCTION__) {
+@noreturn internal func NSInvalidArgument(message: String, method: String = __FUNCTION__) {
     fatalError("\(method): \(message)")
 }