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
|
//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
// This file contains compiler intrinsics for optimized string switch
// implementations. All functions and types declared in this file are not
// intended to be used by switch source directly.
/// The compiler intrinsic which is called to lookup a string in a table
/// of static string case values.
@_semantics("findStringSwitchCase")
public // COMPILER_INTRINSIC
func _findStringSwitchCase(
cases: [StaticString],
string: String) -> Int {
for (idx, s) in cases.enumerated() {
if String(_builtinStringLiteral: s.utf8Start._rawValue,
utf8CodeUnitCount: s._utf8CodeUnitCount,
isASCII: s.isASCII._value) == string {
return idx
}
}
return -1
}
@frozen // needs known size for static allocation
public // used by COMPILER_INTRINSIC
struct _OpaqueStringSwitchCache {
var a: Builtin.Word
var b: Builtin.Word
}
internal typealias _StringSwitchCache = Dictionary<String, Int>
internal struct _StringSwitchContext {
internal let cases: [StaticString]
internal let cachePtr: UnsafeMutablePointer<_StringSwitchCache>
internal init(
cases: [StaticString],
cachePtr: UnsafeMutablePointer<_StringSwitchCache>
){
self.cases = cases
self.cachePtr = cachePtr
}
}
/// The compiler intrinsic which is called to lookup a string in a table
/// of static string case values.
///
/// The first time this function is called, a cache is built and stored
/// in \p cache. Consecutive calls use the cache for faster lookup.
/// The \p cases array must not change between subsequent calls with the
/// same \p cache.
@_semantics("findStringSwitchCaseWithCache")
public // COMPILER_INTRINSIC
func _findStringSwitchCaseWithCache(
cases: [StaticString],
string: String,
cache: inout _OpaqueStringSwitchCache) -> Int {
#if $BuiltinUnprotectedAddressOf
let ptr = UnsafeMutableRawPointer(Builtin.unprotectedAddressOf(&cache))
#else
let ptr = UnsafeMutableRawPointer(Builtin.addressof(&cache))
#endif
let oncePtr = ptr
let cacheRawPtr = oncePtr + MemoryLayout<Builtin.Word>.stride
let cachePtr = cacheRawPtr.bindMemory(to: _StringSwitchCache.self, capacity: 1)
var context = _StringSwitchContext(cases: cases, cachePtr: cachePtr)
withUnsafeMutablePointer(to: &context) { (context) -> () in
Builtin.onceWithContext(oncePtr._rawValue, _createStringTableCache,
context._rawValue)
}
let cache = cachePtr.pointee;
if let idx = cache[string] {
return idx
}
return -1
}
/// Builds the string switch case.
internal func _createStringTableCache(_ cacheRawPtr: Builtin.RawPointer) {
let context = UnsafePointer<_StringSwitchContext>(cacheRawPtr).pointee
var cache = _StringSwitchCache()
cache.reserveCapacity(context.cases.count)
_internalInvariant(
MemoryLayout<_StringSwitchCache>.size <= MemoryLayout<Builtin.Word>.size)
for (idx, s) in context.cases.enumerated() {
let key = String(_builtinStringLiteral: s.utf8Start._rawValue,
utf8CodeUnitCount: s._utf8CodeUnitCount,
isASCII: s.isASCII._value)
cache[key] = idx
}
context.cachePtr.initialize(to: cache)
}
|
