Re-apply "Update for SE-0055: Making pointer nullability explicit."
We're going to take the changes on all branches now. Re-applies #304,
temporarily reverted in #312.
diff --git a/CoreFoundation/Base.subproj/ForFoundationOnly.h b/CoreFoundation/Base.subproj/ForFoundationOnly.h
index 0d819de..a7ec33e 100644
--- a/CoreFoundation/Base.subproj/ForFoundationOnly.h
+++ b/CoreFoundation/Base.subproj/ForFoundationOnly.h
@@ -588,7 +588,7 @@
// This is for NSNumberFormatter use only!
CF_EXPORT void *_CFNumberFormatterGetFormatter(CFNumberFormatterRef formatter);
-CF_EXPORT void _CFDataInit(CFMutableDataRef memory, CFOptionFlags flags, CFIndex capacity, const uint8_t *bytes, CFIndex length, Boolean noCopy);
+CF_EXPORT void _CFDataInit(CFMutableDataRef memory, CFOptionFlags flags, CFIndex capacity, const uint8_t * _Nullable bytes, CFIndex length, Boolean noCopy);
CF_EXPORT CFRange _CFDataFindBytes(CFDataRef data, CFDataRef dataToFind, CFRange searchRange, CFDataSearchFlags compareOptions);
diff --git a/CoreFoundation/Base.subproj/ForSwiftFoundationOnly.h b/CoreFoundation/Base.subproj/ForSwiftFoundationOnly.h
index 6290f16..8820c68 100644
--- a/CoreFoundation/Base.subproj/ForSwiftFoundationOnly.h
+++ b/CoreFoundation/Base.subproj/ForSwiftFoundationOnly.h
@@ -54,7 +54,7 @@
struct _NSArrayBridge {
CFIndex (*_Nonnull count)(CFTypeRef obj);
_Nonnull CFTypeRef (*_Nonnull objectAtIndex)(CFTypeRef obj, CFIndex index);
- void (*_Nonnull getObjects)(CFTypeRef array, CFRange range, CFTypeRef _Nonnull * _Nonnull values);
+ void (*_Nonnull getObjects)(CFTypeRef array, CFRange range, CFTypeRef _Nullable *_Nonnull values);
};
struct _NSMutableArrayBridge {
@@ -73,11 +73,11 @@
CFIndex (*countForKey)(CFTypeRef dictionary, CFTypeRef key);
bool (*containsKey)(CFTypeRef dictionary, CFTypeRef key);
_Nullable CFTypeRef (*_Nonnull objectForKey)(CFTypeRef dictionary, CFTypeRef key);
- bool (*_getValueIfPresent)(CFTypeRef dictionary, CFTypeRef key, CFTypeRef _Nonnull * _Nullable value);
+ bool (*_getValueIfPresent)(CFTypeRef dictionary, CFTypeRef key, CFTypeRef _Nullable *_Nullable value);
CFIndex (*__getValue)(CFTypeRef dictionary, CFTypeRef value, CFTypeRef key);
bool (*containsObject)(CFTypeRef dictionary, CFTypeRef value);
CFIndex (*countForObject)(CFTypeRef dictionary, CFTypeRef value);
- void (*getObjects)(CFTypeRef dictionary, CFTypeRef _Nonnull * _Nonnull valuebuf, CFTypeRef _Nonnull * _Nonnull keybuf);
+ void (*getObjects)(CFTypeRef dictionary, CFTypeRef _Nullable *_Nullable valuebuf, CFTypeRef _Nullable *_Nullable keybuf);
void (*__apply)(CFTypeRef dictionary, void (*applier)(CFTypeRef key, CFTypeRef value, void *context), void *context);
};
@@ -104,7 +104,7 @@
CFIndex (*length)(CFTypeRef str);
UniChar (*characterAtIndex)(CFTypeRef str, CFIndex idx);
void (*getCharacters)(CFTypeRef str, CFRange range, UniChar *buffer);
- CFIndex (*__getBytes)(CFTypeRef str, CFStringEncoding encoding, CFRange range, uint8_t *buffer, CFIndex maxBufLen, CFIndex *usedBufLen);
+ CFIndex (*__getBytes)(CFTypeRef str, CFStringEncoding encoding, CFRange range, uint8_t *_Nullable buffer, CFIndex maxBufLen, CFIndex *_Nullable usedBufLen);
const char *_Nullable (*_Nonnull _fastCStringContents)(CFTypeRef str);
const UniChar *_Nullable (*_Nonnull _fastCharacterContents)(CFTypeRef str);
bool (*_getCString)(CFTypeRef str, char *buffer, size_t len, UInt32 encoding);
@@ -123,7 +123,7 @@
struct _NSXMLParserBridge {
_CFXMLInterface _Nullable (*_Nonnull currentParser)();
- _CFXMLInterfaceParserInput _Nonnull (*_Nonnull _xmlExternalEntityWithURL)(_CFXMLInterface interface, const char *url, const char * identifier, _CFXMLInterfaceParserContext context, _CFXMLInterfaceExternalEntityLoader originalLoaderFunction);
+ _CFXMLInterfaceParserInput _Nullable (*_Nonnull _xmlExternalEntityWithURL)(_CFXMLInterface interface, const char *url, const char * identifier, _CFXMLInterfaceParserContext context, _CFXMLInterfaceExternalEntityLoader originalLoaderFunction);
_CFXMLInterfaceParserContext _Nonnull (*_Nonnull getContext)(_CFXMLInterface ctx);
@@ -131,7 +131,7 @@
int (*isStandalone)(_CFXMLInterface ctx);
int (*hasInternalSubset)(_CFXMLInterface ctx);
int (*hasExternalSubset)(_CFXMLInterface ctx);
- _CFXMLInterfaceEntity _Nonnull (*_Nonnull getEntity)(_CFXMLInterface ctx, const unsigned char *name);
+ _CFXMLInterfaceEntity _Nullable (*_Nonnull getEntity)(_CFXMLInterface ctx, const unsigned char *name);
void (*notationDecl)(_CFXMLInterface ctx,
const unsigned char *name,
const unsigned char *publicId,
@@ -156,16 +156,16 @@
void (*endDocument)(_CFXMLInterface ctx);
void (*startElementNs)(_CFXMLInterface ctx,
const unsigned char *localname,
- const unsigned char *prefix,
+ const unsigned char *_Nullable prefix,
const unsigned char *URI,
int nb_namespaces,
- const unsigned char *_Nonnull *_Nonnull namespaces,
+ const unsigned char *_Nullable *_Nonnull namespaces,
int nb_attributes,
int nb_defaulted,
- const unsigned char *_Nonnull *_Nonnull attributes);
+ const unsigned char *_Nullable *_Nonnull attributes);
void (*endElementNs)(_CFXMLInterface ctx,
const unsigned char *localname,
- const unsigned char *prefix,
+ const unsigned char *_Nullable prefix,
const unsigned char *URI);
void (*characters)(_CFXMLInterface ctx,
const unsigned char *ch,
@@ -239,7 +239,7 @@
extern _Nullable CFDateRef CFCalendarCopyGregorianStartDate(CFCalendarRef calendar);
extern void CFCalendarSetGregorianStartDate(CFCalendarRef calendar, CFDateRef date);
-CF_PRIVATE CF_EXPORT char *_Nonnull*_Nonnull _CFEnviron(void);
+CF_PRIVATE CF_EXPORT char *_Nullable *_Nonnull _CFEnviron(void);
CF_EXPORT void CFLog1(CFLogLevel lev, CFStringRef message);
diff --git a/CoreFoundation/Parsing.subproj/CFXMLInterface.h b/CoreFoundation/Parsing.subproj/CFXMLInterface.h
index 13d64c6..2cc5610 100644
--- a/CoreFoundation/Parsing.subproj/CFXMLInterface.h
+++ b/CoreFoundation/Parsing.subproj/CFXMLInterface.h
@@ -136,7 +136,7 @@
typedef void* _CFXMLDTDPtr;
typedef void* _CFXMLDTDNodePtr;
-_CFXMLNodePtr _CFXMLNewNode(_CFXMLNamespacePtr namespace, const char* name);
+_CFXMLNodePtr _CFXMLNewNode(_CFXMLNamespacePtr _Nullable namespace, const char* name);
_CFXMLNodePtr _CFXMLCopyNode(_CFXMLNodePtr node, bool recursive);
_CFXMLDocPtr _CFXMLNewDoc(const unsigned char* version);
@@ -147,7 +147,7 @@
_CFXMLNamespacePtr _CFXMLNewNamespace(_CFXMLNodePtr _Nullable node, const unsigned char* uri, const unsigned char* prefix);
CF_RETURNS_RETAINED CFStringRef _Nullable _CFXMLNodeURI(_CFXMLNodePtr node);
-void _CFXMLNodeSetURI(_CFXMLNodePtr node, const unsigned char* URI);
+void _CFXMLNodeSetURI(_CFXMLNodePtr node, const unsigned char* _Nullable URI);
void _CFXMLNodeSetPrivateData(_CFXMLNodePtr node, void* data);
void* _Nullable _CFXMLNodeGetPrivateData(_CFXMLNodePtr node);
@@ -156,7 +156,7 @@
const char* _CFXMLNodeGetName(_CFXMLNodePtr node);
void _CFXMLNodeSetName(_CFXMLNodePtr node, const char* name);
CF_RETURNS_RETAINED CFStringRef _Nullable _CFXMLNodeGetContent(_CFXMLNodePtr node);
-void _CFXMLNodeSetContent(_CFXMLNodePtr node, const unsigned char* _Nullable content);
+void _CFXMLNodeSetContent(_CFXMLNodePtr node, const unsigned char* _Nullable content);
void _CFXMLUnlinkNode(_CFXMLNodePtr node);
_CFXMLNodePtr _Nullable _CFXMLNodeGetFirstChild(_CFXMLNodePtr node);
@@ -179,13 +179,13 @@
CF_RETURNS_RETAINED CFStringRef _Nullable _CFXMLDocCharacterEncoding(_CFXMLDocPtr doc);
void _CFXMLDocSetCharacterEncoding(_CFXMLDocPtr doc, const unsigned char* _Nullable encoding);
CF_RETURNS_RETAINED CFStringRef _Nullable _CFXMLDocVersion(_CFXMLDocPtr doc);
-void _CFXMLDocSetVersion(_CFXMLDocPtr doc, const unsigned char* version);
+void _CFXMLDocSetVersion(_CFXMLDocPtr doc, const unsigned char* _Nullable version);
int _CFXMLDocProperties(_CFXMLDocPtr doc);
void _CFXMLDocSetProperties(_CFXMLDocPtr doc, int newProperties);
_CFXMLDTDPtr _Nullable _CFXMLDocDTD(_CFXMLDocPtr doc);
void _CFXMLDocSetDTD(_CFXMLDocPtr doc, _CFXMLDTDPtr _Nullable dtd);
-CF_RETURNS_RETAINED CFStringRef _Nullable _CFXMLEncodeEntities(_CFXMLDocPtr doc, const unsigned char* string);
+CF_RETURNS_RETAINED CFStringRef _Nullable _CFXMLEncodeEntities(_CFXMLDocPtr _Nullable doc, const unsigned char* string);
_CFXMLEntityPtr _Nullable _CFXMLGetDocEntity(_CFXMLDocPtr doc, const char* entity);
_CFXMLEntityPtr _Nullable _CFXMLGetDTDEntity(_CFXMLDocPtr doc, const char* entity);
_CFXMLEntityPtr _Nullable _CFXMLGetParameterEntity(_CFXMLDocPtr doc, const char* entity);
@@ -205,14 +205,14 @@
bool _CFXMLDocValidate(_CFXMLDocPtr doc, CFErrorRef _Nullable * error);
-_CFXMLDTDPtr _CFXMLNewDTD(_CFXMLDocPtr doc, const unsigned char* name, const unsigned char* publicID, const unsigned char* systemID);
+_CFXMLDTDPtr _CFXMLNewDTD(_CFXMLDocPtr _Nullable doc, const unsigned char* name, const unsigned char* publicID, const unsigned char* systemID);
_CFXMLDTDNodePtr _Nullable _CFXMLParseDTDNode(const unsigned char* xmlString);
_CFXMLDTDPtr _Nullable _CFXMLParseDTD(const unsigned char* URL);
_CFXMLDTDPtr _Nullable _CFXMLParseDTDFromData(CFDataRef data, CFErrorRef _Nullable * error);
CF_RETURNS_RETAINED CFStringRef _Nullable _CFXMLDTDExternalID(_CFXMLDTDPtr dtd);
-void _CFXMLDTDSetExternalID(_CFXMLDTDPtr dtd, const unsigned char* externalID);
+void _CFXMLDTDSetExternalID(_CFXMLDTDPtr dtd, const unsigned char* _Nullable externalID);
CF_RETURNS_RETAINED CFStringRef _Nullable _CFXMLDTDSystemID(_CFXMLDTDPtr dtd);
-void _CFXMLDTDSetSystemID(_CFXMLDTDPtr dtd, const unsigned char* systemID);
+void _CFXMLDTDSetSystemID(_CFXMLDTDPtr dtd, const unsigned char* _Nullable systemID);
_CFXMLDTDNodePtr _Nullable _CFXMLDTDGetElementDesc(_CFXMLDTDPtr dtd, const unsigned char* name);
_CFXMLDTDNodePtr _Nullable _CFXMLDTDGetAttributeDesc(_CFXMLDTDPtr dtd, const unsigned char* elementName, const unsigned char* name);
@@ -220,7 +220,7 @@
_CFXMLDTDNodePtr _Nullable _CFXMLDTDGetEntityDesc(_CFXMLDTDPtr dtd, const unsigned char* name);
_CFXMLDTDNodePtr _Nullable _CFXMLDTDGetPredefinedEntity(const unsigned char* name);
-_CFXMLDTDNodePtr _Nullable _CFXMLDTDNewElementDesc(_CFXMLDTDPtr dtd, const unsigned char* name);
+_CFXMLDTDNodePtr _Nullable _CFXMLDTDNewElementDesc(_CFXMLDTDPtr _Nullable dtd, const unsigned char* _Nullable name);
_CFXMLDTDNodePtr _Nullable _CFXMLDTDNewAttributeDesc(_CFXMLDTDPtr dtd, const unsigned char* name);
CFIndex _CFXMLDTDElementNodeGetType(_CFXMLDTDNodePtr node);
@@ -228,9 +228,9 @@
CFIndex _CFXMLDTDAttributeNodeGetType(_CFXMLDTDNodePtr node);
CF_RETURNS_RETAINED CFStringRef _Nullable _CFXMLDTDNodeGetSystemID(_CFXMLDTDNodePtr node);
-void _CFXMLDTDNodeSetSystemID(_CFXMLDTDNodePtr node, const unsigned char* systemID);
+void _CFXMLDTDNodeSetSystemID(_CFXMLDTDNodePtr node, const unsigned char* _Nullable systemID);
CF_RETURNS_RETAINED CFStringRef _Nullable _CFXMLDTDNodeGetPublicID(_CFXMLDTDNodePtr node);
-void _CFXMLDTDNodeSetPublicID(_CFXMLDTDNodePtr node, const unsigned char* publicID);
+void _CFXMLDTDNodeSetPublicID(_CFXMLDTDNodePtr node, const unsigned char* _Nullable publicID);
void _CFXMLFreeNode(_CFXMLNodePtr node);
void _CFXMLFreeDocument(_CFXMLDocPtr doc);
diff --git a/Foundation/NSArray.swift b/Foundation/NSArray.swift
index d14763e..d85e73d 100644
--- a/Foundation/NSArray.swift
+++ b/Foundation/NSArray.swift
@@ -55,7 +55,7 @@
}
public convenience override init() {
- self.init(objects: nil, count:0)
+ self.init(objects: [], count:0)
}
public required init(objects: UnsafePointer<AnyObject?>, count cnt: Int) {
@@ -359,13 +359,13 @@
return NSData(bytesNoCopy: unsafeBitCast(buffer, to: UnsafeMutablePointer<Void>.self), length: count * sizeof(Int), freeWhenDone: true)
}
- public func sortedArrayUsingFunction(_ comparator: @convention(c) (AnyObject, AnyObject, UnsafeMutablePointer<Void>) -> Int, context: UnsafeMutablePointer<Void>) -> [AnyObject] {
+ public func sortedArrayUsingFunction(_ comparator: @convention(c) (AnyObject, AnyObject, UnsafeMutablePointer<Void>?) -> Int, context: UnsafeMutablePointer<Void>?) -> [AnyObject] {
return sortedArrayWithOptions([]) { lhs, rhs in
return NSComparisonResult(rawValue: comparator(lhs, rhs, context))!
}
}
- public func sortedArrayUsingFunction(_ comparator: @convention(c) (AnyObject, AnyObject, UnsafeMutablePointer<Void>) -> Int, context: UnsafeMutablePointer<Void>, hint: NSData?) -> [AnyObject] {
+ public func sortedArrayUsingFunction(_ comparator: @convention(c) (AnyObject, AnyObject, UnsafeMutablePointer<Void>?) -> Int, context: UnsafeMutablePointer<Void>?, hint: NSData?) -> [AnyObject] {
return sortedArrayWithOptions([]) { lhs, rhs in
return NSComparisonResult(rawValue: comparator(lhs, rhs, context))!
}
@@ -653,7 +653,7 @@
}
public init(capacity numItems: Int) {
- super.init(objects: nil, count: 0)
+ super.init(objects: [], count: 0)
if self.dynamicType === NSMutableArray.self {
_storage.reserveCapacity(numItems)
@@ -807,7 +807,7 @@
}
}
- public func sortUsingFunction(_ compare: @convention(c) (AnyObject, AnyObject, UnsafeMutablePointer<Void>) -> Int, context: UnsafeMutablePointer<Void>) {
+ public func sortUsingFunction(_ compare: @convention(c) (AnyObject, AnyObject, UnsafeMutablePointer<Void>?) -> Int, context: UnsafeMutablePointer<Void>?) {
self.setArray(self.sortedArrayUsingFunction(compare, context: context))
}
diff --git a/Foundation/NSCFArray.swift b/Foundation/NSCFArray.swift
index 1440980..f3e09fe 100644
--- a/Foundation/NSCFArray.swift
+++ b/Foundation/NSCFArray.swift
@@ -89,7 +89,7 @@
(array as! NSMutableArray).removeAllObjects()
}
-internal func _CFSwiftArrayReplaceValues(_ array: AnyObject, _ range: CFRange, _ newValues: UnsafeMutablePointer<Unmanaged<AnyObject>?>, _ newCount: CFIndex) {
+internal func _CFSwiftArrayReplaceValues(_ array: AnyObject, _ range: CFRange, _ newValues: UnsafeMutablePointer<Unmanaged<AnyObject>>, _ newCount: CFIndex) {
NSUnimplemented()
// (array as! NSMutableArray).replaceObjectsInRange(NSMakeRange(range.location, range.length), withObjectsFromArray: newValues.array(newCount))
}
diff --git a/Foundation/NSCFDictionary.swift b/Foundation/NSCFDictionary.swift
index 7c82de9..d68a73b 100644
--- a/Foundation/NSCFDictionary.swift
+++ b/Foundation/NSCFDictionary.swift
@@ -64,11 +64,11 @@
let cf = dict._cfObject
count = CFDictionaryGetCount(cf)
- let keys = UnsafeMutablePointer<UnsafePointer<Void>>(allocatingCapacity: count)
+ let keys = UnsafeMutablePointer<UnsafePointer<Void>?>(allocatingCapacity: count)
CFDictionaryGetKeysAndValues(cf, keys, nil)
for idx in 0..<count {
- let key = unsafeBitCast(keys.advanced(by: idx).pointee, to: NSObject.self)
+ let key = unsafeBitCast(keys.advanced(by: idx).pointee!, to: NSObject.self)
keyArray.append(key)
}
keys.deinitialize()
@@ -118,12 +118,12 @@
}
}
-internal func _CFSwiftDictionaryGetValueIfPresent(_ dictionary: AnyObject, key: AnyObject, value: UnsafeMutablePointer<Unmanaged<AnyObject>?>) -> Bool {
+internal func _CFSwiftDictionaryGetValueIfPresent(_ dictionary: AnyObject, key: AnyObject, value: UnsafeMutablePointer<Unmanaged<AnyObject>?>?) -> Bool {
if let val = _CFSwiftDictionaryGetValue(dictionary, key: key) {
- value.pointee = val
+ value?.pointee = val
return true
} else {
- value.pointee = nil
+ value?.pointee = nil
return false
}
}
@@ -140,18 +140,14 @@
NSUnimplemented()
}
-internal func _CFSwiftDictionaryGetValuesAndKeys(_ dictionary: AnyObject, valuebuf: UnsafeMutablePointer<Unmanaged<AnyObject>?>, keybuf: UnsafeMutablePointer<Unmanaged<AnyObject>?>) {
+internal func _CFSwiftDictionaryGetValuesAndKeys(_ dictionary: AnyObject, valuebuf: UnsafeMutablePointer<Unmanaged<AnyObject>?>?, keybuf: UnsafeMutablePointer<Unmanaged<AnyObject>?>?) {
var idx = 0
if valuebuf == nil && keybuf == nil {
return
}
(dictionary as! NSDictionary).enumerateKeysAndObjectsUsingBlock { key, value, _ in
- if valuebuf != nil {
- valuebuf[idx] = Unmanaged<AnyObject>.passUnretained(value)
- }
- if keybuf != nil {
- keybuf[idx] = Unmanaged<AnyObject>.passUnretained(key)
- }
+ valuebuf?[idx] = Unmanaged<AnyObject>.passUnretained(value)
+ keybuf?[idx] = Unmanaged<AnyObject>.passUnretained(key)
idx += 1
}
}
diff --git a/Foundation/NSCFString.swift b/Foundation/NSCFString.swift
index 2cb2747..4fb5640 100644
--- a/Foundation/NSCFString.swift
+++ b/Foundation/NSCFString.swift
@@ -125,26 +125,24 @@
(str as! NSString).getCharacters(buffer, range: NSMakeRange(range.location, range.length))
}
-internal func _CFSwiftStringGetBytes(_ str: AnyObject, encoding: CFStringEncoding, range: CFRange, buffer: UnsafeMutablePointer<UInt8>, maxBufLen: CFIndex, usedBufLen: UnsafeMutablePointer<CFIndex>) -> CFIndex {
+internal func _CFSwiftStringGetBytes(_ str: AnyObject, encoding: CFStringEncoding, range: CFRange, buffer: UnsafeMutablePointer<UInt8>?, maxBufLen: CFIndex, usedBufLen: UnsafeMutablePointer<CFIndex>?) -> CFIndex {
switch encoding {
// TODO: Don't treat many encodings like they are UTF8
case CFStringEncoding(kCFStringEncodingUTF8), CFStringEncoding(kCFStringEncodingISOLatin1), CFStringEncoding(kCFStringEncodingMacRoman), CFStringEncoding(kCFStringEncodingASCII), CFStringEncoding(kCFStringEncodingNonLossyASCII):
let encodingView = (str as! NSString)._swiftObject.utf8
let start = encodingView.startIndex
- if buffer != nil {
+ if let buffer = buffer {
for idx in 0..<range.length {
let character = encodingView[start.advanced(by: idx + range.location)]
buffer.advanced(by: idx).initialize(with: character)
}
}
- if usedBufLen != nil {
- usedBufLen.pointee = range.length
- }
+ usedBufLen?.pointee = range.length
case CFStringEncoding(kCFStringEncodingUTF16):
let encodingView = (str as! NSString)._swiftObject.utf16
let start = encodingView.startIndex
- if buffer != nil {
+ if let buffer = buffer {
for idx in 0..<range.length {
// Since character is 2 bytes but the buffer is in term of 1 byte values, we have to split it up
let character = encodingView[start.advanced(by: idx + range.location)]
@@ -154,10 +152,8 @@
buffer.advanced(by: (idx * 2) + 1).initialize(with: byte1)
}
}
- if usedBufLen != nil {
- // Every character was 2 bytes
- usedBufLen.pointee = range.length * 2
- }
+ // Every character was 2 bytes
+ usedBufLen?.pointee = range.length * 2
default:
@@ -180,11 +176,11 @@
return Unmanaged<AnyObject>.passRetained((str as! NSString).mutableCopyWithZone(nil))
}
-internal func _CFSwiftStringFastCStringContents(_ str: AnyObject) -> UnsafePointer<Int8> {
+internal func _CFSwiftStringFastCStringContents(_ str: AnyObject) -> UnsafePointer<Int8>? {
return (str as! NSString)._fastCStringContents
}
-internal func _CFSwiftStringFastContents(_ str: AnyObject) -> UnsafePointer<UniChar> {
+internal func _CFSwiftStringFastContents(_ str: AnyObject) -> UnsafePointer<UniChar>? {
return (str as! NSString)._fastContents
}
diff --git a/Foundation/NSCalendar.swift b/Foundation/NSCalendar.swift
index 642f14d..77da279 100644
--- a/Foundation/NSCalendar.swift
+++ b/Foundation/NSCalendar.swift
@@ -96,11 +96,11 @@
public class NSCalendar : NSObject, NSCopying, NSSecureCoding {
typealias CFType = CFCalendar
private var _base = _CFInfo(typeID: CFCalendarGetTypeID())
- private var _identifier: UnsafeMutablePointer<Void> = nil
- private var _locale: UnsafeMutablePointer<Void> = nil
- private var _localeID: UnsafeMutablePointer<Void> = nil
- private var _tz: UnsafeMutablePointer<Void> = nil
- private var _cal: UnsafeMutablePointer<Void> = nil
+ private var _identifier: UnsafeMutablePointer<Void>? = nil
+ private var _locale: UnsafeMutablePointer<Void>? = nil
+ private var _localeID: UnsafeMutablePointer<Void>? = nil
+ private var _tz: UnsafeMutablePointer<Void>? = nil
+ private var _cal: UnsafeMutablePointer<Void>? = nil
internal var _cfObject: CFType {
return unsafeBitCast(self, to: CFCalendar.self)
@@ -435,7 +435,7 @@
var at: CFAbsoluteTime = 0.0
let res: Bool = withUnsafeMutablePointer(&at) { t in
return vector.withUnsafeMutableBufferPointer { (vectorBuffer: inout UnsafeMutableBufferPointer<Int32>) in
- return _CFCalendarComposeAbsoluteTimeV(_cfObject, t, compDesc, vectorBuffer.baseAddress, Int32(vector.count))
+ return _CFCalendarComposeAbsoluteTimeV(_cfObject, t, compDesc, vectorBuffer.baseAddress!, Int32(vectorBuffer.count))
}
}
@@ -519,11 +519,11 @@
var ints = [Int32](repeating: 0, count: 20)
let res = ints.withUnsafeMutableBufferPointer { (intArrayBuffer: inout UnsafeMutableBufferPointer<Int32>) -> Bool in
var vector: [UnsafeMutablePointer<Int32>] = (0..<20).map { idx in
- intArrayBuffer.baseAddress.advanced(by: idx)
+ intArrayBuffer.baseAddress!.advanced(by: idx)
}
return vector.withUnsafeMutableBufferPointer { (vecBuffer: inout UnsafeMutableBufferPointer<UnsafeMutablePointer<Int32>>) in
- return _CFCalendarDecomposeAbsoluteTimeV(_cfObject, date.timeIntervalSinceReferenceDate, compDesc, vecBuffer.baseAddress, Int32(compDesc.count - 1))
+ return _CFCalendarDecomposeAbsoluteTimeV(_cfObject, date.timeIntervalSinceReferenceDate, compDesc, vecBuffer.baseAddress!, Int32(compDesc.count - 1))
}
}
if res {
@@ -539,7 +539,7 @@
let res: Bool = withUnsafeMutablePointer(&at) { t in
return vector.withUnsafeMutableBufferPointer { (vectorBuffer: inout UnsafeMutableBufferPointer<Int32>) in
- return _CFCalendarAddComponentsV(_cfObject, t, CFOptionFlags(opts.rawValue), compDesc, vectorBuffer.baseAddress, Int32(vector.count))
+ return _CFCalendarAddComponentsV(_cfObject, t, CFOptionFlags(opts.rawValue), compDesc, vectorBuffer.baseAddress!, Int32(vector.count))
}
}
@@ -555,11 +555,11 @@
var ints = [Int32](repeating: 0, count: 20)
let res = ints.withUnsafeMutableBufferPointer { (intArrayBuffer: inout UnsafeMutableBufferPointer<Int32>) -> Bool in
var vector: [UnsafeMutablePointer<Int32>] = (0..<20).map { idx in
- return intArrayBuffer.baseAddress.advanced(by: idx)
+ return intArrayBuffer.baseAddress!.advanced(by: idx)
}
return vector.withUnsafeMutableBufferPointer { (vecBuffer: inout UnsafeMutableBufferPointer<UnsafeMutablePointer<Int32>>) in
- _CFCalendarGetComponentDifferenceV(_cfObject, startingDate.timeIntervalSinceReferenceDate, resultDate.timeIntervalSinceReferenceDate, CFOptionFlags(opts.rawValue), compDesc, vecBuffer.baseAddress, Int32(vector.count))
+ _CFCalendarGetComponentDifferenceV(_cfObject, startingDate.timeIntervalSinceReferenceDate, resultDate.timeIntervalSinceReferenceDate, CFOptionFlags(opts.rawValue), compDesc, vecBuffer.baseAddress!, Int32(vector.count))
return false
}
}
@@ -573,20 +573,12 @@
This API is a convenience for getting era, year, month, and day of a given date.
Pass NULL for a NSInteger pointer parameter if you don't care about that value.
*/
- public func getEra(_ eraValuePointer: UnsafeMutablePointer<Int>, year yearValuePointer: UnsafeMutablePointer<Int>, month monthValuePointer: UnsafeMutablePointer<Int>, day dayValuePointer: UnsafeMutablePointer<Int>, fromDate date: NSDate) {
+ public func getEra(_ eraValuePointer: UnsafeMutablePointer<Int>?, year yearValuePointer: UnsafeMutablePointer<Int>?, month monthValuePointer: UnsafeMutablePointer<Int>?, day dayValuePointer: UnsafeMutablePointer<Int>?, fromDate date: NSDate) {
if let comps = components([.Era, .Year, .Month, .Day], fromDate: date) {
- if eraValuePointer != nil {
- eraValuePointer.pointee = comps.era
- }
- if yearValuePointer != nil {
- yearValuePointer.pointee = comps.year
- }
- if monthValuePointer != nil {
- monthValuePointer.pointee = comps.month
- }
- if dayValuePointer != nil {
- dayValuePointer.pointee = comps.day
- }
+ eraValuePointer?.pointee = comps.era
+ yearValuePointer?.pointee = comps.year
+ monthValuePointer?.pointee = comps.month
+ dayValuePointer?.pointee = comps.day
}
}
@@ -594,20 +586,12 @@
This API is a convenience for getting era, year for week-of-year calculations, week of year, and weekday of a given date.
Pass NULL for a NSInteger pointer parameter if you don't care about that value.
*/
- public func getEra(_ eraValuePointer: UnsafeMutablePointer<Int>, yearForWeekOfYear yearValuePointer: UnsafeMutablePointer<Int>, weekOfYear weekValuePointer: UnsafeMutablePointer<Int>, weekday weekdayValuePointer: UnsafeMutablePointer<Int>, fromDate date: NSDate) {
+ public func getEra(_ eraValuePointer: UnsafeMutablePointer<Int>?, yearForWeekOfYear yearValuePointer: UnsafeMutablePointer<Int>?, weekOfYear weekValuePointer: UnsafeMutablePointer<Int>?, weekday weekdayValuePointer: UnsafeMutablePointer<Int>?, fromDate date: NSDate) {
if let comps = components([.Era, .YearForWeekOfYear, .WeekOfYear, .Weekday], fromDate: date) {
- if eraValuePointer != nil {
- eraValuePointer.pointee = comps.era
- }
- if yearValuePointer != nil {
- yearValuePointer.pointee = comps.yearForWeekOfYear
- }
- if weekValuePointer != nil {
- weekValuePointer.pointee = comps.weekOfYear
- }
- if weekdayValuePointer != nil {
- weekdayValuePointer.pointee = comps.weekday
- }
+ eraValuePointer?.pointee = comps.era
+ yearValuePointer?.pointee = comps.yearForWeekOfYear
+ weekValuePointer?.pointee = comps.weekOfYear
+ weekdayValuePointer?.pointee = comps.weekday
}
}
@@ -615,20 +599,12 @@
This API is a convenience for getting hour, minute, second, and nanoseconds of a given date.
Pass NULL for a NSInteger pointer parameter if you don't care about that value.
*/
- public func getHour(_ hourValuePointer: UnsafeMutablePointer<Int>, minute minuteValuePointer: UnsafeMutablePointer<Int>, second secondValuePointer: UnsafeMutablePointer<Int>, nanosecond nanosecondValuePointer: UnsafeMutablePointer<Int>, fromDate date: NSDate) {
+ public func getHour(_ hourValuePointer: UnsafeMutablePointer<Int>?, minute minuteValuePointer: UnsafeMutablePointer<Int>?, second secondValuePointer: UnsafeMutablePointer<Int>?, nanosecond nanosecondValuePointer: UnsafeMutablePointer<Int>?, fromDate date: NSDate) {
if let comps = components([.Hour, .Minute, .Second, .Nanosecond], fromDate: date) {
- if hourValuePointer != nil {
- hourValuePointer.pointee = comps.hour
- }
- if minuteValuePointer != nil {
- minuteValuePointer.pointee = comps.minute
- }
- if secondValuePointer != nil {
- secondValuePointer.pointee = comps.second
- }
- if nanosecondValuePointer != nil {
- nanosecondValuePointer.pointee = comps.nanosecond
- }
+ hourValuePointer?.pointee = comps.hour
+ minuteValuePointer?.pointee = comps.minute
+ secondValuePointer?.pointee = comps.second
+ nanosecondValuePointer?.pointee = comps.nanosecond
}
}
diff --git a/Foundation/NSCharacterSet.swift b/Foundation/NSCharacterSet.swift
index 41c7e91..c0d49dc 100644
--- a/Foundation/NSCharacterSet.swift
+++ b/Foundation/NSCharacterSet.swift
@@ -33,9 +33,9 @@
typealias CFType = CFCharacterSet
private var _base = _CFInfo(typeID: CFCharacterSetGetTypeID())
private var _hashValue = CFHashCode(0)
- private var _buffer: UnsafeMutablePointer<Void> = nil
+ private var _buffer: UnsafeMutablePointer<Void>? = nil
private var _length = CFIndex(0)
- private var _annex: UnsafeMutablePointer<Void> = nil
+ private var _annex: UnsafeMutablePointer<Void>? = nil
internal var _cfObject: CFType {
return unsafeBitCast(self, to: CFType.self)
diff --git a/Foundation/NSCoder.swift b/Foundation/NSCoder.swift
index 933ca3d..2e753a4 100644
--- a/Foundation/NSCoder.swift
+++ b/Foundation/NSCoder.swift
@@ -130,12 +130,15 @@
encodeValueOfObjCType("[\(count)\(String(cString: type))]", at: array)
}
- public func encodeBytes(_ byteaddr: UnsafePointer<Void>, length: Int) {
+ public func encodeBytes(_ byteaddr: UnsafePointer<Void>?, length: Int) {
var newLength = UInt32(length)
withUnsafePointer(&newLength) { (ptr: UnsafePointer<UInt32>) -> Void in
encodeValueOfObjCType("I", at: ptr)
}
- encodeArrayOfObjCType("c", count: length, at: byteaddr)
+ var empty: [Int8] = []
+ withUnsafePointer(&empty) {
+ encodeArrayOfObjCType("c", count: length, at: byteaddr ?? UnsafePointer($0))
+ }
}
public func decodeObject() -> AnyObject? {
@@ -251,7 +254,7 @@
NSRequiresConcreteImplementation()
}
- public func decodeBytesForKey(_ key: String, returnedLength lengthp: UnsafeMutablePointer<Int>) -> UnsafePointer<UInt8> { // returned bytes immutable!
+ public func decodeBytesForKey(_ key: String, returnedLength lengthp: UnsafeMutablePointer<Int>?) -> UnsafePointer<UInt8>? { // returned bytes immutable!
NSRequiresConcreteImplementation()
}
diff --git a/Foundation/NSConcreteValue.swift b/Foundation/NSConcreteValue.swift
index ab8247f..9385a2d 100644
--- a/Foundation/NSConcreteValue.swift
+++ b/Foundation/NSConcreteValue.swift
@@ -92,9 +92,7 @@
self._typeInfo = typeInfo!
self._storage = UnsafeMutablePointer<UInt8>(allocatingCapacity: self._typeInfo.size)
- if value != nil {
- self._storage.initializeFrom(unsafeBitCast(value, to: UnsafeMutablePointer<UInt8>.self), count: self._typeInfo.size)
- }
+ self._storage.initializeFrom(unsafeBitCast(value, to: UnsafeMutablePointer<UInt8>.self), count: self._typeInfo.size)
}
deinit {
@@ -107,7 +105,7 @@
}
override var objCType : UnsafePointer<Int8> {
- return NSString(self._typeInfo.name).UTF8String // XXX leaky
+ return NSString(self._typeInfo.name).UTF8String! // XXX leaky
}
override var classForCoder: AnyClass {
@@ -127,8 +125,9 @@
}
let typep = type._swiftObject
-
- self.init(bytes: nil, objCType: typep)
+
+ // FIXME: This will result in reading garbage memory.
+ self.init(bytes: [], objCType: typep)
aDecoder.decodeValueOfObjCType(typep, at: self.value)
}
}
diff --git a/Foundation/NSData.swift b/Foundation/NSData.swift
index 5341938..30ce04b 100644
--- a/Foundation/NSData.swift
+++ b/Foundation/NSData.swift
@@ -75,20 +75,21 @@
private var _base = _CFInfo(typeID: CFDataGetTypeID())
private var _length: CFIndex = 0
private var _capacity: CFIndex = 0
- private var _deallocator: UnsafeMutablePointer<Void> = nil // for CF only
+ private var _deallocator: UnsafeMutablePointer<Void>? = nil // for CF only
private var _deallocHandler: _NSDataDeallocator? = _NSDataDeallocator() // for Swift
- private var _bytes: UnsafeMutablePointer<UInt8> = nil
+ private var _bytes: UnsafeMutablePointer<UInt8>? = nil
internal var _cfObject: CFType {
if self.dynamicType === NSData.self || self.dynamicType === NSMutableData.self {
return unsafeBitCast(self, to: CFType.self)
} else {
- return CFDataCreate(kCFAllocatorSystemDefault, unsafeBitCast(self.bytes, to: UnsafePointer<UInt8>.self), self.length)
+ return CFDataCreate(kCFAllocatorSystemDefault, UnsafePointer<UInt8>(self.bytes), self.length)
}
}
public override required convenience init() {
- self.init(bytes: nil, length: 0, copy: false, deallocator: nil)
+ let dummyPointer = unsafeBitCast(NSData.self, to: UnsafeMutablePointer<Void>.self)
+ self.init(bytes: dummyPointer, length: 0, copy: false, deallocator: nil)
}
public override var hash: Int {
@@ -104,21 +105,21 @@
}
deinit {
- if _bytes != nil {
- _deallocHandler?.handler(_bytes, _length)
+ if let allocatedBytes = _bytes {
+ _deallocHandler?.handler(allocatedBytes, _length)
}
if self.dynamicType === NSData.self || self.dynamicType === NSMutableData.self {
_CFDeinit(self._cfObject)
}
}
- internal init(bytes: UnsafeMutablePointer<Void>, length: Int, copy: Bool, deallocator: ((UnsafeMutablePointer<Void>, Int) -> Void)?) {
+ internal init(bytes: UnsafeMutablePointer<Void>?, length: Int, copy: Bool, deallocator: ((UnsafeMutablePointer<Void>, Int) -> Void)?) {
super.init()
let options : CFOptionFlags = (self.dynamicType == NSMutableData.self) ? __kCFMutable | __kCFGrowable : 0x0
if copy {
_CFDataInit(unsafeBitCast(self, to: CFMutableData.self), options, length, UnsafeMutablePointer<UInt8>(bytes), length, false)
if let handler = deallocator {
- handler(bytes, length)
+ handler(bytes!, length)
}
} else {
if let handler = deallocator {
@@ -224,7 +225,7 @@
extension NSData {
- public convenience init(bytes: UnsafePointer<Void>, length: Int) {
+ public convenience init(bytes: UnsafePointer<Void>?, length: Int) {
self.init(bytes: UnsafeMutablePointer<Void>(bytes), length: length, copy: true, deallocator: nil)
}
@@ -583,7 +584,7 @@
self.init(bytes: nil, length: 0)
}
- internal override init(bytes: UnsafeMutablePointer<Void>, length: Int, copy: Bool, deallocator: ((UnsafeMutablePointer<Void>, Int) -> Void)?) {
+ internal override init(bytes: UnsafeMutablePointer<Void>?, length: Int, copy: Bool, deallocator: ((UnsafeMutablePointer<Void>, Int) -> Void)?) {
super.init(bytes: bytes, length: length, copy: copy, deallocator: deallocator)
}
diff --git a/Foundation/NSDictionary.swift b/Foundation/NSDictionary.swift
index 55d27e8..f60cf55 100644
--- a/Foundation/NSDictionary.swift
+++ b/Foundation/NSDictionary.swift
@@ -57,14 +57,14 @@
let cf = x._cfObject
let cnt = CFDictionaryGetCount(cf)
- let keys = UnsafeMutablePointer<UnsafePointer<Void>>(allocatingCapacity: cnt)
- let values = UnsafeMutablePointer<UnsafePointer<Void>>(allocatingCapacity: cnt)
+ let keys = UnsafeMutablePointer<UnsafePointer<Void>?>(allocatingCapacity: cnt)
+ let values = UnsafeMutablePointer<UnsafePointer<Void>?>(allocatingCapacity: cnt)
CFDictionaryGetKeysAndValues(cf, keys, values)
for idx in 0..<cnt {
- let key = unsafeBitCast(keys.advanced(by: idx).pointee, to: AnyObject.self)
- let value = unsafeBitCast(values.advanced(by: idx).pointee, to: AnyObject.self)
+ let key = unsafeBitCast(keys.advanced(by: idx).pointee!, to: AnyObject.self)
+ let value = unsafeBitCast(values.advanced(by: idx).pointee!, to: AnyObject.self)
if let k = key as? Key {
if let v = value as? Value {
dict[k] = v
@@ -122,7 +122,7 @@
}
public override convenience init() {
- self.init(objects: nil, forKeys: nil, count: 0)
+ self.init(objects: [], forKeys: [], count: 0)
}
public required init(objects: UnsafePointer<AnyObject>, forKeys keys: UnsafePointer<NSObject>, count cnt: Int) {
@@ -603,8 +603,8 @@
self.init(capacity: 0)
}
- public init(capacity numItems: Int) {
- super.init(objects: nil, forKeys: nil, count: 0)
+ public convenience init(capacity numItems: Int) {
+ self.init(objects: [], forKeys: [], count: 0)
}
public required init(objects: UnsafePointer<AnyObject>, forKeys keys: UnsafePointer<NSObject>, count cnt: Int) {
diff --git a/Foundation/NSFileHandle.swift b/Foundation/NSFileHandle.swift
index a7c60e5..2f701dc 100644
--- a/Foundation/NSFileHandle.swift
+++ b/Foundation/NSFileHandle.swift
@@ -30,7 +30,7 @@
public func readDataOfLength(_ length: Int) -> NSData {
var statbuf = stat()
- var dynamicBuffer: UnsafeMutablePointer<UInt8> = nil
+ var dynamicBuffer: UnsafeMutablePointer<UInt8>? = nil
var total = 0
if _closed || fstat(_fd, &statbuf) < 0 {
fatalError("Unable to read file")
@@ -45,11 +45,11 @@
// Make sure there is always at least amountToRead bytes available in the buffer.
if (currentAllocationSize - total) < amountToRead {
currentAllocationSize *= 2
- dynamicBuffer = UnsafeMutablePointer<UInt8>(_CFReallocf(UnsafeMutablePointer<Void>(dynamicBuffer), currentAllocationSize))
+ dynamicBuffer = UnsafeMutablePointer<UInt8>(_CFReallocf(UnsafeMutablePointer<Void>(dynamicBuffer!), currentAllocationSize))
if dynamicBuffer == nil {
fatalError("unable to allocate backing buffer")
}
- let amtRead = read(_fd, dynamicBuffer.advanced(by: total), amountToRead)
+ let amtRead = read(_fd, dynamicBuffer!.advanced(by: total), amountToRead)
if 0 > amtRead {
free(dynamicBuffer)
fatalError("read failure")
@@ -81,7 +81,7 @@
}
while remaining > 0 {
- let count = read(_fd, dynamicBuffer.advanced(by: total), remaining)
+ let count = read(_fd, dynamicBuffer!.advanced(by: total), remaining)
if count < 0 {
free(dynamicBuffer)
fatalError("Unable to read from fd")
@@ -96,7 +96,7 @@
}
if length == Int.max && total > 0 {
- dynamicBuffer = UnsafeMutablePointer<UInt8>(_CFReallocf(UnsafeMutablePointer<Void>(dynamicBuffer), total))
+ dynamicBuffer = UnsafeMutablePointer<UInt8>(_CFReallocf(UnsafeMutablePointer<Void>(dynamicBuffer!), total))
}
if (0 == total) {
@@ -104,7 +104,7 @@
}
if total > 0 {
- return NSData(bytesNoCopy: UnsafeMutablePointer<Void>(dynamicBuffer), length: total)
+ return NSData(bytesNoCopy: UnsafeMutablePointer<Void>(dynamicBuffer!), length: total)
}
return NSData()
diff --git a/Foundation/NSFileManager.swift b/Foundation/NSFileManager.swift
index 977b6d5..f2c7792 100644
--- a/Foundation/NSFileManager.swift
+++ b/Foundation/NSFileManager.swift
@@ -248,21 +248,16 @@
defer {
closedir(dir)
}
-
- var entry: UnsafeMutablePointer<dirent> = readdir(dir)
-
- while entry != nil {
+
+ while let entry = readdir(dir) {
if let entryName = withUnsafePointer(&entry.pointee.d_name, { (ptr) -> String? in
- let int8Ptr = unsafeBitCast(ptr, to: UnsafePointer<Int8>.self)
- return String(cString: int8Ptr)
+ return String(cString: UnsafePointer<Int8>(ptr))
}) {
// TODO: `entryName` should be limited in length to `entry.memory.d_namlen`.
if entryName != "." && entryName != ".." {
contents.append(entryName)
}
}
-
- entry = readdir(dir)
}
return contents
@@ -470,7 +465,7 @@
} else if errno == ENOTEMPTY {
let fsRep = NSFileManager.defaultManager().fileSystemRepresentationWithPath(path)
- let ps = UnsafeMutablePointer<UnsafeMutablePointer<Int8>>(allocatingCapacity: 2)
+ let ps = UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>(allocatingCapacity: 2)
ps.initialize(with: UnsafeMutablePointer(fsRep))
ps.advanced(by: 1).initialize(with: nil)
let stream = fts_open(ps, FTS_PHYSICAL | FTS_XDEV | FTS_NOCHDIR, nil)
@@ -590,10 +585,10 @@
return self.fileExistsAtPath(path, isDirectory: nil)
}
- public func fileExistsAtPath(_ path: String, isDirectory: UnsafeMutablePointer<ObjCBool>) -> Bool {
+ public func fileExistsAtPath(_ path: String, isDirectory: UnsafeMutablePointer<ObjCBool>?) -> Bool {
var s = stat()
if lstat(path, &s) >= 0 {
- if isDirectory != nil {
+ if let isDirectory = isDirectory {
if (s.st_mode & S_IFMT) == S_IFLNK {
if stat(path, &s) >= 0 {
isDirectory.pointee = (s.st_mode & S_IFMT) == S_IFDIR
@@ -698,7 +693,7 @@
precondition(path != "", "Empty path argument")
let len = CFStringGetMaximumSizeOfFileSystemRepresentation(path._cfObject)
if len == kCFNotFound {
- return nil
+ fatalError("string could not be converted")
}
let buf = UnsafeMutablePointer<Int8>(allocatingCapacity: len)
for i in 0..<len {
@@ -707,7 +702,7 @@
if !path._nsObject.getFileSystemRepresentation(buf, maxLength: len) {
buf.deinitialize(count: len)
buf.deallocateCapacity(len)
- return nil
+ fatalError("string could not be converted")
}
return UnsafePointer(buf)
}
@@ -899,8 +894,8 @@
var _url : NSURL
var _options : NSDirectoryEnumerationOptions
var _errorHandler : ((NSURL, NSError) -> Bool)?
- var _stream : UnsafeMutablePointer<FTS> = nil
- var _current : UnsafeMutablePointer<FTSENT> = nil
+ var _stream : UnsafeMutablePointer<FTS>? = nil
+ var _current : UnsafeMutablePointer<FTSENT>? = nil
var _rootError : NSError? = nil
var _gotRoot : Bool = false
@@ -912,7 +907,7 @@
if let path = _url.path {
if NSFileManager.defaultManager().fileExistsAtPath(path) {
let fsRep = NSFileManager.defaultManager().fileSystemRepresentationWithPath(path)
- let ps = UnsafeMutablePointer<UnsafeMutablePointer<Int8>>(allocatingCapacity: 2)
+ let ps = UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>(allocatingCapacity: 2)
ps.initialize(with: UnsafeMutablePointer(fsRep))
ps.advanced(by: 1).initialize(with: nil)
_stream = fts_open(ps, FTS_PHYSICAL | FTS_XDEV | FTS_NOCHDIR, nil)
@@ -928,50 +923,50 @@
}
deinit {
- if _stream != nil {
- fts_close(_stream)
+ if let stream = _stream {
+ fts_close(stream)
}
}
override func nextObject() -> AnyObject? {
- if _stream != nil {
+ if let stream = _stream {
if !_gotRoot {
_gotRoot = true
// Skip the root.
- _current = fts_read(_stream)
+ _current = fts_read(stream)
}
- _current = fts_read(_stream)
- while _current != nil {
- switch Int32(_current.pointee.fts_info) {
+ _current = fts_read(stream)
+ while let current = _current {
+ switch Int32(current.pointee.fts_info) {
case FTS_D:
if _options.contains(.SkipsSubdirectoryDescendants) {
fts_set(_stream, _current, FTS_SKIP)
}
fallthrough
case FTS_DEFAULT, FTS_F, FTS_NSOK, FTS_SL, FTS_SLNONE:
- let str = NSString(bytes: _current.pointee.fts_path, length: Int(strlen(_current.pointee.fts_path)), encoding: NSUTF8StringEncoding)!._swiftObject
+ let str = NSString(bytes: current.pointee.fts_path, length: Int(strlen(current.pointee.fts_path)), encoding: NSUTF8StringEncoding)!._swiftObject
return NSURL(fileURLWithPath: str)
case FTS_DNR, FTS_ERR, FTS_NS:
let keepGoing : Bool
if let handler = _errorHandler {
- let str = NSString(bytes: _current.pointee.fts_path, length: Int(strlen(_current.pointee.fts_path)), encoding: NSUTF8StringEncoding)!._swiftObject
- keepGoing = handler(NSURL(fileURLWithPath: str), _NSErrorWithErrno(_current.pointee.fts_errno, reading: true))
+ let str = NSString(bytes: current.pointee.fts_path, length: Int(strlen(current.pointee.fts_path)), encoding: NSUTF8StringEncoding)!._swiftObject
+ keepGoing = handler(NSURL(fileURLWithPath: str), _NSErrorWithErrno(current.pointee.fts_errno, reading: true))
} else {
keepGoing = true
}
if !keepGoing {
- fts_close(_stream)
+ fts_close(stream)
_stream = nil
return nil
}
default:
break
}
- _current = fts_read(_stream)
+ _current = fts_read(stream)
}
// TODO: Error handling if fts_read fails.
@@ -993,16 +988,12 @@
}
override var level: Int {
- if _current != nil {
- return Int(_current.pointee.fts_level)
- } else {
- return 0
- }
+ return Int(_current?.pointee.fts_level ?? 0)
}
override func skipDescendants() {
- if _stream != nil && _current != nil {
- fts_set(_stream, _current, FTS_SKIP)
+ if let stream = _stream, current = _current {
+ fts_set(stream, current, FTS_SKIP)
}
}
}
diff --git a/Foundation/NSHost.swift b/Foundation/NSHost.swift
index ea59c93..84edbf5 100644
--- a/Foundation/NSHost.swift
+++ b/Foundation/NSHost.swift
@@ -77,24 +77,23 @@
hints.ai_socktype = _CF_SOCK_STREAM()
hints.ai_flags = flags
- var res0: UnsafeMutablePointer<addrinfo> = nil
- let r = withUnsafeMutablePointers(&hints, &res0) { hintsPtr, res0Ptr in
- return getaddrinfo(info, nil, hintsPtr, res0Ptr)
- }
+ var res0: UnsafeMutablePointer<addrinfo>? = nil
+ let r = getaddrinfo(info, nil, &hints, &res0)
if r != 0 {
return
}
- var res: UnsafeMutablePointer<addrinfo> = res0
+ var res: UnsafeMutablePointer<addrinfo>? = res0
while res != nil {
- let family = res.pointee.ai_family
+ let info = res!.pointee
+ let family = info.ai_family
if family != AF_INET && family != AF_INET6 {
- res = res.pointee.ai_next
+ res = info.ai_next
continue
}
let sa_len: socklen_t = socklen_t((family == AF_INET6) ? sizeof(sockaddr_in6) : sizeof(sockaddr_in))
let lookupInfo = { (content: inout [String], flags: Int32) in
let hname = UnsafeMutablePointer<Int8>(allocatingCapacity: 1024)
- if (getnameinfo(res.pointee.ai_addr, sa_len, hname, 1024, nil, 0, flags) == 0) {
+ if (getnameinfo(info.ai_addr, sa_len, hname, 1024, nil, 0, flags) == 0) {
content.append(String(hname))
}
hname.deinitialize()
@@ -103,7 +102,7 @@
lookupInfo(&_addresses, NI_NUMERICHOST)
lookupInfo(&_names, NI_NAMEREQD)
lookupInfo(&_names, NI_NOFQDN|NI_NAMEREQD)
- res = res.pointee.ai_next
+ res = info.ai_next
}
freeaddrinfo(res0)
diff --git a/Foundation/NSIndexSet.swift b/Foundation/NSIndexSet.swift
index 67c7baa..6602bdc 100644
--- a/Foundation/NSIndexSet.swift
+++ b/Foundation/NSIndexSet.swift
@@ -209,12 +209,12 @@
/* Fills up to bufferSize indexes in the specified range into the buffer and returns the number of indexes actually placed in the buffer; also modifies the optional range passed in by pointer to be "positioned" after the last index filled into the buffer.Example: if the index set contains the indexes 0, 2, 4, ..., 98, 100, for a buffer of size 10 and the range (20, 80) the buffer would contain 20, 22, ..., 38 and the range would be modified to (40, 60).
*/
- public func getIndexes(_ indexBuffer: UnsafeMutablePointer<Int>, maxCount bufferSize: Int, inIndexRange range: NSRangePointer) -> Int {
+ public func getIndexes(_ indexBuffer: UnsafeMutablePointer<Int>, maxCount bufferSize: Int, inIndexRange range: NSRangePointer?) -> Int {
let minIndex : Int
let maxIndex : Int
- if range != nil {
- minIndex = range.pointee.location
- maxIndex = NSMaxRange(range.pointee) - 1
+ if let initialRange = range {
+ minIndex = initialRange.pointee.location
+ maxIndex = NSMaxRange(initialRange.pointee) - 1
} else {
minIndex = firstIndex
maxIndex = lastIndex
@@ -250,10 +250,10 @@
}
}
- if counter > 0 && range != nil {
+ if counter > 0, let resultRange = range {
let delta = indexBuffer.advanced(by: counter - 1).pointee - minIndex + 1
- range.pointee.location += delta
- range.pointee.length -= delta
+ resultRange.pointee.location += delta
+ resultRange.pointee.length -= delta
}
return counter
} else {
diff --git a/Foundation/NSJSONSerialization.swift b/Foundation/NSJSONSerialization.swift
index 0dce0a6..7fade40 100644
--- a/Foundation/NSJSONSerialization.swift
+++ b/Foundation/NSJSONSerialization.swift
@@ -109,7 +109,7 @@
pretty: opt.contains(.PrettyPrinted),
writer: { (str: String?) in
if let str = str {
- result.appendBytes(str.bridge().cStringUsingEncoding(NSUTF8StringEncoding), length: str.lengthOfBytesUsingEncoding(NSUTF8StringEncoding))
+ result.appendBytes(str.bridge().cStringUsingEncoding(NSUTF8StringEncoding)!, length: str.lengthOfBytesUsingEncoding(NSUTF8StringEncoding))
}
}
)
@@ -455,7 +455,7 @@
func takeString(_ begin: Index, end: Index) throws -> String {
let byteLength = begin.distance(to: end)
- guard let chunk = NSString(bytes: buffer.baseAddress.advanced(by: begin), length: byteLength, encoding: encoding)?.bridge() else {
+ guard let chunk = NSString(bytes: buffer.baseAddress!.advanced(by: begin), length: byteLength, encoding: encoding)?.bridge() else {
throw NSError(domain: NSCocoaErrorDomain, code: NSCocoaError.PropertyListReadCorruptError.rawValue, userInfo: [
"NSDebugDescription" : "Unable to convert data to a string using the detected encoding. The data may be corrupt."
])
@@ -627,11 +627,12 @@
func parseNumber(_ input: Index) throws -> (Double, Index)? {
func parseDouble(_ address: UnsafePointer<UInt8>) -> (Double, Index.Distance)? {
let startPointer = UnsafePointer<Int8>(address)
- let endPointer = UnsafeMutablePointer<UnsafeMutablePointer<Int8>>(allocatingCapacity: 1)
+ let endPointer = UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>(allocatingCapacity: 1)
defer { endPointer.deallocateCapacity(1) }
let result = strtod(startPointer, endPointer)
- let distance = startPointer.distance(to: endPointer[0])
+ let distance = startPointer.distance(to: endPointer[0]!)
+
guard distance > 0 else {
return nil
}
@@ -640,7 +641,7 @@
}
if source.encoding == NSUTF8StringEncoding {
- return parseDouble(source.buffer.baseAddress.advanced(by: input)).map { return ($0.0, input + $0.1) }
+ return parseDouble(source.buffer.baseAddress!.advanced(by: input)).map { return ($0.0, input + $0.1) }
}
else {
var numberCharacters = [UInt8]()
@@ -652,7 +653,7 @@
numberCharacters.append(0)
- return numberCharacters.withUnsafeBufferPointer { parseDouble($0.baseAddress) }.map { return ($0.0, index) }
+ return numberCharacters.withUnsafeBufferPointer { parseDouble($0.baseAddress!) }.map { return ($0.0, index) }
}
}
diff --git a/Foundation/NSKeyedCoderOldStyleArray.swift b/Foundation/NSKeyedCoderOldStyleArray.swift
index e65e660..c800f91 100644
--- a/Foundation/NSKeyedCoderOldStyleArray.swift
+++ b/Foundation/NSKeyedCoderOldStyleArray.swift
@@ -11,7 +11,7 @@
internal final class _NSKeyedCoderOldStyleArray : NSObject, NSCopying, NSSecureCoding, NSCoding {
- private var _addr : UnsafeMutablePointer<UInt8> = nil // free if decoding
+ private var _addr : UnsafeMutablePointer<UInt8> // free if decoding
private var _count : Int
private var _size : Int
private var _type : _NSSimpleObjCType
diff --git a/Foundation/NSKeyedUnarchiver.swift b/Foundation/NSKeyedUnarchiver.swift
index 69f44e7..eefeff4 100644
--- a/Foundation/NSKeyedUnarchiver.swift
+++ b/Foundation/NSKeyedUnarchiver.swift
@@ -752,11 +752,11 @@
}
// returned bytes immutable, and they go away with the unarchiver, not the containing autorelease pool
- public override func decodeBytesForKey(_ key: String, returnedLength lengthp: UnsafeMutablePointer<Int>) -> UnsafePointer<UInt8> {
+ public override func decodeBytesForKey(_ key: String, returnedLength lengthp: UnsafeMutablePointer<Int>?) -> UnsafePointer<UInt8>? {
let ns : NSData? = _decodeValue(forKey: key)
if let value = ns {
- lengthp.pointee = Int(value.length)
+ lengthp?.pointee = Int(value.length)
return UnsafePointer<UInt8>(value.bytes)
}
@@ -828,7 +828,7 @@
break
case .CharPtr:
if let ns = decodeObject() as? NSString {
- let string = ns.UTF8String // XXX leaky
+ let string = ns.UTF8String! // XXX leaky
unsafeBitCast(addr, to: UnsafeMutablePointer<UnsafePointer<Int8>>.self).pointee = string
}
break
diff --git a/Foundation/NSLocale.swift b/Foundation/NSLocale.swift
index d17c098..b8c7d9b 100644
--- a/Foundation/NSLocale.swift
+++ b/Foundation/NSLocale.swift
@@ -13,9 +13,9 @@
public class NSLocale : NSObject, NSCopying, NSSecureCoding {
typealias CFType = CFLocale
private var _base = _CFInfo(typeID: CFLocaleGetTypeID())
- private var _identifier: UnsafeMutablePointer<Void> = nil
- private var _cache: UnsafeMutablePointer<Void> = nil
- private var _prefs: UnsafeMutablePointer<Void> = nil
+ private var _identifier: UnsafeMutablePointer<Void>? = nil
+ private var _cache: UnsafeMutablePointer<Void>? = nil
+ private var _prefs: UnsafeMutablePointer<Void>? = nil
#if os(OSX) || os(iOS)
private var _lock = pthread_mutex_t()
#elseif os(Linux)
diff --git a/Foundation/NSNumber.swift b/Foundation/NSNumber.swift
index d666046..2b2b63e 100644
--- a/Foundation/NSNumber.swift
+++ b/Foundation/NSNumber.swift
@@ -281,18 +281,18 @@
public required convenience init?(coder aDecoder: NSCoder) {
if !aDecoder.allowsKeyedCoding {
- var objCType: UnsafeMutablePointer<Int8> = nil
- var size: Int = 0
- NSGetSizeAndAlignment(objCType, &size, nil)
- let buffer = malloc(size)
- aDecoder.decodeValueOfObjCType(objCType, at: buffer)
- withUnsafeMutablePointer(&objCType, { (ptr: UnsafeMutablePointer<UnsafeMutablePointer<Int8>>) -> Void in
+ var objCType: UnsafeMutablePointer<Int8>? = nil
+ withUnsafeMutablePointer(&objCType, { (ptr: UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>) -> Void in
aDecoder.decodeValueOfObjCType(String(_NSSimpleObjCType.CharPtr), at: UnsafeMutablePointer<Void>(ptr))
})
if objCType == nil {
return nil
}
- self.init(bytes: buffer, objCType: objCType)
+ var size: Int = 0
+ NSGetSizeAndAlignment(objCType!, &size, nil)
+ let buffer = malloc(size)
+ aDecoder.decodeValueOfObjCType(objCType!, at: buffer)
+ self.init(bytes: buffer, objCType: objCType!)
free(buffer)
} else if aDecoder.dynamicType == NSKeyedUnarchiver.self || aDecoder.containsValueForKey("NS.number") {
let number = aDecoder._decodePropertyListForKey("NS.number")
diff --git a/Foundation/NSObjCRuntime.swift b/Foundation/NSObjCRuntime.swift
index f85464d..8bf47bc 100644
--- a/Foundation/NSObjCRuntime.swift
+++ b/Foundation/NSObjCRuntime.swift
@@ -116,24 +116,21 @@
}
public func NSGetSizeAndAlignment(_ typePtr: UnsafePointer<Int8>,
- _ sizep: UnsafeMutablePointer<Int>,
- _ alignp: UnsafeMutablePointer<Int>) -> UnsafePointer<Int8> {
+ _ sizep: UnsafeMutablePointer<Int>?,
+ _ alignp: UnsafeMutablePointer<Int>?) -> UnsafePointer<Int8> {
let type = _NSSimpleObjCType(UInt8(typePtr.pointee))!
var size : Int = 0
var align : Int = 0
if !_NSGetSizeAndAlignment(type, &size, &align) {
- return nil
+ // FIXME: This used to return nil, but the corresponding Darwin
+ // implementation is defined as returning a non-optional value.
+ fatalError("invalid type encoding")
}
- if sizep != nil {
- sizep.pointee = size
- }
-
- if alignp != nil {
- alignp.pointee = align
- }
+ sizep?.pointee = size
+ alignp?.pointee = align
return typePtr.advanced(by: 1)
}
diff --git a/Foundation/NSOrderedSet.swift b/Foundation/NSOrderedSet.swift
index 54e86b9..d87bcff 100644
--- a/Foundation/NSOrderedSet.swift
+++ b/Foundation/NSOrderedSet.swift
@@ -84,7 +84,7 @@
}
public convenience override init() {
- self.init(objects: nil, count: 0)
+ self.init(objects: [], count: 0)
}
public init(objects: UnsafePointer<AnyObject?>, count cnt: Int) {
@@ -361,7 +361,7 @@
}
public init(capacity numItems: Int) {
- super.init(objects: nil, count: 0)
+ super.init(objects: [], count: 0)
}
required public convenience init(arrayLiteral elements: AnyObject...) {
diff --git a/Foundation/NSPropertyList.swift b/Foundation/NSPropertyList.swift
index 13c223d..9f61e23 100644
--- a/Foundation/NSPropertyList.swift
+++ b/Foundation/NSPropertyList.swift
@@ -64,20 +64,17 @@
}
/// - Experiment: Note that the return type of this function is different than on Darwin Foundation (Any instead of AnyObject). This is likely to change once we have a more complete story for bridging in place.
- public class func propertyListWithData(_ data: NSData, options opt: NSPropertyListReadOptions, format: UnsafeMutablePointer<NSPropertyListFormat>) throws -> Any {
+ public class func propertyListWithData(_ data: NSData, options opt: NSPropertyListReadOptions, format: UnsafeMutablePointer<NSPropertyListFormat>?) throws -> Any {
var fmt = kCFPropertyListBinaryFormat_v1_0
var error: Unmanaged<CFError>? = nil
let decoded = withUnsafeMutablePointers(&fmt, &error) { (outFmt: UnsafeMutablePointer<CFPropertyListFormat>, outErr: UnsafeMutablePointer<Unmanaged<CFError>?>) -> NSObject? in
return unsafeBitCast(CFPropertyListCreateWithData(kCFAllocatorSystemDefault, unsafeBitCast(data, to: CFData.self), CFOptionFlags(CFIndex(opt.rawValue)), outFmt, outErr), to: NSObject.self)
}
- if format != nil {
#if os(OSX) || os(iOS)
- format.pointee = NSPropertyListFormat(rawValue: UInt(fmt.rawValue))!
+ format?.pointee = NSPropertyListFormat(rawValue: UInt(fmt.rawValue))!
#else
- format.pointee = NSPropertyListFormat(rawValue: UInt(fmt))!
+ format?.pointee = NSPropertyListFormat(rawValue: UInt(fmt))!
#endif
- }
-
if let err = error {
throw err.takeUnretainedValue()._nsObject
} else {
@@ -85,19 +82,17 @@
}
}
- internal class func propertyListWithStream(_ stream: CFReadStream, length streamLength: Int, options opt: NSPropertyListReadOptions, format: UnsafeMutablePointer <NSPropertyListFormat>) throws -> Any {
+ internal class func propertyListWithStream(_ stream: CFReadStream, length streamLength: Int, options opt: NSPropertyListReadOptions, format: UnsafeMutablePointer <NSPropertyListFormat>?) throws -> Any {
var fmt = kCFPropertyListBinaryFormat_v1_0
var error: Unmanaged<CFError>? = nil
let decoded = withUnsafeMutablePointers(&fmt, &error) { (outFmt: UnsafeMutablePointer<CFPropertyListFormat>, outErr: UnsafeMutablePointer<Unmanaged<CFError>?>) -> NSObject? in
return unsafeBitCast(CFPropertyListCreateWithStream(kCFAllocatorSystemDefault, stream, streamLength, CFOptionFlags(CFIndex(opt.rawValue)), outFmt, outErr), to: NSObject.self)
}
- if format != nil {
#if os(OSX) || os(iOS)
- format.pointee = NSPropertyListFormat(rawValue: UInt(fmt.rawValue))!
+ format?.pointee = NSPropertyListFormat(rawValue: UInt(fmt.rawValue))!
#else
- format.pointee = NSPropertyListFormat(rawValue: UInt(fmt))!
+ format?.pointee = NSPropertyListFormat(rawValue: UInt(fmt))!
#endif
- }
if let err = error {
throw err.takeUnretainedValue()._nsObject
} else {
diff --git a/Foundation/NSRegularExpression.swift b/Foundation/NSRegularExpression.swift
index ac9ac7a..019411e 100644
--- a/Foundation/NSRegularExpression.swift
+++ b/Foundation/NSRegularExpression.swift
@@ -118,7 +118,7 @@
}
}
-internal func _NSRegularExpressionMatch(_ context: UnsafeMutablePointer<Void>, ranges: UnsafeMutablePointer<CFRange>, count: CFIndex, options: _CFRegularExpressionMatchingOptions, stop: UnsafeMutablePointer<_DarwinCompatibleBoolean>) -> Void {
+internal func _NSRegularExpressionMatch(_ context: UnsafeMutablePointer<Void>?, ranges: UnsafeMutablePointer<CFRange>?, count: CFIndex, options: _CFRegularExpressionMatchingOptions, stop: UnsafeMutablePointer<_DarwinCompatibleBoolean>) -> Void {
let matcher = unsafeBitCast(context, to: _NSRegularExpressionMatcher.self)
if ranges == nil {
#if os(OSX) || os(iOS)
@@ -128,7 +128,7 @@
#endif
matcher.block(nil, NSMatchingFlags(rawValue: opts), UnsafeMutablePointer<ObjCBool>(stop))
} else {
- let result = NSTextCheckingResult.regularExpressionCheckingResultWithRanges(NSRangePointer(ranges), count: count, regularExpression: matcher.regex)
+ let result = NSTextCheckingResult.regularExpressionCheckingResultWithRanges(NSRangePointer(ranges!), count: count, regularExpression: matcher.regex)
#if os(OSX) || os(iOS)
let flags = NSMatchingFlags(rawValue: options.rawValue)
#else
diff --git a/Foundation/NSScanner.swift b/Foundation/NSScanner.swift
index 604285f..d863c93 100644
--- a/Foundation/NSScanner.swift
+++ b/Foundation/NSScanner.swift
@@ -95,7 +95,7 @@
let range = NSMakeRange(_stringLoc, bufferLen)
bufferLoc = 1
buffer.withUnsafeMutableBufferPointer({ (ptr: inout UnsafeMutableBufferPointer<unichar>) -> Void in
- self.string.getCharacters(ptr.baseAddress, range: range)
+ self.string.getCharacters(ptr.baseAddress!, range: range)
})
curChar = buffer[0]
} else {
@@ -115,7 +115,7 @@
let range = NSMakeRange(_stringLoc, bufferLen)
bufferLoc = 1
buffer.withUnsafeMutableBufferPointer({ (ptr: inout UnsafeMutableBufferPointer<unichar>) -> Void in
- self.string.getCharacters(ptr.baseAddress, range: range)
+ self.string.getCharacters(ptr.baseAddress!, range: range)
})
curChar = buffer[0]
} else {
@@ -137,7 +137,7 @@
bufferLen = min(32, stringLen - _stringLoc);
let range = NSMakeRange(_stringLoc, bufferLen)
buffer.withUnsafeMutableBufferPointer({ (ptr: inout UnsafeMutableBufferPointer<unichar>) -> Void in
- string.getCharacters(ptr.baseAddress, range: range)
+ string.getCharacters(ptr.baseAddress!, range: range)
})
bufferLoc = 1
curChar = buffer[0]
@@ -166,7 +166,7 @@
_stringLoc -= bufferLen
let range = NSMakeRange(_stringLoc, bufferLen)
buffer.withUnsafeMutableBufferPointer({ (ptr: inout UnsafeMutableBufferPointer<unichar>) -> Void in
- string.getCharacters(ptr.baseAddress, range: range)
+ string.getCharacters(ptr.baseAddress!, range: range)
})
} else {
bufferLoc = 0
diff --git a/Foundation/NSSet.swift b/Foundation/NSSet.swift
index ed8cbcd..e20feb2 100644
--- a/Foundation/NSSet.swift
+++ b/Foundation/NSSet.swift
@@ -43,7 +43,7 @@
let cf = x._cfObject
let cnt = CFSetGetCount(cf)
- let objs = UnsafeMutablePointer<UnsafePointer<Void>>(allocatingCapacity: cnt)
+ let objs = UnsafeMutablePointer<UnsafePointer<Void>?>(allocatingCapacity: cnt)
CFSetGetValues(cf, objs)
@@ -102,8 +102,7 @@
}
public convenience override init() {
- let objects: UnsafePointer<AnyObject?> = nil
- self.init(objects: objects, count: 0)
+ self.init(objects: [], count: 0)
}
public init(objects: UnsafePointer<AnyObject?>, count cnt: Int) {
@@ -382,7 +381,7 @@
}
public required init(capacity numItems: Int) {
- super.init(objects: nil, count: 0)
+ super.init(objects: [], count: 0)
}
public required convenience init?(coder: NSCoder) {
diff --git a/Foundation/NSSpecialValue.swift b/Foundation/NSSpecialValue.swift
index e360089..b8833c9 100644
--- a/Foundation/NSSpecialValue.swift
+++ b/Foundation/NSSpecialValue.swift
@@ -121,7 +121,7 @@
override var objCType : UnsafePointer<Int8> {
let typeName = NSSpecialValue._objCTypeFromType(_value.dynamicType)
- return typeName!.bridge().UTF8String // leaky
+ return typeName!.bridge().UTF8String! // leaky
}
override var classForCoder: AnyClass {
diff --git a/Foundation/NSString.swift b/Foundation/NSString.swift
index dbfac9b..9324b19 100644
--- a/Foundation/NSString.swift
+++ b/Foundation/NSString.swift
@@ -104,7 +104,7 @@
let len = x.length
var characters = [unichar](repeating: 0, count: len)
result = characters.withUnsafeMutableBufferPointer() { (buffer: inout UnsafeMutableBufferPointer<unichar>) -> String? in
- x.getCharacters(buffer.baseAddress, range: NSMakeRange(0, len))
+ x.getCharacters(buffer.baseAddress!, range: NSMakeRange(0, len))
return String._fromCodeUnitSequence(UTF16.self, input: buffer)
}
}
@@ -163,7 +163,7 @@
return nil
}
-internal func _bytesInEncoding(_ str: NSString, _ encoding: NSStringEncoding, _ fatalOnError: Bool, _ externalRep: Bool, _ lossy: Bool) -> UnsafePointer<Int8> {
+internal func _bytesInEncoding(_ str: NSString, _ encoding: NSStringEncoding, _ fatalOnError: Bool, _ externalRep: Bool, _ lossy: Bool) -> UnsafePointer<Int8>? {
let theRange = NSMakeRange(0, str.length)
var cLength = 0
var used = 0
@@ -253,7 +253,7 @@
self.init(string: str)
} else {
var length = 0
- let buffer = UnsafeMutablePointer<Void>(aDecoder.decodeBytesForKey("NS.bytes", returnedLength: &length))
+ let buffer = UnsafeMutablePointer<Void>(aDecoder.decodeBytesForKey("NS.bytes", returnedLength: &length)!)
self.init(bytes: buffer, length: length, encoding: NSUTF8StringEncoding)
}
}
@@ -276,8 +276,7 @@
public func mutableCopyWithZone(_ zone: NSZone) -> AnyObject {
if self.dynamicType === NSString.self || self.dynamicType === NSMutableString.self {
- let contents = _fastContents
- if contents != nil {
+ if let contents = _fastContents {
return NSMutableString(characters: contents, length: length)
}
}
@@ -317,7 +316,7 @@
_storage = String(value)
}
- internal var _fastCStringContents: UnsafePointer<Int8> {
+ internal var _fastCStringContents: UnsafePointer<Int8>? {
if self.dynamicType == NSString.self || self.dynamicType == NSMutableString.self {
if _storage._core.isASCII {
return unsafeBitCast(_storage._core.startASCII, to: UnsafePointer<Int8>.self)
@@ -326,7 +325,7 @@
return nil
}
- internal var _fastContents: UnsafePointer<UniChar> {
+ internal var _fastContents: UnsafePointer<UniChar>? {
if self.dynamicType == NSString.self || self.dynamicType == NSMutableString.self {
if !_storage._core.isASCII {
return unsafeBitCast(_storage._core.startUTF16, to: UnsafePointer<UniChar>.self)
@@ -709,19 +708,15 @@
return mutableCopy._swiftObject
}
- internal func _getBlockStart(_ startPtr: UnsafeMutablePointer<Int>, end endPtr: UnsafeMutablePointer<Int>, contentsEnd contentsEndPtr: UnsafeMutablePointer<Int>, forRange range: NSRange, stopAtLineSeparators line: Bool) {
+ internal func _getBlockStart(_ startPtr: UnsafeMutablePointer<Int>?, end endPtr: UnsafeMutablePointer<Int>?, contentsEnd contentsEndPtr: UnsafeMutablePointer<Int>?, forRange range: NSRange, stopAtLineSeparators line: Bool) {
let len = length
var ch: unichar
precondition(range.length <= len && range.location < len - range.length, "Range {\(range.location), \(range.length)} is out of bounds of length \(len)")
if range.location == 0 && range.length == len && contentsEndPtr == nil { // This occurs often
- if startPtr != nil {
- startPtr.pointee = 0
- }
- if endPtr != nil {
- endPtr.pointee = range.length
- }
+ startPtr?.pointee = 0
+ endPtr?.pointee = range.length
return
}
/* Find the starting point first */
@@ -749,7 +744,7 @@
buf.rewind()
}
}
- startPtr.pointee = start
+ startPtr!.pointee = start
}
}
@@ -786,16 +781,12 @@
}
}
- if contentsEndPtr != nil {
- contentsEndPtr.pointee = endOfContents
- }
- if endPtr != nil {
- endPtr.pointee = endOfContents + lineSeparatorLength
- }
+ contentsEndPtr?.pointee = endOfContents
+ endPtr?.pointee = endOfContents + lineSeparatorLength
}
}
- public func getLineStart(_ startPtr: UnsafeMutablePointer<Int>, end lineEndPtr: UnsafeMutablePointer<Int>, contentsEnd contentsEndPtr: UnsafeMutablePointer<Int>, forRange range: NSRange) {
+ public func getLineStart(_ startPtr: UnsafeMutablePointer<Int>?, end lineEndPtr: UnsafeMutablePointer<Int>?, contentsEnd contentsEndPtr: UnsafeMutablePointer<Int>?, forRange range: NSRange) {
_getBlockStart(startPtr, end: lineEndPtr, contentsEnd: contentsEndPtr, forRange: range, stopAtLineSeparators: true)
}
@@ -806,7 +797,7 @@
return NSMakeRange(start, lineEnd - start)
}
- public func getParagraphStart(_ startPtr: UnsafeMutablePointer<Int>, end parEndPtr: UnsafeMutablePointer<Int>, contentsEnd contentsEndPtr: UnsafeMutablePointer<Int>, forRange range: NSRange) {
+ public func getParagraphStart(_ startPtr: UnsafeMutablePointer<Int>?, end parEndPtr: UnsafeMutablePointer<Int>?, contentsEnd contentsEndPtr: UnsafeMutablePointer<Int>?, forRange range: NSRange) {
_getBlockStart(startPtr, end: parEndPtr, contentsEnd: contentsEndPtr, forRange: range, stopAtLineSeparators: false)
}
@@ -827,7 +818,7 @@
}
}
- public var UTF8String: UnsafePointer<Int8> {
+ public var UTF8String: UnsafePointer<Int8>? {
return _bytesInEncoding(self, NSUTF8StringEncoding, false, false, false)
}
@@ -880,7 +871,7 @@
return __CFStringEncodeByteStream(_cfObject, 0, length, false, CFStringConvertNSStringEncodingToEncoding(encoding), 0, nil, 0, nil) == length
}
- public func cStringUsingEncoding(_ encoding: UInt) -> UnsafePointer<Int8> {
+ public func cStringUsingEncoding(_ encoding: UInt) -> UnsafePointer<Int8>? {
return _bytesInEncoding(self, encoding, false, false, false)
}
@@ -902,7 +893,7 @@
return false
}
- public func getBytes(_ buffer: UnsafeMutablePointer<Void>, maxLength maxBufferCount: Int, usedLength usedBufferCount: UnsafeMutablePointer<Int>, encoding: UInt, options: NSStringEncodingConversionOptions, range: NSRange, remainingRange leftover: NSRangePointer) -> Bool {
+ public func getBytes(_ buffer: UnsafeMutablePointer<Void>?, maxLength maxBufferCount: Int, usedLength usedBufferCount: UnsafeMutablePointer<Int>?, encoding: UInt, options: NSStringEncodingConversionOptions, range: NSRange, remainingRange leftover: NSRangePointer?) -> Bool {
var totalBytesWritten = 0
var numCharsProcessed = 0
let cfStringEncoding = CFStringConvertNSStringEncodingToEncoding(encoding)
@@ -920,12 +911,8 @@
result = false /* ??? Need other encodings */
}
}
- if usedBufferCount != nil {
- usedBufferCount.pointee = totalBytesWritten
- }
- if leftover != nil {
- leftover.pointee = NSMakeRange(range.location + numCharsProcessed, range.length - numCharsProcessed)
- }
+ usedBufferCount?.pointee = totalBytesWritten
+ leftover?.pointee = NSMakeRange(range.location + numCharsProcessed, range.length - numCharsProcessed)
return result
}
@@ -1291,11 +1278,11 @@
try self.init(contentsOfURL: NSURL(fileURLWithPath: path), encoding: enc)
}
- public convenience init(contentsOfURL url: NSURL, usedEncoding enc: UnsafeMutablePointer<UInt>) throws {
+ public convenience init(contentsOfURL url: NSURL, usedEncoding enc: UnsafeMutablePointer<UInt>?) throws {
NSUnimplemented()
}
- public convenience init(contentsOfFile path: String, usedEncoding enc: UnsafeMutablePointer<UInt>) throws {
+ public convenience init(contentsOfFile path: String, usedEncoding enc: UnsafeMutablePointer<UInt>?) throws {
NSUnimplemented()
}
}
@@ -1320,7 +1307,7 @@
}
public required init(capacity: Int) {
- super.init(characters: nil, length: 0)
+ super.init(characters: [], length: 0)
}
public convenience required init?(coder aDecoder: NSCoder) {
@@ -1407,7 +1394,7 @@
if let findResults = CFStringCreateArrayWithFindResults(kCFAllocatorSystemDefault, _cfObject, target._cfObject, CFRange(searchRange), options._cfValue(true)) {
let numOccurrences = CFArrayGetCount(findResults)
for cnt in 0..<numOccurrences {
- let range = UnsafePointer<CFRange>(CFArrayGetValueAtIndex(findResults, backwards ? cnt : numOccurrences - cnt - 1))
+ let range = UnsafePointer<CFRange>(CFArrayGetValueAtIndex(findResults, backwards ? cnt : numOccurrences - cnt - 1)!)
replaceCharactersInRange(NSRange(range.pointee), withString: replacement)
}
return numOccurrences
@@ -1417,14 +1404,12 @@
}
- public func applyTransform(_ transform: String, reverse: Bool, range: NSRange, updatedRange resultingRange: NSRangePointer) -> Bool {
+ public func applyTransform(_ transform: String, reverse: Bool, range: NSRange, updatedRange resultingRange: NSRangePointer?) -> Bool {
var cfRange = CFRangeMake(range.location, range.length)
return withUnsafeMutablePointer(&cfRange) { (rangep: UnsafeMutablePointer<CFRange>) -> Bool in
if CFStringTransform(_cfMutableObject, rangep, transform._cfObject, reverse) {
- if resultingRange != nil {
- resultingRange.pointee.location = rangep.pointee.location
- resultingRange.pointee.length = rangep.pointee.length
- }
+ resultingRange?.pointee.location = rangep.pointee.location
+ resultingRange?.pointee.length = rangep.pointee.length
return true
}
return false
diff --git a/Foundation/NSSwiftRuntime.swift b/Foundation/NSSwiftRuntime.swift
index 1d6aa9f..40cf6a0 100644
--- a/Foundation/NSSwiftRuntime.swift
+++ b/Foundation/NSSwiftRuntime.swift
@@ -350,9 +350,9 @@
return self.fromOpaque(OpaquePointer(value))
}
- internal static func fromOptionalOpaque(_ value: UnsafePointer<Void>) -> Unmanaged<Instance>? {
- if value != nil {
- return self.fromOpaque(OpaquePointer(value))
+ internal static func fromOptionalOpaque(_ value: UnsafePointer<Void>?) -> Unmanaged<Instance>? {
+ if let opaqueValue = value {
+ return self.fromOpaque(OpaquePointer(opaqueValue))
} else {
return nil
}
@@ -360,8 +360,8 @@
}
extension Array {
- internal mutating func withUnsafeMutablePointerOrAllocation<R>(_ count: Int, fastpath: UnsafeMutablePointer<Element> = nil, @noescape body: (UnsafeMutablePointer<Element>) -> R) -> R {
- if fastpath != nil {
+ internal mutating func withUnsafeMutablePointerOrAllocation<R>(_ count: Int, fastpath: UnsafeMutablePointer<Element>? = nil, @noescape body: (UnsafeMutablePointer<Element>) -> R) -> R {
+ if let fastpath = fastpath {
return body(fastpath)
} else if self.count > count {
let buffer = UnsafeMutablePointer<Element>(allocatingCapacity: count)
@@ -371,7 +371,7 @@
return res
} else {
return withUnsafeMutableBufferPointer() { (bufferPtr: inout UnsafeMutableBufferPointer<Element>) -> R in
- return body(bufferPtr.baseAddress)
+ return body(bufferPtr.baseAddress!)
}
}
}
diff --git a/Foundation/NSTask.swift b/Foundation/NSTask.swift
index 0348003..cc6f559 100644
--- a/Foundation/NSTask.swift
+++ b/Foundation/NSTask.swift
@@ -27,7 +27,7 @@
private var managerThreadSetupOnceToken = pthread_once_t()
// these are different sadly...
#if os(OSX) || os(iOS)
-private var threadID: pthread_t = nil
+private var threadID: pthread_t? = nil
#elseif os(Linux)
private var threadID = pthread_t()
#endif
@@ -40,24 +40,24 @@
internal let kCFSocketDataCallBack = CFSocketCallBackType.dataCallBack.rawValue
#endif
-private func emptyRunLoopCallback(_ context : UnsafeMutablePointer<Void>) -> Void {}
+private func emptyRunLoopCallback(_ context : UnsafeMutablePointer<Void>!) -> Void {}
// Retain method for run loop source
-private func runLoopSourceRetain(_ pointer : UnsafePointer<Void>) -> UnsafePointer<Void> {
+private func runLoopSourceRetain(_ pointer : UnsafePointer<Void>!) -> UnsafePointer<Void>! {
let ref = Unmanaged<AnyObject>.fromOpaque(OpaquePointer(pointer)).takeUnretainedValue()
let retained = Unmanaged<AnyObject>.passRetained(ref)
return unsafeBitCast(retained, to: UnsafePointer<Void>.self)
}
// Release method for run loop source
-private func runLoopSourceRelease(_ pointer : UnsafePointer<Void>) -> Void {
+private func runLoopSourceRelease(_ pointer : UnsafePointer<Void>!) -> Void {
Unmanaged<AnyObject>.fromOpaque(OpaquePointer(pointer)).release()
}
// Equal method for run loop source
-private func runloopIsEqual(_ a : UnsafePointer<Void>, b : UnsafePointer<Void>) -> _DarwinCompatibleBoolean {
+private func runloopIsEqual(_ a : UnsafePointer<Void>!, b : UnsafePointer<Void>!) -> _DarwinCompatibleBoolean {
let unmanagedrunLoopA = Unmanaged<AnyObject>.fromOpaque(OpaquePointer(a))
guard let runLoopA = unmanagedrunLoopA.takeUnretainedValue() as? NSRunLoop else {
@@ -76,7 +76,7 @@
return true
}
-@noreturn private func managerThread(_ x: UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void> {
+@noreturn private func managerThread(_ x: UnsafeMutablePointer<Void>!) -> UnsafeMutablePointer<Void>! {
managerThreadRunLoop = NSRunLoop.currentRunLoop()
var emptySourceContext = CFRunLoopSourceContext (version: 0, info: UnsafeMutablePointer<Void>(OpaquePointer(bitPattern: Unmanaged.passUnretained(managerThreadRunLoop!))),
@@ -111,7 +111,7 @@
// Equal method for task in run loop source
-private func nstaskIsEqual(_ a : UnsafePointer<Void>, b : UnsafePointer<Void>) -> _DarwinCompatibleBoolean {
+private func nstaskIsEqual(_ a : UnsafePointer<Void>!, b : UnsafePointer<Void>!) -> _DarwinCompatibleBoolean {
let unmanagedTaskA = Unmanaged<AnyObject>.fromOpaque(OpaquePointer(a))
guard let taskA = unmanagedTaskA.takeUnretainedValue() as? NSTask else {
@@ -184,9 +184,9 @@
args.append(contentsOf: arguments)
}
- let argv : UnsafeMutablePointer<UnsafeMutablePointer<Int8>> = args.withUnsafeBufferPointer {
+ let argv : UnsafeMutablePointer<UnsafeMutablePointer<Int8>?> = args.withUnsafeBufferPointer {
let array : UnsafeBufferPointer<String> = $0
- let buffer = UnsafeMutablePointer<UnsafeMutablePointer<Int8>>(allocatingCapacity: array.count + 1)
+ let buffer = UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>(allocatingCapacity: array.count + 1)
buffer.initializeFrom(array.map { $0.withCString(strdup) })
buffer[array.count] = nil
return buffer
@@ -200,11 +200,11 @@
argv.deallocateCapacity(args.count + 1)
}
- let envp: UnsafeMutablePointer<UnsafeMutablePointer<Int8>>
+ let envp: UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>
if let env = environment {
let nenv = env.count
- envp = UnsafeMutablePointer<UnsafeMutablePointer<Int8>>(allocatingCapacity: 1 + nenv)
+ envp = UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>(allocatingCapacity: 1 + nenv)
envp.initializeFrom(env.map { strdup("\($0)=\($1)") })
envp[env.count] = nil
@@ -250,11 +250,11 @@
if task.terminationHandler != nil {
#if os(OSX) || os(iOS)
- var threadID: pthread_t = nil
+ var threadID: pthread_t? = nil
#elseif os(Linux)
var threadID = pthread_t()
#endif
- pthread_create(&threadID, nil, { (context) -> UnsafeMutablePointer<Void> in
+ pthread_create(&threadID, nil, { (context) -> UnsafeMutablePointer<Void>! in
let unmanagedTask : Unmanaged<NSTask> = Unmanaged.fromOpaque(context)
let task = unmanagedTask.takeRetainedValue()
diff --git a/Foundation/NSThread.swift b/Foundation/NSThread.swift
index 162e3db..0ccd973 100644
--- a/Foundation/NSThread.swift
+++ b/Foundation/NSThread.swift
@@ -16,7 +16,7 @@
import CoreFoundation
-private func disposeTLS(_ ctx: UnsafeMutablePointer<Void>) -> Void {
+private func disposeTLS(_ ctx: UnsafeMutablePointer<Void>!) -> Void {
Unmanaged<AnyObject>.fromOpaque(OpaquePointer(ctx)).release()
}
@@ -73,7 +73,7 @@
case Finished
}
-private func NSThreadStart(_ context: UnsafeMutablePointer<Void>) -> UnsafeMutablePointer<Void> {
+private func NSThreadStart(_ context: UnsafeMutablePointer<Void>!) -> UnsafeMutablePointer<Void>! {
let unmanaged: Unmanaged<NSThread> = Unmanaged.fromOpaque(OpaquePointer(context))
let thread = unmanaged.takeUnretainedValue()
NSThread._currentThread.set(thread)
@@ -155,7 +155,7 @@
internal var _main: (Void) -> Void = {}
#if os(OSX) || os(iOS)
- private var _thread: pthread_t = nil
+ private var _thread: pthread_t? = nil
#elseif os(Linux)
private var _thread = pthread_t()
#endif
@@ -166,6 +166,7 @@
public var threadDictionary = [String:AnyObject]()
internal init(thread: pthread_t) {
+ // Note: even on Darwin this is a non-optional pthread_t; this is only used for valid threads, which are never null pointers.
_thread = thread
}
diff --git a/Foundation/NSTimeZone.swift b/Foundation/NSTimeZone.swift
index da4397b..2fc9830 100644
--- a/Foundation/NSTimeZone.swift
+++ b/Foundation/NSTimeZone.swift
@@ -13,9 +13,9 @@
public class NSTimeZone : NSObject, NSCopying, NSSecureCoding, NSCoding {
typealias CFType = CFTimeZone
private var _base = _CFInfo(typeID: CFTimeZoneGetTypeID())
- private var _name: UnsafeMutablePointer<Void> = nil
- private var _data: UnsafeMutablePointer<Void> = nil
- private var _periods: UnsafeMutablePointer<Void> = nil
+ private var _name: UnsafeMutablePointer<Void>? = nil
+ private var _data: UnsafeMutablePointer<Void>? = nil
+ private var _periods: UnsafeMutablePointer<Void>? = nil
private var _periodCnt = Int32(0)
internal var _cfObject: CFType {
diff --git a/Foundation/NSTimer.swift b/Foundation/NSTimer.swift
index dfe7d3e..4fd5ef2 100644
--- a/Foundation/NSTimer.swift
+++ b/Foundation/NSTimer.swift
@@ -10,7 +10,7 @@
import CoreFoundation
-internal func __NSFireTimer(_ timer: CFRunLoopTimer!, info: UnsafeMutablePointer<Void>) -> Void {
+internal func __NSFireTimer(_ timer: CFRunLoopTimer!, info: UnsafeMutablePointer<Void>!) -> Void {
let t = Unmanaged<NSTimer>.fromOpaque(info).takeUnretainedValue()
t._fire(t)
}
diff --git a/Foundation/NSURL.swift b/Foundation/NSURL.swift
index 34a5bef..0ad7f1d 100644
--- a/Foundation/NSURL.swift
+++ b/Foundation/NSURL.swift
@@ -33,10 +33,10 @@
internal var _base = _CFInfo(typeID: CFURLGetTypeID())
internal var _flags : UInt32 = 0
internal var _encoding : CFStringEncoding = 0
- internal var _string : UnsafeMutablePointer<CFString> = nil
- internal var _baseURL : UnsafeMutablePointer<CFURL> = nil
- internal var _extra : OpaquePointer = nil
- internal var _resourceInfo : OpaquePointer = nil
+ internal var _string : UnsafeMutablePointer<CFString>? = nil
+ internal var _baseURL : UnsafeMutablePointer<CFURL>? = nil
+ internal var _extra : OpaquePointer? = nil
+ internal var _resourceInfo : OpaquePointer? = nil
internal var _range1 = NSRange(location: 0, length: 0)
internal var _range2 = NSRange(location: 0, length: 0)
internal var _range3 = NSRange(location: 0, length: 0)
@@ -314,7 +314,7 @@
let passwordBuf = buf[passwordRange.location ..< passwordRange.location+passwordRange.length]
return passwordBuf.withUnsafeBufferPointer { ptr in
- NSString(bytes: ptr.baseAddress, length: passwordBuf.count, encoding: NSUTF8StringEncoding)?._swiftObject
+ NSString(bytes: ptr.baseAddress!, length: passwordBuf.count, encoding: NSUTF8StringEncoding)?._swiftObject
}
}
@@ -369,7 +369,10 @@
return UnsafePointer(_fsrBuffer)
}
- return nil
+ // FIXME: This used to return nil, but the corresponding Darwin
+ // implementation is marked as non-nullable.
+ fatalError("URL cannot be expressed in the filesystem representation;" +
+ "use getFileSystemRepresentation to handle this case")
}
// Whether the scheme is file:; if [myURL isFileURL] is YES, then [myURL path] is suitable for input into NSFileManager or NSPathUtilities.
diff --git a/Foundation/NSUUID.swift b/Foundation/NSUUID.swift
index 3413682..745b4a1 100644
--- a/Foundation/NSUUID.swift
+++ b/Foundation/NSUUID.swift
@@ -32,11 +32,7 @@
}
public init(UUIDBytes bytes: UnsafePointer<UInt8>) {
- if (bytes != nil) {
- memcpy(unsafeBitCast(buffer, to: UnsafeMutablePointer<Void>.self), UnsafePointer<Void>(bytes), 16)
- } else {
- memset(unsafeBitCast(buffer, to: UnsafeMutablePointer<Void>.self), 0, 16)
- }
+ memcpy(unsafeBitCast(buffer, to: UnsafeMutablePointer<Void>.self), UnsafePointer<Void>(bytes), 16)
}
public func getUUIDBytes(_ uuid: UnsafeMutablePointer<UInt8>) {
@@ -66,7 +62,7 @@
var length : Int = 0
let bytes = coder.decodeBytesForKey("NS.uuidbytes", returnedLength: &length)
if (length == 16) {
- self.init(UUIDBytes: bytes)
+ self.init(UUIDBytes: bytes!)
} else {
self.init() // failure to decode the entire uuid_t results in a new uuid
}
diff --git a/Foundation/NSXMLDTD.swift b/Foundation/NSXMLDTD.swift
index ced84c3..c4de595 100644
--- a/Foundation/NSXMLDTD.swift
+++ b/Foundation/NSXMLDTD.swift
@@ -21,8 +21,7 @@
public convenience init(contentsOfURL url: NSURL, options mask: Int) throws {
let urlString = url.absoluteString
- let node = _CFXMLParseDTD(urlString)
- if node == nil {
+ guard let node = _CFXMLParseDTD(urlString) else {
//TODO: throw error
fatalError("parsing dtd string failed")
}
@@ -31,11 +30,13 @@
public convenience init(data: NSData, options mask: Int) throws {
var unmanagedError: Unmanaged<CFError>? = nil
- let node = _CFXMLParseDTDFromData(data._cfObject, &unmanagedError)
- if node == nil {
+
+ guard let node = _CFXMLParseDTDFromData(data._cfObject, &unmanagedError) else {
if let error = unmanagedError?.takeRetainedValue()._nsObject {
throw error
}
+ //TODO: throw a generic error?
+ fatalError("parsing dtd from data failed")
}
self.init(ptr: node)
@@ -130,10 +131,7 @@
@abstract Returns the entity declaration matching this name.
*/
public func entityDeclarationForName(_ name: String) -> NSXMLDTDNode? {
- let node = _CFXMLDTDGetEntityDesc(_xmlDTD, name)
- if node == nil {
- return nil
- }
+ guard let node = _CFXMLDTDGetEntityDesc(_xmlDTD, name) else { return nil }
return NSXMLDTDNode._objectNodeForNode(node)
} //primitive
@@ -142,11 +140,7 @@
@abstract Returns the notation declaration matching this name.
*/
public func notationDeclarationForName(_ name: String) -> NSXMLDTDNode? {
- let node = _CFXMLDTDGetNotationDesc(_xmlDTD, name)
-
- if node == nil {
- return nil
- }
+ guard let node = _CFXMLDTDGetNotationDesc(_xmlDTD, name) else { return nil }
return NSXMLDTDNode._objectNodeForNode(node)
} //primitive
@@ -155,11 +149,7 @@
@abstract Returns the element declaration matching this name.
*/
public func elementDeclarationForName(_ name: String) -> NSXMLDTDNode? {
- let node = _CFXMLDTDGetElementDesc(_xmlDTD, name)
-
- if node == nil {
- return nil
- }
+ guard let node = _CFXMLDTDGetElementDesc(_xmlDTD, name) else { return nil }
return NSXMLDTDNode._objectNodeForNode(node)
} //primitive
@@ -168,11 +158,7 @@
@abstract Returns the attribute declaration matching this name.
*/
public func attributeDeclarationForName(_ name: String, elementName: String) -> NSXMLDTDNode? {
- let node = _CFXMLDTDGetAttributeDesc(_xmlDTD, elementName, name)
-
- if node == nil {
- return nil
- }
+ guard let node = _CFXMLDTDGetAttributeDesc(_xmlDTD, elementName, name) else { return nil }
return NSXMLDTDNode._objectNodeForNode(node)
} //primitive
@@ -183,20 +169,15 @@
<ul><li>&lt; - <</li><li>&gt; - ></li><li>&amp; - &</li><li>&quot; - "</li><li>&apos; - &</li></ul>
*/
public class func predefinedEntityDeclarationForName(_ name: String) -> NSXMLDTDNode? {
- let node = _CFXMLDTDGetPredefinedEntity(name)
-
- if node == nil {
- return nil
- }
-
+ guard let node = _CFXMLDTDGetPredefinedEntity(name) else { return nil }
return NSXMLDTDNode._objectNodeForNode(node)
}
internal override class func _objectNodeForNode(_ node: _CFXMLNodePtr) -> NSXMLDTD {
precondition(_CFXMLNodeGetType(node) == _kCFXMLTypeDTD)
- if _CFXMLNodeGetPrivateData(node) != nil {
- let unmanaged = Unmanaged<NSXMLDTD>.fromOpaque(_CFXMLNodeGetPrivateData(node))
+ if let privateData = _CFXMLNodeGetPrivateData(node) {
+ let unmanaged = Unmanaged<NSXMLDTD>.fromOpaque(privateData)
return unmanaged.takeUnretainedValue()
}
diff --git a/Foundation/NSXMLDTDNode.swift b/Foundation/NSXMLDTDNode.swift
index 15cc361..db40251 100644
--- a/Foundation/NSXMLDTDNode.swift
+++ b/Foundation/NSXMLDTDNode.swift
@@ -54,20 +54,16 @@
@abstract Returns an element, attribute, entity, or notation DTD node based on the full XML string.
*/
public init?(XMLString string: String) {
- let ptr = _CFXMLParseDTDNode(string)
- if ptr == nil {
- return nil
- } else {
- super.init(ptr: ptr)
- }
+ guard let ptr = _CFXMLParseDTDNode(string) else { return nil }
+ super.init(ptr: ptr)
} //primitive
public override init(kind: NSXMLNodeKind, options: Int) {
- var ptr: _CFXMLNodePtr = nil
+ let ptr: _CFXMLNodePtr
switch kind {
case .ElementDeclarationKind:
- ptr = _CFXMLDTDNewElementDesc(nil, nil)
+ ptr = _CFXMLDTDNewElementDesc(nil, nil)!
default:
super.init(kind: kind, options: options)
@@ -242,8 +238,8 @@
type == _kCFXMLDTDNodeTypeEntity ||
type == _kCFXMLDTDNodeTypeElement)
- if _CFXMLNodeGetPrivateData(node) != nil {
- let unmanaged = Unmanaged<NSXMLDTDNode>.fromOpaque(_CFXMLNodeGetPrivateData(node))
+ if let privateData = _CFXMLNodeGetPrivateData(node) {
+ let unmanaged = Unmanaged<NSXMLDTDNode>.fromOpaque(privateData)
return unmanaged.takeUnretainedValue()
}
diff --git a/Foundation/NSXMLDocument.swift b/Foundation/NSXMLDocument.swift
index 6e36ff6..2b2f899 100644
--- a/Foundation/NSXMLDocument.swift
+++ b/Foundation/NSXMLDocument.swift
@@ -197,11 +197,10 @@
*/
/*@NSCopying*/ public var DTD: NSXMLDTD? {
get {
- return NSXMLDTD._objectNodeForNode(_CFXMLDocDTD(_xmlDoc));
+ return NSXMLDTD._objectNodeForNode(_CFXMLDocDTD(_xmlDoc)!);
}
set {
- let currDTD = _CFXMLDocDTD(_xmlDoc)
- if currDTD != nil {
+ if let currDTD = _CFXMLDocDTD(_xmlDoc) {
if _CFXMLNodeGetPrivateData(currDTD) != nil {
let DTD = NSXMLDTD._objectNodeForNode(currDTD)
_CFXMLUnlinkNode(currDTD)
@@ -243,8 +242,7 @@
@abstract The root element.
*/
public func rootElement() -> NSXMLElement? {
- let rootPtr = _CFXMLDocRootElement(_xmlDoc)
- if rootPtr == nil {
+ guard let rootPtr = _CFXMLDocRootElement(_xmlDoc) else {
return nil
}
@@ -347,8 +345,8 @@
internal override class func _objectNodeForNode(_ node: _CFXMLNodePtr) -> NSXMLDocument {
precondition(_CFXMLNodeGetType(node) == _kCFXMLTypeDocument)
- if _CFXMLNodeGetPrivateData(node) != nil {
- let unmanaged = Unmanaged<NSXMLDocument>.fromOpaque(_CFXMLNodeGetPrivateData(node))
+ if let privateData = _CFXMLNodeGetPrivateData(node) {
+ let unmanaged = Unmanaged<NSXMLDocument>.fromOpaque(privateData)
return unmanaged.takeUnretainedValue()
}
diff --git a/Foundation/NSXMLElement.swift b/Foundation/NSXMLElement.swift
index f967ad6..32ee5cb 100644
--- a/Foundation/NSXMLElement.swift
+++ b/Foundation/NSXMLElement.swift
@@ -83,8 +83,7 @@
@abstract Removes an attribute based on its name.
*/
public func removeAttributeForName(_ name: String) {
- let prop = _CFXMLNodeHasProp(_xmlNode, name)
- if prop != nil {
+ if let prop = _CFXMLNodeHasProp(_xmlNode, name) {
let propNode = NSXMLNode._objectNodeForNode(_CFXMLNodePtr(prop))
_childNodes.remove(propNode)
// We can't use `xmlRemoveProp` because someone else may still have a reference to this attribute
@@ -99,10 +98,10 @@
public var attributes: [NSXMLNode]? {
get {
var result: [NSXMLNode] = []
- var attribute = _CFXMLNodeProperties(_xmlNode)
- while attribute != nil {
+ var nextAttribute = _CFXMLNodeProperties(_xmlNode)
+ while let attribute = nextAttribute {
result.append(NSXMLNode._objectNodeForNode(attribute))
- attribute = _CFXMLNodeGetNextSibling(attribute)
+ nextAttribute = _CFXMLNodeGetNextSibling(attribute)
}
return result.count > 0 ? result : nil // This appears to be how Darwin does it
}
@@ -121,11 +120,11 @@
}
private func removeAttributes() {
- var attribute = _CFXMLNodeProperties(_xmlNode)
- while attribute != nil {
+ var nextAttribute = _CFXMLNodeProperties(_xmlNode)
+ while let attribute = nextAttribute {
var shouldFreeNode = true
- if _CFXMLNodeGetPrivateData(attribute) != nil {
- let nodeUnmanagedRef = Unmanaged<NSXMLNode>.fromOpaque(_CFXMLNodeGetPrivateData(attribute))
+ if let privateData = _CFXMLNodeGetPrivateData(attribute) {
+ let nodeUnmanagedRef = Unmanaged<NSXMLNode>.fromOpaque(privateData)
let node = nodeUnmanagedRef.takeUnretainedValue()
_childNodes.remove(node)
@@ -138,7 +137,7 @@
_CFXMLFreeNode(attribute)
}
- attribute = temp
+ nextAttribute = temp
}
}
@@ -158,8 +157,7 @@
@abstract Returns an attribute matching this name.
*/
public func attributeForName(_ name: String) -> NSXMLNode? {
- let attribute = _CFXMLNodeHasProp(_xmlNode, name)
- if attribute == nil { return nil }
+ guard let attribute = _CFXMLNodeHasProp(_xmlNode, name) else { return nil }
return NSXMLNode._objectNodeForNode(attribute)
}
@@ -262,8 +260,8 @@
internal override class func _objectNodeForNode(_ node: _CFXMLNodePtr) -> NSXMLElement {
precondition(_CFXMLNodeGetType(node) == _kCFXMLTypeElement)
- if _CFXMLNodeGetPrivateData(node) != nil {
- let unmanaged = Unmanaged<NSXMLElement>.fromOpaque(_CFXMLNodeGetPrivateData(node))
+ if let privateData = _CFXMLNodeGetPrivateData(node) {
+ let unmanaged = Unmanaged<NSXMLElement>.fromOpaque(privateData)
return unmanaged.takeUnretainedValue()
}
diff --git a/Foundation/NSXMLNode.swift b/Foundation/NSXMLNode.swift
index dcbb9b6..33d0cf2 100644
--- a/Foundation/NSXMLNode.swift
+++ b/Foundation/NSXMLNode.swift
@@ -93,7 +93,7 @@
_xmlNode = _CFXMLNewDTD(nil, "", "", "")
default:
- _xmlNode = nil
+ fatalError("invalid node kind for this initializer")
}
super.init()
@@ -216,10 +216,7 @@
@abstract Returns an element, attribute, entity, or notation DTD node based on the full XML string.
*/
public class func DTDNodeWithXMLString(_ string: String) -> AnyObject? {
- let node = _CFXMLParseDTDNode(string)
- if node == nil {
- return nil
- }
+ guard let node = _CFXMLParseDTDNode(string) else { return nil }
return NSXMLDTDNode(ptr: node)
}
@@ -229,7 +226,6 @@
@abstract Returns an element, attribute, entity, or notation DTD node based on the full XML string.
*/
public var kind: NSXMLNodeKind {
- guard _xmlNode != nil else { return .InvalidKind }
switch _CFXMLNodeGetType(_xmlNode) {
case _kCFXMLTypeElement:
return .ElementKind
@@ -339,10 +335,10 @@
}
internal func _removeAllChildren() {
- var child = _CFXMLNodeGetFirstChild(_xmlNode)
- while child != nil {
+ var nextChild = _CFXMLNodeGetFirstChild(_xmlNode)
+ while let child = nextChild {
_CFXMLUnlinkNode(child)
- child = _CFXMLNodeGetNextSibling(child)
+ nextChild = _CFXMLNodeGetNextSibling(child)
}
_childNodes.removeAll(keepingCapacity: true)
}
@@ -383,7 +379,7 @@
}
var result: [Character] = Array(string.characters)
- let doc = _CFXMLNodeGetDocument(_xmlNode)
+ let doc = _CFXMLNodeGetDocument(_xmlNode)!
for (range, entity) in entities {
var entityPtr = _CFXMLGetDocEntity(doc, entity)
if entityPtr == nil {
@@ -392,8 +388,8 @@
if entityPtr == nil {
entityPtr = _CFXMLGetParameterEntity(doc, entity)
}
- if entityPtr != nil {
- let replacement = _CFXMLGetEntityContent(entityPtr)?._swiftObject ?? ""
+ if let validEntity = entityPtr {
+ let replacement = _CFXMLGetEntityContent(validEntity)?._swiftObject ?? ""
result.replaceSubrange(range, with: replacement.characters)
} else {
result.replaceSubrange(range, with: []) // This appears to be how Darwin Foundation does it
@@ -421,10 +417,10 @@
*/
public var level: Int {
var result = 0
- var parent = _CFXMLNodeGetParent(_xmlNode)
- while parent != nil {
+ var nextParent = _CFXMLNodeGetParent(_xmlNode)
+ while let parent = nextParent {
result += 1
- parent = _CFXMLNodeGetParent(parent)
+ nextParent = _CFXMLNodeGetParent(parent)
}
return result
@@ -435,8 +431,7 @@
@abstract The encompassing document or nil.
*/
public var rootDocument: NSXMLDocument? {
- let doc = _CFXMLNodeGetDocument(_xmlNode)
- guard doc != nil else { return nil }
+ guard let doc = _CFXMLNodeGetDocument(_xmlNode) else { return nil }
return NSXMLNode._objectNodeForNode(_CFXMLNodePtr(doc)) as? NSXMLDocument
}
@@ -446,8 +441,7 @@
@abstract The parent of this node. Documents and standalone Nodes have a nil parent; there is not a 1-to-1 relationship between parent and children, eg a namespace cannot be a child but has a parent element.
*/
/*@NSCopying*/ public var parent: NSXMLNode? {
- let parentPtr = _CFXMLNodeGetParent(_xmlNode)
- guard parentPtr != nil else { return nil }
+ guard let parentPtr = _CFXMLNodeGetParent(_xmlNode) else { return nil }
return NSXMLNode._objectNodeForNode(parentPtr)
} //primitive
@@ -499,8 +493,7 @@
@abstract Returns the previous sibling, or nil if there isn't one.
*/
/*@NSCopying*/ public var previousSibling: NSXMLNode? {
- let prev = _CFXMLNodeGetPrevSibling(_xmlNode)
- guard prev != nil else { return nil }
+ guard let prev = _CFXMLNodeGetPrevSibling(_xmlNode) else { return nil }
return NSXMLNode._objectNodeForNode(prev)
}
@@ -510,8 +503,7 @@
@abstract Returns the next sibling, or nil if there isn't one.
*/
/*@NSCopying*/ public var nextSibling: NSXMLNode? {
- let next = _CFXMLNodeGetNextSibling(_xmlNode)
- guard next != nil else { return nil }
+ guard let next = _CFXMLNodeGetNextSibling(_xmlNode) else { return nil }
return NSXMLNode._objectNodeForNode(next)
}
@@ -522,8 +514,8 @@
*/
/*@NSCopying*/ public var previousNode: NSXMLNode? {
if let previousSibling = self.previousSibling {
- if _CFXMLNodeGetLastChild(previousSibling._xmlNode) != nil {
- return NSXMLNode._objectNodeForNode(_CFXMLNodeGetLastChild(previousSibling._xmlNode))
+ if let lastChild = _CFXMLNodeGetLastChild(previousSibling._xmlNode) {
+ return NSXMLNode._objectNodeForNode(lastChild)
} else {
return previousSibling
}
@@ -539,8 +531,7 @@
@abstract Returns the next node in document order. This can be used to walk the tree forwards.
*/
/*@NSCopying*/ public var nextNode: NSXMLNode? {
- let children = _CFXMLNodeGetFirstChild(_xmlNode)
- if children != nil {
+ if let children = _CFXMLNodeGetFirstChild(_xmlNode) {
return NSXMLNode._objectNodeForNode(children)
} else if let next = nextSibling {
return next
@@ -556,12 +547,10 @@
@abstract Detaches this node from its parent.
*/
public func detach() {
- let parentPtr = _CFXMLNodeGetParent(_xmlNode)
- guard parentPtr != nil else { return }
+ guard let parentPtr = _CFXMLNodeGetParent(_xmlNode) else { return }
_CFXMLUnlinkNode(_xmlNode)
- let parentNodePtr = _CFXMLNodeGetPrivateData(parentPtr)
- guard parentNodePtr != nil else { return }
+ guard let parentNodePtr = _CFXMLNodeGetPrivateData(parentPtr) else { return }
let parent = Unmanaged<NSXMLNode>.fromOpaque(parentNodePtr).takeUnretainedValue()
parent._childNodes.remove(self)
} //primitive
@@ -576,7 +565,7 @@
var pathComponents: [String?] = []
var parent = _CFXMLNodeGetParent(_xmlNode)
if parent != nil {
- let parentObj = NSXMLNode._objectNodeForNode(parent)
+ let parentObj = NSXMLNode._objectNodeForNode(parent!)
let siblingsWithSameName = parentObj.filter { $0.name == self.name }
if siblingsWithSameName.count > 1 {
@@ -590,15 +579,15 @@
return self.name
}
while true {
- if _CFXMLNodeGetParent(parent) != nil {
- let grandparent = NSXMLNode._objectNodeForNode(_CFXMLNodeGetParent(parent))
+ if let parentNode = _CFXMLNodeGetParent(parent!) {
+ let grandparent = NSXMLNode._objectNodeForNode(parentNode)
let possibleParentNodes = grandparent.filter { $0.name == self.parent?.name }
let count = possibleParentNodes.reduce(0) {
return $0.0 + 1
}
if count <= 1 {
- pathComponents.append(NSXMLNode._objectNodeForNode(parent).name)
+ pathComponents.append(NSXMLNode._objectNodeForNode(parent!).name)
} else {
var parentNumber = 1
for possibleParent in possibleParentNodes {
@@ -611,10 +600,10 @@
pathComponents.append("\(self.parent?.name ?? "")[\(parentNumber)]")
}
- parent = _CFXMLNodeGetParent(parent)
+ parent = _CFXMLNodeGetParent(parent!)
} else {
- pathComponents.append(NSXMLNode._objectNodeForNode(parent).name)
+ pathComponents.append(NSXMLNode._objectNodeForNode(parent!).name)
break
}
}
@@ -772,14 +761,12 @@
}
internal init(ptr: _CFXMLNodePtr) {
- precondition(ptr != nil)
precondition(_CFXMLNodeGetPrivateData(ptr) == nil, "Only one NSXMLNode per xmlNodePtr allowed")
_xmlNode = ptr
super.init()
- let parent = _CFXMLNodeGetParent(_xmlNode)
- if parent != nil {
+ if let parent = _CFXMLNodeGetParent(_xmlNode) {
let parentNode = NSXMLNode._objectNodeForNode(parent)
parentNode._childNodes.insert(self)
}
@@ -809,8 +796,7 @@
return NSXMLDTDNode._objectNodeForNode(node)
default:
- let _private = _CFXMLNodeGetPrivateData(node)
- if _private != nil {
+ if let _private = _CFXMLNodeGetPrivateData(node) {
let unmanaged = Unmanaged<NSXMLNode>.fromOpaque(_private)
return unmanaged.takeUnretainedValue()
}
@@ -830,7 +816,7 @@
_childNodes.insert(child)
if index == 0 {
- let first = _CFXMLNodeGetFirstChild(_xmlNode)
+ let first = _CFXMLNodeGetFirstChild(_xmlNode)!
_CFXMLNodeAddPrevSibling(first, child._xmlNode)
} else {
let currChild = childAtIndex(index - 1)!._xmlNode
@@ -900,21 +886,21 @@
extension NSXMLNode: _NSXMLNodeCollectionType {
public struct Index: BidirectionalIndex {
- private let node: _CFXMLNodePtr
+ private let node: _CFXMLNodePtr?
public func predecessor() -> Index {
guard node != nil else { return self }
- return Index(node: _CFXMLNodeGetPrevSibling(node))
+ return Index(node: _CFXMLNodeGetPrevSibling(node!))
}
public func successor() -> Index {
guard node != nil else { return self }
- return Index(node: _CFXMLNodeGetNextSibling(node))
+ return Index(node: _CFXMLNodeGetNextSibling(node!))
}
}
public subscript(index: Index) -> NSXMLNode {
- return NSXMLNode._objectNodeForNode(index.node)
+ return NSXMLNode._objectNodeForNode(index.node!)
}
public var startIndex: Index {
diff --git a/Foundation/NSXMLParser.swift b/Foundation/NSXMLParser.swift
index 1ef1d32..e0aac1d 100644
--- a/Foundation/NSXMLParser.swift
+++ b/Foundation/NSXMLParser.swift
@@ -46,7 +46,7 @@
return str
}
-internal func _NSXMLParserCurrentParser() -> _CFXMLInterface {
+internal func _NSXMLParserCurrentParser() -> _CFXMLInterface? {
if let parser = NSXMLParser.currentParser() {
return parser.interface
} else {
@@ -54,7 +54,7 @@
}
}
-internal func _NSXMLParserExternalEntityWithURL(_ interface: _CFXMLInterface, urlStr: UnsafePointer<Int8>, identifier: UnsafePointer<Int8>, context: _CFXMLInterfaceParserContext, originalLoaderFunction: _CFXMLInterfaceExternalEntityLoader) -> _CFXMLInterfaceParserInput {
+internal func _NSXMLParserExternalEntityWithURL(_ interface: _CFXMLInterface, urlStr: UnsafePointer<Int8>, identifier: UnsafePointer<Int8>, context: _CFXMLInterfaceParserContext, originalLoaderFunction: _CFXMLInterfaceExternalEntityLoader) -> _CFXMLInterfaceParserInput? {
let parser = interface.parser
let policy = parser.externalEntityResolvingPolicy
var a: NSURL?
@@ -126,7 +126,7 @@
}
internal func _NSXMLParserGetContext(_ ctx: _CFXMLInterface) -> _CFXMLInterfaceParserContext {
- return ctx.parser._parserContext
+ return ctx.parser._parserContext!
}
internal func _NSXMLParserInternalSubset(_ ctx: _CFXMLInterface, name: UnsafePointer<UInt8>, ExternalID: UnsafePointer<UInt8>, SystemID: UnsafePointer<UInt8>) -> Void {
@@ -145,7 +145,7 @@
return _CFXMLInterfaceHasExternalSubset(ctx.parser._parserContext)
}
-internal func _NSXMLParserGetEntity(_ ctx: _CFXMLInterface, name: UnsafePointer<UInt8>) -> _CFXMLInterfaceEntity {
+internal func _NSXMLParserGetEntity(_ ctx: _CFXMLInterface, name: UnsafePointer<UInt8>) -> _CFXMLInterfaceEntity? {
let parser = ctx.parser
let context = _NSXMLParserGetContext(ctx)
var entity = _CFXMLInterfaceGetPredefinedEntity(name)
@@ -235,13 +235,13 @@
return "\(prefixString!):\(suffixString!)"
}
-internal func _NSXMLParserStartElementNs(_ ctx: _CFXMLInterface, localname: UnsafePointer<UInt8>, prefix: UnsafePointer<UInt8>, URI: UnsafePointer<UInt8>, nb_namespaces: Int32, namespaces: UnsafeMutablePointer<UnsafePointer<UInt8>>, nb_attributes: Int32, nb_defaulted: Int32, attributes: UnsafeMutablePointer<UnsafePointer<UInt8>>) -> Void {
+internal func _NSXMLParserStartElementNs(_ ctx: _CFXMLInterface, localname: UnsafePointer<UInt8>, prefix: UnsafePointer<UInt8>?, URI: UnsafePointer<UInt8>, nb_namespaces: Int32, namespaces: UnsafeMutablePointer<UnsafePointer<UInt8>?>, nb_attributes: Int32, nb_defaulted: Int32, attributes: UnsafeMutablePointer<UnsafePointer<UInt8>?>) -> Void {
let parser = ctx.parser
let reportQNameURI = parser.shouldProcessNamespaces
let reportNamespaces = parser.shouldReportNamespacePrefixes
- let prefixLen = prefix == nil ? UInt(strlen(UnsafePointer<Int8>(prefix))) : 0
+ let prefixLen = prefix != nil ? UInt(strlen(UnsafePointer<Int8>(prefix!))) : 0
let localnameString = (prefixLen == 0 || reportQNameURI) ? UTF8STRING(localname) : nil
- let qualifiedNameString = prefixLen != 0 ? _colonSeparatedStringFromPrefixAndSuffix(prefix, UInt(prefixLen), localname, UInt(strlen(UnsafePointer<Int8>(localname)))) : localnameString
+ let qualifiedNameString = prefixLen != 0 ? _colonSeparatedStringFromPrefixAndSuffix(prefix!, UInt(prefixLen), localname, UInt(strlen(UnsafePointer<Int8>(localname)))) : localnameString
let namespaceURIString = reportQNameURI ? UTF8STRING(URI) : nil
var nsDict = [String:String]()
@@ -250,16 +250,16 @@
for idx in stride(from: 0, to: Int(nb_namespaces) * 2, by: 2) {
var namespaceNameString: String?
var asAttrNamespaceNameString: String?
- if namespaces[idx] != nil {
+ if let ns = namespaces[idx] {
if reportNamespaces {
- namespaceNameString = UTF8STRING(namespaces[idx])
+ namespaceNameString = UTF8STRING(ns)
}
- asAttrNamespaceNameString = _colonSeparatedStringFromPrefixAndSuffix("xmlns", 5, namespaces[idx], UInt(strlen(UnsafePointer<Int8>(namespaces[idx]))))
+ asAttrNamespaceNameString = _colonSeparatedStringFromPrefixAndSuffix("xmlns", 5, ns, UInt(strlen(UnsafePointer<Int8>(ns))))
} else {
namespaceNameString = ""
asAttrNamespaceNameString = "xmlns"
}
- let namespaceValueString = namespaces[idx + 1] == nil ? UTF8STRING(namespaces[idx + 1]) : ""
+ let namespaceValueString = namespaces[idx + 1] != nil ? UTF8STRING(namespaces[idx + 1]!) : ""
if reportNamespaces {
if let k = namespaceNameString, v = namespaceValueString {
nsDict[k] = v
@@ -282,11 +282,11 @@
continue
}
var attributeQName: String
- let attrLocalName = attributes[idx]
+ let attrLocalName = attributes[idx]!
let attrPrefix = attributes[idx + 1]
- let attrPrefixLen = attrPrefix == nil ? strlen(UnsafePointer<Int8>(attrPrefix)) : 0
+ let attrPrefixLen = attrPrefix != nil ? strlen(UnsafePointer<Int8>(attrPrefix!)) : 0
if attrPrefixLen != 0 {
- attributeQName = _colonSeparatedStringFromPrefixAndSuffix(attrPrefix, UInt(attrPrefixLen), attrLocalName, UInt(strlen((UnsafePointer<Int8>(attrLocalName)))))
+ attributeQName = _colonSeparatedStringFromPrefixAndSuffix(attrPrefix!, UInt(attrPrefixLen), attrLocalName, UInt(strlen((UnsafePointer<Int8>(attrLocalName)))))
} else {
attributeQName = UTF8STRING(attrLocalName)!
}
@@ -295,13 +295,13 @@
// By using XML_PARSE_NOENT the attribute value string will already have entities resolved
var attributeValue = ""
if attributes[idx + 3] != nil && attributes[idx + 4] != nil {
- let numBytesWithoutTerminator = attributes[idx + 4] - attributes[idx + 3]
+ let numBytesWithoutTerminator = attributes[idx + 4]! - attributes[idx + 3]!
let numBytesWithTerminator = numBytesWithoutTerminator + 1
if numBytesWithoutTerminator != 0 {
var chars = [Int8](repeating: 0, count: numBytesWithTerminator)
attributeValue = chars.withUnsafeMutableBufferPointer({ (buffer: inout UnsafeMutableBufferPointer<Int8>) -> String in
- strncpy(buffer.baseAddress, UnsafePointer<Int8>(attributes[idx + 3]), numBytesWithoutTerminator) //not strlcpy because attributes[i+3] is not Nul terminated
- return UTF8STRING(UnsafePointer<UInt8>(buffer.baseAddress))!
+ strncpy(buffer.baseAddress!, UnsafePointer<Int8>(attributes[idx + 3]!), numBytesWithoutTerminator) //not strlcpy because attributes[i+3] is not Nul terminated
+ return UTF8STRING(UnsafePointer<UInt8>(buffer.baseAddress!))!
})
}
attrDict[attributeQName] = attributeValue
@@ -318,13 +318,13 @@
}
}
-internal func _NSXMLParserEndElementNs(_ ctx: _CFXMLInterface , localname: UnsafePointer<UInt8>, prefix: UnsafePointer<UInt8>, URI: UnsafePointer<UInt8>) -> Void {
+internal func _NSXMLParserEndElementNs(_ ctx: _CFXMLInterface , localname: UnsafePointer<UInt8>, prefix: UnsafePointer<UInt8>?, URI: UnsafePointer<UInt8>) -> Void {
let parser = ctx.parser
let reportQNameURI = parser.shouldProcessNamespaces
- let prefixLen = prefix == nil ? strlen(UnsafePointer<Int8>(prefix)) : 0
+ let prefixLen = prefix != nil ? strlen(UnsafePointer<Int8>(prefix!)) : 0
let localnameString = (prefixLen == 0 || reportQNameURI) ? UTF8STRING(localname) : nil
let nilStr: String? = nil
- let qualifiedNameString = (prefixLen != 0) ? _colonSeparatedStringFromPrefixAndSuffix(prefix, UInt(prefixLen), localname, UInt(strlen(UnsafePointer<Int8>(localname)))) : nilStr
+ let qualifiedNameString = (prefixLen != 0) ? _colonSeparatedStringFromPrefixAndSuffix(prefix!, UInt(prefixLen), localname, UInt(strlen(UnsafePointer<Int8>(localname)))) : nilStr
let namespaceURIString = reportQNameURI ? UTF8STRING(URI) : nilStr
@@ -343,7 +343,7 @@
internal func _NSXMLParserCharacters(_ ctx: _CFXMLInterface, ch: UnsafePointer<UInt8>, len: Int32) -> Void {
let parser = ctx.parser
- let context = parser._parserContext
+ let context = parser._parserContext!
if _CFXMLInterfaceInRecursiveState(context) != 0 {
_CFXMLInterfaceResetRecursiveState(context)
} else {
@@ -398,7 +398,7 @@
internal var _chunkSize = Int(4096 * 32) // a suitably large number for a decent chunk size
internal var _haveDetectedEncoding = false
internal var _bomChunk: NSData?
- private var _parserContext: _CFXMLInterfaceParserContext
+ private var _parserContext: _CFXMLInterfaceParserContext?
internal var _delegateAborted = false
internal var _url: NSURL?
internal var _namespaces = [[String:String]]()
@@ -509,7 +509,7 @@
allExistingData = data
}
- var handler: _CFXMLInterfaceSAXHandler = nil
+ var handler: _CFXMLInterfaceSAXHandler? = nil
if delegate != nil {
handler = _handler
}
@@ -587,8 +587,8 @@
// called by the delegate to stop the parse. The delegate will get an error message sent to it.
public func abortParsing() {
- if _parserContext != nil {
- _CFXMLInterfaceStopParser(_parserContext)
+ if let context = _parserContext {
+ _CFXMLInterfaceStopParser(context)
_delegateAborted = true
}
}
diff --git a/Foundation/String.swift b/Foundation/String.swift
index d498a08..4f3a834 100644
--- a/Foundation/String.swift
+++ b/Foundation/String.swift
@@ -111,14 +111,12 @@
/// non-`nil`, convert the buffer to an `Index` and write it into the
/// memory referred to by `index`
func _withOptionalOutParameter<Result>(
- _ index: UnsafeMutablePointer<Index>,
- @noescape body: (UnsafeMutablePointer<Int>) -> Result
+ _ index: UnsafeMutablePointer<Index>?,
+ @noescape body: (UnsafeMutablePointer<Int>?) -> Result
) -> Result {
var utf16Index: Int = 0
- let result = index._withBridgeValue(&utf16Index) {
- body($0)
- }
- index._setIfNonNil { self._index(utf16Index) }
+ let result = (index != nil) ? body(&utf16Index) : body(nil)
+ index?.pointee = self._index(utf16Index)
return result
}
@@ -126,14 +124,12 @@
/// from non-`nil`, convert the buffer to a `Range<Index>` and write
/// it into the memory referred to by `range`
func _withOptionalOutParameter<Result>(
- _ range: UnsafeMutablePointer<Range<Index>>,
- @noescape body: (UnsafeMutablePointer<NSRange>) -> Result
+ _ range: UnsafeMutablePointer<Range<Index>>?,
+ @noescape body: (UnsafeMutablePointer<NSRange>?) -> Result
) -> Result {
var nsRange = NSRange(location: 0, length: 0)
- let result = range._withBridgeValue(&nsRange) {
- body($0)
- }
- range._setIfNonNil { self._range(nsRange) }
+ let result = (range != nil) ? body(&nsRange) : body(nil)
+ range?.pointee = self._range(nsRange)
return result
}
@@ -802,7 +798,7 @@
/// interpret the file.
public init(
contentsOfFile path: String,
- usedEncoding: UnsafeMutablePointer<NSStringEncoding> = nil
+ usedEncoding: UnsafeMutablePointer<NSStringEncoding>? = nil
) throws {
let ns = try NSString(contentsOfFile: path, usedEncoding: usedEncoding)
self = ns._swiftObject
@@ -834,7 +830,7 @@
/// data. Errors are written into the inout `error` argument.
public init(
contentsOfURL url: NSURL,
- usedEncoding enc: UnsafeMutablePointer<NSStringEncoding> = nil
+ usedEncoding enc: UnsafeMutablePointer<NSStringEncoding>? = nil
) throws {
let ns = try NSString(contentsOfURL: url, usedEncoding: enc)
self = ns._swiftObject
diff --git a/TestFoundation/TestNSArray.swift b/TestFoundation/TestNSArray.swift
index e0a21f8..be20c74 100644
--- a/TestFoundation/TestNSArray.swift
+++ b/TestFoundation/TestNSArray.swift
@@ -358,7 +358,7 @@
let mutableInput = inputNumbers.bridge().mutableCopy() as! NSMutableArray
let expectedNumbers = inputNumbers.sorted()
- func compare(_ left: AnyObject, right:AnyObject, context: UnsafeMutablePointer<Void>) -> Int {
+ func compare(_ left: AnyObject, right:AnyObject, context: UnsafeMutablePointer<Void>?) -> Int {
let l = (left as! NSNumber).integerValue
let r = (right as! NSNumber).integerValue
return l < r ? -1 : (l > r ? 0 : 1)
diff --git a/TestFoundation/TestNSKeyedArchiver.swift b/TestFoundation/TestNSKeyedArchiver.swift
index ad6c541..7c12817 100644
--- a/TestFoundation/TestNSKeyedArchiver.swift
+++ b/TestFoundation/TestNSKeyedArchiver.swift
@@ -129,7 +129,7 @@
let array: Array<UInt64> = [12341234123, 23452345234, 23475982345, 9893563243, 13469816598]
let objctype = "[5Q]"
array.withUnsafeBufferPointer { cArray in
- let concrete = NSValue(bytes: cArray.baseAddress, objCType: objctype)
+ let concrete = NSValue(bytes: cArray.baseAddress!, objCType: objctype)
test_archive(concrete)
}
}
@@ -144,14 +144,14 @@
test_archive({ archiver -> Bool in
array.withUnsafeBufferPointer { cArray in
- archiver.encodeValueOfObjCType("[4i]", at: cArray.baseAddress)
+ archiver.encodeValueOfObjCType("[4i]", at: cArray.baseAddress!)
}
return true
},
decode: {unarchiver -> Bool in
var expected: Array<Int32> = [0, 0, 0, 0]
expected.withUnsafeMutableBufferPointer {(p: inout UnsafeMutableBufferPointer<Int32>) in
- unarchiver.decodeValueOfObjCType("[4i]", at: UnsafeMutablePointer<Void>(p.baseAddress))
+ unarchiver.decodeValueOfObjCType("[4i]", at: UnsafeMutablePointer<Void>(p.baseAddress!))
}
XCTAssertEqual(expected, array)
return true
@@ -229,15 +229,15 @@
guard let value = unarchiver.decodeObjectOfClass(NSValue.self, forKey: "root") else {
return false
}
- var expectedCharPtr: UnsafeMutablePointer<CChar> = nil
+ var expectedCharPtr: UnsafeMutablePointer<CChar>? = nil
value.getValue(&expectedCharPtr)
let s1 = String(cString: charPtr)
- let s2 = String(cString: expectedCharPtr)
+ let s2 = String(cString: expectedCharPtr!)
// On Darwin decoded strings would belong to the autorelease pool, but as we don't have
// one in SwiftFoundation let's explicitly deallocate it here.
- expectedCharPtr.deallocateCapacity(charArray.count)
+ expectedCharPtr!.deallocateCapacity(charArray.count)
return s1 == s2
})
diff --git a/TestFoundation/TestNSKeyedUnarchiver.swift b/TestFoundation/TestNSKeyedUnarchiver.swift
index 47cc00d..e724106 100644
--- a/TestFoundation/TestNSKeyedUnarchiver.swift
+++ b/TestFoundation/TestNSKeyedUnarchiver.swift
@@ -67,7 +67,7 @@
let array: Array<Int32> = [1, 2, 3]
let objctype = "[3i]"
array.withUnsafeBufferPointer { cArray in
- let concrete = NSValue(bytes: cArray.baseAddress, objCType: objctype)
+ let concrete = NSValue(bytes: cArray.baseAddress!, objCType: objctype)
test_unarchive_from_file("NSKeyedUnarchiver-ConcreteValueTest", concrete)
}
}
diff --git a/TestFoundation/TestNSString.swift b/TestFoundation/TestNSString.swift
index 65454da..46b2df4 100644
--- a/TestFoundation/TestNSString.swift
+++ b/TestFoundation/TestNSString.swift
@@ -743,7 +743,7 @@
let expected: [Int8] = [102, 111, 111, 0]
var res: Bool = false
chars.withUnsafeMutableBufferPointer() {
- let ptr = $0.baseAddress
+ let ptr = $0.baseAddress!
res = str.getCString(ptr, maxLength: count, encoding: NSASCIIStringEncoding)
}
XCTAssertTrue(res, "getCString should work on simple strings with ascii string encoding")
@@ -757,12 +757,12 @@
let count = chars.count
var res: Bool = false
chars.withUnsafeMutableBufferPointer() {
- let ptr = $0.baseAddress
+ let ptr = $0.baseAddress!
res = str.getCString(ptr, maxLength: count, encoding: NSASCIIStringEncoding)
}
XCTAssertFalse(res, "getCString should not work on non ascii strings accessing as ascii string encoding")
chars.withUnsafeMutableBufferPointer() {
- let ptr = $0.baseAddress
+ let ptr = $0.baseAddress!
res = str.getCString(ptr, maxLength: count, encoding: NSUTF8StringEncoding)
}
XCTAssertTrue(res, "getCString should work on UTF8 encoding")
diff --git a/TestFoundation/TestNSUUID.swift b/TestFoundation/TestNSUUID.swift
index 1b0bf0f..1043e3a 100644
--- a/TestFoundation/TestNSUUID.swift
+++ b/TestFoundation/TestNSUUID.swift
@@ -23,7 +23,6 @@
return [
("test_Equality", test_Equality),
("test_InvalidUUID", test_InvalidUUID),
- ("test_InitializationWithNil", test_InitializationWithNil),
("test_UUIDString", test_UUIDString),
("test_description", test_description),
// Disabled until NSKeyedArchiver and NSKeyedUnarchiver are implemented
@@ -47,11 +46,6 @@
XCTAssertNil(uuid, "The convenience initializer `init?(UUIDString string:)` must return nil for an invalid UUID string.")
}
- func test_InitializationWithNil() {
- let uuid = NSUUID(UUIDBytes: nil)
- XCTAssertEqual(uuid, NSUUID(UUIDBytes: [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]), "The convenience initializer `init(UUIDBytes bytes:)` must return the Nil UUID when UUIDBytes is nil.")
- }
-
// `UUIDString` should return an uppercase string
// See: https://bugs.swift.org/browse/SR-865
func test_UUIDString() {
diff --git a/TestFoundation/TestNSValue.swift b/TestFoundation/TestNSValue.swift
index a4bfe49..2936f3c 100644
--- a/TestFoundation/TestNSValue.swift
+++ b/TestFoundation/TestNSValue.swift
@@ -103,7 +103,7 @@
let array: Array<UInt64> = [12341234123, 23452345234, 23475982345, 9893563243, 13469816598]
array.withUnsafeBufferPointer { cArray in
var expected = [UInt64](repeating: 0, count: 5)
- NSValue(bytes: cArray.baseAddress, objCType: "[5Q]").getValue(&expected)
+ NSValue(bytes: cArray.baseAddress!, objCType: "[5Q]").getValue(&expected)
XCTAssertEqual(array, expected)
}
}
@@ -113,7 +113,7 @@
let objctype = "[" + String(array.count) + "s]"
array.withUnsafeBufferPointer { cArray in
var expected = [Int16](repeating: 0, count: array.count)
- NSValue(bytes: cArray.baseAddress, objCType: objctype).getValue(&expected)
+ NSValue(bytes: cArray.baseAddress!, objCType: objctype).getValue(&expected)
XCTAssertEqual(array, expected)
}
}
@@ -121,7 +121,7 @@
func test_valueWithCharPtr() {
let charArray = [UInt8]("testing123".utf8)
var charPtr = UnsafeMutablePointer<UInt8>(charArray)
- var expectedPtr: UnsafeMutablePointer<UInt8> = nil
+ var expectedPtr: UnsafeMutablePointer<UInt8>? = nil
NSValue(bytes: &charPtr, objCType: "*").getValue(&expectedPtr)
XCTAssertEqual(charPtr, expectedPtr)
