1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
|
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
#include "swift/Runtime/Config.h"
#if SWIFT_OBJC_INTEROP
#include "swift/Basic/Lazy.h"
#include "swift/Runtime/Metadata.h"
#include "swift/Runtime/ObjCBridge.h"
#include "swift/Runtime/Portability.h"
#include "swift/Threading/Mutex.h"
#import <CoreFoundation/CoreFoundation.h>
#import <Foundation/Foundation.h>
#include <vector>
using namespace swift;
/// Class of sentinel objects used to represent the `nil` value of nested
/// optionals.
///
/// NOTE: older runtimes called this _SwiftNull. The two must
/// coexist, so it was renamed. The old name must not be used in the new
/// runtime.
@interface __SwiftNull : NSObject {
@public
unsigned depth;
}
@end
@implementation __SwiftNull : NSObject
- (id)description {
char *str = NULL;
const char *clsName = class_getName([self class]);
int fmtResult = swift_asprintf(&str, "<%s %p depth = %u>", clsName,
(void*)self,
self->depth);
(void)fmtResult;
assert(fmtResult != -1 && "unable to format description of null");
id result = swift_stdlib_NSStringFromUTF8(str, strlen(str));
free(str);
return result;
}
@end
namespace {
struct SwiftNullSentinelCache {
std::vector<id> Cache;
Mutex Lock;
};
static Lazy<SwiftNullSentinelCache> Sentinels;
static id getSentinelForDepth(unsigned depth) {
// For unnested optionals, use NSNull.
if (depth == 1)
return SWIFT_LAZY_CONSTANT(id_const_cast([objc_getClass("NSNull") null]));
// Otherwise, make up our own sentinel.
// See if we created one for this depth.
auto &theSentinels = Sentinels.get();
unsigned depthIndex = depth - 2;
{
Mutex::ScopedLock lock(theSentinels.Lock);
const auto &cache = theSentinels.Cache;
if (depthIndex < cache.size()) {
id cached = cache[depthIndex];
if (cached)
return cached;
}
}
// Make one if we need to.
{
Mutex::ScopedLock lock(theSentinels.Lock);
if (depthIndex >= theSentinels.Cache.size())
theSentinels.Cache.resize(depthIndex + 1);
auto &cached = theSentinels.Cache[depthIndex];
// Make sure another writer didn't sneak in.
if (!cached) {
auto sentinel = [[__SwiftNull alloc] init];
sentinel->depth = depth;
cached = sentinel;
}
return cached;
}
}
}
/// Return the sentinel object to use to represent `nil` for a given Optional
/// type.
SWIFT_RUNTIME_STDLIB_API SWIFT_CC(swift)
id _swift_Foundation_getOptionalNilSentinelObject(const Metadata *Wrapped) {
// Figure out the depth of optionality we're working with.
unsigned depth = 1;
while (Wrapped->getKind() == MetadataKind::Optional) {
++depth;
Wrapped = cast<EnumMetadata>(Wrapped)->getGenericArgs()[0];
}
return objc_retain(getSentinelForDepth(depth));
}
#endif
|