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
|
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2023 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 Swift project authors
//
private import _TestingInternals
extension CommandLine {
/// The path to the current process' executable.
static var executablePath: String {
get throws {
#if os(macOS)
var result: String?
#if DEBUG
var bufferCount = UInt32(1) // force looping
#else
var bufferCount = UInt32(PATH_MAX)
#endif
while result == nil {
withUnsafeTemporaryAllocation(of: CChar.self, capacity: Int(bufferCount)) { buffer in
// _NSGetExecutablePath returns 0 on success and -1 if bufferCount is
// too small. If that occurs, we'll return nil here and loop with the
// new value of bufferCount.
if 0 == _NSGetExecutablePath(buffer.baseAddress, &bufferCount) {
result = String(cString: buffer.baseAddress!)
}
}
}
return result!
#elseif os(Linux) || os(Android)
return try withUnsafeTemporaryAllocation(of: CChar.self, capacity: Int(PATH_MAX) * 2) { buffer in
let readCount = readlink("/proc/self/exe", buffer.baseAddress!, buffer.count - 1)
guard readCount >= 0 else {
throw CError(rawValue: swt_errno())
}
buffer[readCount] = 0 // NUL-terminate the string.
return String(cString: buffer.baseAddress!)
}
#elseif os(FreeBSD)
var mib = [CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1]
return try mib.withUnsafeMutableBufferPointer { mib in
var bufferCount = 0
guard 0 == sysctl(mib.baseAddress!, .init(mib.count), nil, &bufferCount, nil, 0) else {
throw CError(rawValue: swt_errno())
}
return try withUnsafeTemporaryAllocation(of: CChar.self, capacity: bufferCount) { buffer in
guard 0 == sysctl(mib.baseAddress!, .init(mib.count), buffer.baseAddress!, &bufferCount, nil, 0) else {
throw CError(rawValue: swt_errno())
}
return String(cString: buffer.baseAddress!)
}
}
#elseif os(Windows)
var result: String?
#if DEBUG
var bufferCount = Int(1) // force looping
#else
var bufferCount = Int(MAX_PATH)
#endif
while result == nil {
try withUnsafeTemporaryAllocation(of: wchar_t.self, capacity: bufferCount) { buffer in
SetLastError(DWORD(ERROR_SUCCESS))
_ = GetModuleFileNameW(nil, buffer.baseAddress!, DWORD(buffer.count))
switch GetLastError() {
case DWORD(ERROR_SUCCESS):
result = String.decodeCString(buffer.baseAddress!, as: UTF16.self)?.result
if result == nil {
throw Win32Error(rawValue: DWORD(ERROR_ILLEGAL_CHARACTER))
}
case DWORD(ERROR_INSUFFICIENT_BUFFER):
bufferCount += Int(MAX_PATH)
case let errorCode:
throw Win32Error(rawValue: errorCode)
}
}
}
return result!
#elseif os(WASI)
// WASI does not really have the concept of a file system path to the main
// executable, so simply return the first argument--presumably the program
// name, but as you know this is not guaranteed by the C standard!
return arguments[0]
#else
#warning("Platform-specific implementation missing: executable path unavailable")
return ""
#endif
}
}
}
|
