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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 Apple Inc. and the Swift System project authors
Licensed under Apache License v2.0 with Runtime Library Exception
See https://swift.org/LICENSE.txt for license information
*/
// NOTICE: This utility definitions are copied from swift-system package
// temporarily until we will upstream extra functions in this module.
import SystemPackage
#if canImport(Darwin)
import Darwin
#endif
#if canImport(Glibc)
import Glibc
#endif
#if canImport(ucrt)
import ucrt
#endif
#if canImport(WASILibc)
import WASILibc
#endif
// Results in errno if i == -1
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
private func valueOrErrno<I: FixedWidthInteger>(
_ i: I
) -> Result<I, Errno> {
i == -1 ? .failure(Errno(rawValue: errno)) : .success(i)
}
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
private func nothingOrErrno<I: FixedWidthInteger>(
_ i: I
) -> Result<(), Errno> {
valueOrErrno(i).map { _ in () }
}
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
internal func valueOrErrno<I: FixedWidthInteger>(
retryOnInterrupt: Bool, _ f: () -> I
) -> Result<I, Errno> {
repeat {
switch valueOrErrno(f()) {
case .success(let r): return .success(r)
case .failure(let err):
guard retryOnInterrupt && err == .interrupted else { return .failure(err) }
break
}
} while true
}
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
internal func nothingOrErrno<I: FixedWidthInteger>(
retryOnInterrupt: Bool, _ f: () -> I
) -> Result<(), Errno> {
valueOrErrno(retryOnInterrupt: retryOnInterrupt, f).map { _ in () }
}
// Run a precondition for debug client builds
internal func _debugPrecondition(
_ condition: @autoclosure () -> Bool,
_ message: StaticString = StaticString(),
file: StaticString = #file, line: UInt = #line
) {
// Only check in debug mode.
if _slowPath(_isDebugAssertConfiguration()) {
precondition(
condition(), String(describing: message), file: file, line: line)
}
}
extension OpaquePointer {
internal var _isNULL: Bool {
OpaquePointer(bitPattern: Int(bitPattern: self)) == nil
}
}
extension Sequence {
// Tries to recast contiguous pointer if available, otherwise allocates memory.
internal func _withRawBufferPointer<R>(
_ body: (UnsafeRawBufferPointer) throws -> R
) rethrows -> R {
guard let result = try self.withContiguousStorageIfAvailable({
try body(UnsafeRawBufferPointer($0))
}) else {
return try Array(self).withUnsafeBytes(body)
}
return result
}
}
extension OptionSet {
// Helper method for building up a comma-separated list of options
//
// Taking an array of descriptions reduces code size vs
// a series of calls due to avoiding register copies. Make sure
// to pass an array literal and not an array built up from a series of
// append calls, else that will massively bloat code size. This takes
// StaticStrings because otherwise we get a warning about getting evicted
// from the shared cache.
@inline(never)
internal func _buildDescription(
_ descriptions: [(Element, StaticString)]
) -> String {
var copy = self
var result = "["
for (option, name) in descriptions {
if _slowPath(copy.contains(option)) {
result += name.description
copy.remove(option)
if !copy.isEmpty { result += ", " }
}
}
if _slowPath(!copy.isEmpty) {
result += "\(Self.self)(rawValue: \(copy.rawValue))"
}
result += "]"
return result
}
}
internal func _dropCommonPrefix<C: Collection>(
_ lhs: C, _ rhs: C
) -> (C.SubSequence, C.SubSequence)
where C.Element: Equatable {
var (lhs, rhs) = (lhs[...], rhs[...])
while lhs.first != nil && lhs.first == rhs.first {
lhs.removeFirst()
rhs.removeFirst()
}
return (lhs, rhs)
}
extension MutableCollection where Element: Equatable {
mutating func _replaceAll(_ e: Element, with new: Element) {
for idx in self.indices {
if self[idx] == e { self[idx] = new }
}
}
}
|
