Compare commits

...
551 Commits
Author SHA1 Message Date
Max Desiatov 94090e1c5c WIP: fix errors when building for Embedded Swift
rdar://159277249
2025-08-27 14:56:23 +01:00
Guillaume Lessard b6a7776360 Merge pull request #255 from lamtrinhdev/Fix_typo_issues
Fix spelling errors in some comments.
2025-08-12 15:00:43 -07:00
LamTrinh.Dev 0ea6743c17 Fix spelling errors in some comments. 2025-08-11 00:56:26 +07:00
Jonathan Flat 086219bf62 Merge pull request #253 from jrflat/static-and-wasm-sdk-builds
[CI] Enable Linux static SDK and Wasm SDK builds
2025-08-01 16:21:21 -06:00
Jonathan Flat 11d9d4a78e [CI] Enable Linux static SDK and Wasm SDK builds 2025-08-01 14:51:27 -06:00
Jonathan Flat 0c11feadd4 Merge pull request #252 from jrflat/release-mode-testing
Support testing in release mode
2025-07-31 10:11:32 -06:00
Guillaume Lessard 2410aed341 Merge pull request #251 from apple/release/1.6.0
Merge 1.6.x into main
2025-07-31 09:05:02 -07:00
Jonathan Flat 9ec41a667c Support testing in release mode 2025-07-30 18:47:26 -06:00
Guillaume Lessard 9226c72b3a Merge pull request #232 from apple/availability-macros
Replace bespoke availability system
2025-07-30 17:10:32 -07:00
Guillaume Lessard d9d138a88e Merge pull request #250 from glessard/five-nine-required
[gardening] Swift 5.9 is required
2025-07-30 16:08:07 -07:00
Guillaume Lessard 13ad3fe4ac Update copyright dates 2025-07-30 14:29:52 -07:00
Guillaume Lessard 2610d66a52 This package requires Swift 5.9
Accordingly, these conditions would always be true
2025-07-30 14:29:52 -07:00
Guillaume Lessard e0d9cb0638 Merge pull request #249 from glessard/feature-flag-condition
Gate 6.2 features by feature flag
2025-07-30 09:46:08 -07:00
Guillaume Lessard c4fef8b59a Disable non-escapable API by feature flag 2025-07-30 09:21:05 -07:00
Rauhul Varma f97a80426c update readme 2025-07-30 08:53:33 -07:00
Rauhul Varma e5198c2b2d disable 16.0 and 16.1 2025-07-30 08:50:14 -07:00
Rauhul Varma 9a1530813e Replace bespoke availability system
Removes the script based availability system with the experimental
availability macro feature.
2025-07-30 08:40:08 -07:00
Guillaume Lessard b63d24d465 Merge pull request #248 from glessard/updates-1.6.1
Updates for 1.6.1 tag
2025-07-29 23:11:20 -07:00
Guillaume Lessard a717516d69 Merge branch 'main' into updates-1.6.1 2025-07-29 18:50:55 -07:00
Jonathan Flat d89ca1d511 Merge pull request #247 from jrflat/ioring-for-older-kernels
Fix IORing build for older Linux kernels
2025-07-29 19:38:33 -06:00
Jonathan Flat d32abd8c6e Fix warning: will never be executed 2025-07-29 15:35:30 -06:00
Guillaume Lessard d75acaac3a [ci] expand github actions 2025-07-29 14:26:38 -06:00
Jonathan Flat 5fedb102b5 Fix IORing build for older Linux kernel versions 2025-07-29 14:24:17 -06:00
Guillaume Lessard 960067d31a Merge pull request #245 from glessard/update-readme-main
Update README
2025-07-29 11:06:18 -07:00
Guillaume Lessard 0bb855ac35 Merge pull request #244 from glessard/update-readme-1.6.x
Update README
2025-07-29 08:10:23 -07:00
Guillaume Lessard 3f68d42246 Update Readme 2025-07-28 17:42:40 -07:00
Guillaume Lessard c72c758953 Update Readme 2025-07-28 17:41:23 -07:00
Jonathan Flat a067a0751a Merge pull request #242 from jrflat/fix-ioring-static-linux-sdk
Fix IORing static Linux SDK
2025-07-28 14:31:18 -06:00
Jonathan Flat e1191b2ba5 Merge pull request #241 from jrflat/fix-ioring-release-build
Fix IORing release build
2025-07-28 14:30:41 -06:00
Jonathan Flat c7eaf63462 Merge pull request #239 from jrflat/fix-wasi-build
Fix WASI build (dirent, umask, errno and open flag tests)
2025-07-28 12:18:40 -06:00
Jonathan Flat 4f5b5fb40d Fix IORing static Linux SDK 2025-07-28 12:08:37 -06:00
Jonathan Flat 5059730d24 Fix IORing release build 2025-07-28 10:52:35 -06:00
Jonathan Flat 8de80270cb Fix WASI build (dirent, umask, errno and open flag tests) 2025-07-25 14:03:59 -06:00
David Smith 41daa93a5d Merge pull request #235 from apple/merge-1.5.0-into-main
Merge 1.5.0 into main
2025-07-24 22:18:56 +00:00
David Smith 2adb6b41cc Merge branch 'release/1.5.0' into merge-1.5.0-into-main 2025-07-24 14:29:18 -07:00
Guillaume Lessard 6ee9a58c36 Merge pull request #234 from azarovalex/fix-api-docs
Fix API documentation links in README.md
2025-07-14 15:18:35 -07:00
David Smith 7f9dba80cf Merge pull request #208 from apple/david/ioring
Add io_uring support to System
2025-07-12 00:39:04 +00:00
David Smith 08ed962064 Don't abort the test if we can't open /proc/sys/kernel/io_uring_disabled 2025-07-11 23:05:26 +00:00
David Smith 08ea3343a5 Merge branch 'david/ioring' of https://github.com/apple/swift-system into david/ioring 2025-07-11 22:42:41 +00:00
David Smith a66176f518 Only run IORing tests if io_uring support is enabled 2025-07-11 22:42:35 +00:00
David Smith 33b58a8110 Fix excludes harder 2025-07-11 13:44:46 -07:00
David Smith 52d9c99a94 Fix excludes 2025-07-11 13:42:49 -07:00
David Smith b93169b8e2 Work around windows bugs harder 2025-07-11 20:37:23 +00:00
David Smith 9a046498d0 Try adding newlines to the ends of files to work around a compiler bug 2025-07-11 19:23:24 +00:00
David Smith a56bcda3c1 Un-combine conditionals but flip their order. This should fix the Windows build with older compilers 2025-07-11 19:07:04 +00:00
David Smith f7c05e1fb8 Combine platform conditionals 2025-07-11 18:53:55 +00:00
David Smith 7fc787e6ba Move IORing files to a subdirectory 2025-07-11 17:00:32 +00:00
David Smith 779c9ac628 Fix misuse of _CANCEL_ANY, and add support for non-redicated cancellation 2025-07-11 16:50:58 +00:00
David Smith 2f6c4e0f03 Add support for non-IORING_FEAT_SINGLE_MMAP kernels 2025-07-11 16:14:36 +00:00
David Smith d121081c01 More Ubuntu 22 workarounds. This should error at runtime rather than not compiling, since we don't have Linux version checks at compile time 2025-07-10 23:30:42 +00:00
David Smith a6675d7e5c timespec should be compatible here, let's try it to fix the Ubuntu 22 build 2025-07-10 23:22:11 +00:00
David Smith 329c5f59a2 Conditionalize IORing on compiler >= 6.2 2025-07-09 21:17:42 +00:00
David Smith 6dd0eba8e3 Merge branch 'david/ioring' of https://github.com/apple/swift-system into david/ioring 2025-07-09 20:53:28 +00:00
David Smith 4b70ffe375 Fix short submits and also fix the registration ops enum, which somehow stopped compiling overnight 2025-07-09 20:53:23 +00:00
David Smith 8757fae97c Remove some stray commas the API breakage test complains about 2025-07-08 16:57:30 -07:00
David Smith d2b78f801b Remove unneeded defines 2025-07-08 23:53:50 +00:00
David Smith d6687d2bbb Add deleted file back 2025-07-08 16:51:24 -07:00
David Smith 528e7485ba Document completion flags and disable ones we don't currently support 2025-07-08 16:38:21 -07:00
David Smith a6c5a39ca5 Remove the proposal doc 2025-07-08 16:24:28 -07:00
David Smith 55e55c1978 Add test and fix submission queue capacity check 2025-07-08 23:15:17 +00:00
David Smith bc097e91dc Remove more blocking enqueue infrastructure 2025-07-08 22:42:15 +00:00
David Smith 227a38f230 Remove blocking enqueue 2025-07-08 22:41:06 +00:00
David Smith bbe2f1c192 Add doc comments, Span/MutableSpan support, unregistering registered fds, variants of submission operations that don't block, address various TODOs 2025-07-08 00:41:50 +00:00
David Smith e580c13ca8 Merge branch 'david/ioring' of https://github.com/apple/swift-system into david/ioring 2025-07-04 00:11:17 +00:00
David Smith a6149c215e Cleanup, implement buffer unregistering, inline almost everything because we're not ABI stable on Linux 2025-07-04 00:09:19 +00:00
David Smith de2d6e2d39 Conditionalize tests too 2025-07-03 16:17:51 -07:00
David Smith 0d4c6fc971 Fix Musl 2025-07-03 16:12:56 -07:00
David Smith 27ccce55db Conditionalize IORing stuff for Linux 2025-07-03 16:04:52 -07:00
David Smith 321a71c2e9 Expand test coverage 2025-07-03 00:13:29 +00:00
David Smith 131326c8ae Fix tests 2025-07-01 01:02:40 +00:00
Alex Azarov c0273af7e5 Fix API documentation links in README.md 2025-06-28 17:49:11 +02:00
David Smith f91cb6b8de Improve tests. Not quite working but close 2025-06-27 00:39:35 +00:00
David Smith f9c2a2b8e7 Work around io_uring.h in ways that will work on both versions 2025-06-18 23:08:45 +00:00
Guillaume Lessard 61e4ca4b81 Merge pull request #231 from apple/main
Merge main into release/1.5.0
2025-05-28 16:25:04 -07:00
Guillaume Lessard f3154e33ec Merge branch 'release/1.4.0' into release/1.5.0 2025-05-23 15:09:25 -07:00
Guillaume Lessard 99feed67fe Merge pull request #225 from marcprux/main
Add Android imports to tests
2025-05-22 10:07:29 -07:00
Guillaume Lessard 40d22dace6 Merge pull request #230 from owenv/owenv/windows-release-path-parsing
Fix Windows path parsing when the package is built in release configuration
2025-05-22 09:48:39 -07:00
Owen Voorhees 595c862c19 Fix Windows path parsing when the package is built in release configuration
forceWindowsPaths can be used to force Windows path parsing both on and off.
Instead of defaulting it to false in release builds, we should not express any preference
2025-05-21 21:12:58 -07:00
David Smith 3d6cba22b6 Work around compiler bugs harder 2025-04-28 23:03:26 +00:00
David Smith f5b8e02ba7 Merge remote-tracking branch 'origin/main' into david/ioring 2025-04-28 22:33:21 +00:00
David Smith 7e2f797fb4 Fix some errors on newer linux systems 2025-04-28 22:30:00 +00:00
David Smith 3a649e32a6 Fix type of features, and make it clear that Completion is a nested type 2025-04-24 16:39:41 -07:00
Jake Petroules 5695a8831b Transparently add the \\?\ prefix to Win32 calls for extended length path handling
On Windows, there is a built-in maximum path limitation of 260 characters under most conditions. This can be extended to 32767 characters under either of the following two conditions:

- Adding the longPathAware attribute to the executable's manifest AND enabling the LongPathsEnabled system-wide registry key or group policy.
- Ensuring fully qualified paths passed to Win32 APIs are prefixed with \\?\

Unfortunately, the former is not realistic for the Swift ecosystem, since it requires developers to have awareness of this specific Windows limitation, AND set longPathAware in their apps' manifest AND expect end users of those apps to change their system configuration.

Instead, this patch transparently prefixes all eligible paths in calls to Win32 APIs with the \\?\ prefix to allow them to work with paths longer than 260 characters without requiring the caller of System to manually prefix the paths.

See https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation for more info.
2025-04-23 14:52:03 -07:00
David Smith f38d72f310 Nested types, some renames, misc other updates 2025-04-22 16:32:12 -07:00
David Smith a49ba8a8b3 Give flags a default value 2025-04-22 23:20:37 +00:00
David Smith c47779fac0 Try making requests and completions nested types 2025-04-22 23:07:01 +00:00
David Smith 344b3b85f8 Proposal updates 2025-04-21 16:59:39 -07:00
David Smith a98cd3f2da Build fix and rename IOResource 2025-04-21 23:47:00 +00:00
David Smith 3760dc265a Nest IOResource, and update proposal to match 2025-04-21 16:35:08 -07:00
David Smith baa3d62569 API tweak 2025-04-21 23:26:14 +00:00
David Smith ea77ef8a21 Minor cleanup 2025-04-21 23:24:09 +00:00
David Smith 9d325b29ce Change IORingFileSlot and IORingBuffer to be nested types in IORing 2025-04-21 23:23:26 +00:00
David Smith 7798f0c957 Add cancellation support and drop gerunds 2025-04-21 23:18:33 +00:00
Guillaume Lessard 5691e92a4b Merge pull request #227 from apple/enable-windows-ci 2025-04-19 09:59:09 -07:00
Jake Petroules 28ce835363 Enable Windows CI
FileOperationsTestWindows.testPermissions fails on Windows in a container environment with Hyper-V isolated containers; see https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/persistent-storage#permissions for some potentially-relevant information.

Skip it if we detect we're in a container.

Closes #223
2025-04-19 00:23:55 -07:00
David Smith 05eac87c08 It compiles again! 2025-04-18 23:38:43 +00:00
David Smith c029c1bfbd Proposal updates and a minor change to setup flags 2025-04-18 15:22:17 -07:00
David Smith 261ca250fe Centralize on Errno for errors, and work around lifetime compiler crash. There's a second compiler crash still to work around though. 2025-04-18 22:20:09 +00:00
David Smith 014f8b78eb Rename userData to context 2025-04-17 23:36:51 +00:00
David Smith 41f9676907 WIP, crashes the compiler 2025-04-17 23:31:01 +00:00
David Smith d4ca203c09 Most of feature querying and setup flags 2025-04-17 00:26:13 +00:00
David Smith 2f91217c90 Fix a few things I missed 2025-04-16 23:44:21 +00:00
David Smith 27275f843a Merge remote-tracking branch 'refs/remotes/origin/david/ioring' into david/ioring 2025-04-16 23:38:35 +00:00
David Smith b40b09440c Revamp error handling 2025-04-16 23:37:50 +00:00
David Smith 0e652c4d25 Naming updates, cancellation support, IOResources are structs now, other editorial updates 2025-04-04 16:42:33 -07:00
Marc Prud'hommeaux 009b07e140 Add Android imports to tests 2025-03-13 08:59:59 -04:00
Karoy Lorentey 1b8167d354 Merge pull request #222 from apple/github-actions-support
[CI] Add support for GitHub Actions
2025-03-10 14:50:35 -07:00
Mishal Shah 2ac80d6f4e Disable a few checks 2025-03-09 18:29:05 -07:00
David Smith 7fff872441 Add the draft proposal so I can link to it 2025-03-06 12:09:57 -08:00
Mishal Shah d6b40a7284 [CI] Add support for GitHub Actions 2025-03-04 23:22:34 -08:00
David Smith 72c316ba86 Make completions noncopyable again 2025-03-03 23:59:36 +00:00
David Smith 48455a9135 Fix plumbing 2025-03-03 23:04:52 +00:00
David Smith 880ec9086e Add a pointer convenience for getting the user data 2025-03-03 22:51:35 +00:00
David Smith 9ad16c0aae Plumb through userData 2025-03-03 22:37:51 +00:00
David Smith 91155fd527 Plumb error handling through completion consumers 2025-03-03 22:15:32 +00:00
David Smith 49dd7977ca Add a combined "submit and consume" operation 2025-03-03 22:07:28 +00:00
David Smith 5e24673259 Switch from unsafe pointers to FilePaths, using hacks 2025-03-03 21:53:26 +00:00
David Smith d338de1478 Only get one completion if we asked for one completion 2025-02-28 00:49:31 +00:00
David Smith f3b8cc473d Actually consume events we waited for 2025-02-28 00:45:31 +00:00
Guillaume Lessard a34201439c Merge pull request #220 from glessard/1.4.2
[1.4.x] Support for FreeBSD and OpenBSD
2025-02-18 15:35:23 -08:00
Guillaume Lessard 12573bfb88 Merge branch 'main' into 1.4.2 2025-02-17 17:03:43 -08:00
Guillaume Lessard 3a1b4a8e05 Merge pull request #219 from glessard/1.4.1
[1.4.x] Use GetTempPathW for better compatibility
2025-02-17 14:04:33 -08:00
Guillaume Lessard d9b03016dc Merge pull request #218 from glessard/1.4.1
[1.4.x] Use GetTempPathW for better compatibility
2025-02-17 11:52:53 -08:00
xuty f18ed75481 Use GetTempPathW for better compatibility 2025-02-17 11:43:11 -08:00
David Smith d895f2a828 Revert "Reapply "Turn on single issuer as an experiment""
This reverts commit 283e8d6b7b.
2025-02-14 18:27:17 +00:00
David Smith 283e8d6b7b Reapply "Turn on single issuer as an experiment"
This reverts commit 901f4c80c4.
2025-02-14 18:26:31 +00:00
David Smith 901f4c80c4 Revert "Turn on single issuer as an experiment"
This reverts commit 0064649631.
2025-02-14 18:25:46 +00:00
David Smith 0064649631 Turn on single issuer as an experiment 2025-02-14 18:24:09 +00:00
David Smith 5ba137703c Dubious approach to this, but I want to try it out a bit 2025-02-13 23:43:19 +00:00
David Smith 6983196ad6 Add unlinkAt support 2025-02-13 23:31:06 +00:00
David Smith a22e5f6858 Add a version of registerBuffers that isn't varargs 2025-02-13 22:09:42 +00:00
David Smith 0c6ef16ca9 Fix type 2025-02-12 23:45:18 +00:00
David Smith 7f6e673750 Adjust registered resources API 2025-02-12 23:43:29 +00:00
David Smith 74366c3341 Improve submit API 2025-02-12 20:18:51 +00:00
David Smith 5bfed03c97 Switch to static methods for constructing requests 2025-02-11 23:27:03 +00:00
David Smith d4ca4129a0 Some renaming, and implement linked requests 2025-02-11 23:01:33 +00:00
David Smith a396967e3a More registration tweaks 2025-02-11 22:38:01 +00:00
David Smith bb03f0fba3 Redesign registered resources API 2025-02-11 22:33:10 +00:00
David Smith 02481e0daa More import fixes 2025-02-11 21:06:16 +00:00
David Smith 7107a570b4 Fix import visibility 2025-02-11 21:01:49 +00:00
Guillaume Lessard b1b7b60a55 Merge pull request #215 from 3405691582/openbsd
OpenBSD support.
2025-02-10 14:41:18 -08:00
Guillaume Lessard 2228d64644 Merge pull request #213 from Steelskin/fabrice/cmake-install-paths
[cmake] Install libraries in standard directories
2025-02-07 11:00:22 -08:00
David Smith fdbcecab0b Eliminate internal locking and add multiple consume support 2025-02-06 00:42:21 +00:00
David Smith e5fdf9ea96 Remove managed abstractions for now 2025-02-06 00:41:30 +00:00
3405691582 3b053e055b ManagedBuffer.capacity is unavailable on OpenBSD.
`.capacity` is backed by malloc introspection (`malloc_size`), which is
not available on all platforms. The workaround is straightforward here,
thankfully: instead, use the minimum capacity already specified.
2025-02-04 19:44:35 -05:00
3405691582 90702d6d15 Typealias system_DIRPtr for OpenBSD. 2025-02-04 19:44:32 -05:00
Guillaume Lessard 849d005b2b Merge pull request #211 from ShaftUI/temp-path-w
[Windows] Use GetTempPathW in _getTemporaryDirectory for better compatibility
2025-01-30 15:00:27 -08:00
Guillaume Lessard 8790e47013 Merge pull request #214 from michael-yuji/freebsd-wip
Add FreeBSD errno and open options
2025-01-29 15:50:13 -08:00
Guillaume Lessard f27874d762 Merge pull request #209 from ADKaster/install-interface
CSystem: Set build and install interfaces on included headers
2025-01-28 13:49:12 -08:00
Michael Chiu df7341ee2b fix cmake x86_64 build 2025-01-26 21:29:19 -08:00
Michael Chiu 4d735a6631 Add FreeBSD errnos and open options 2025-01-26 21:29:13 -08:00
Fabrice de Gans bebd7c146e [cmake] Install libraries in standard directories
Previously, libs were installed under `lib/swift/${os}`. They should be
installed in the default library directory for the relevant target
system.
In addition, swiftmodules were installed in the older layout format.
This changes to use the standard modern layout format for swiftmodules.
2025-01-23 11:45:17 -08:00
michael-yuji 4fa2a719c5 Merge pull request #212 from michael-yuji/freebsd-wip
Guard errnos not available on FreeBSD
2025-01-17 21:52:07 -08:00
Michael Chiu 0d824eee86 refactor ifdef in test 2025-01-17 15:06:28 -08:00
Michael Chiu eb566de2d3 Fix tests on FreeBSD 2025-01-17 14:43:40 -08:00
Michael Chiu a4fb6cb206 Keep order consistent 2025-01-17 14:43:34 -08:00
Michael Chiu 7e73a336fb Guard errnos not available on FreeBSD 2025-01-17 14:30:51 -08:00
xuty 85b83fddb1 Use GetTempPathW for better compatibility 2024-12-17 15:13:15 +08:00
David Smith 55fd6e7150 Add support for timeout-on-wait to IORing, don't have tests yet 2024-12-12 01:20:24 +00:00
David Smith 7ea32aefce More refactoring, and working timeout support on ManagedIORing 2024-12-11 23:00:50 +00:00
David Smith ef94a37193 Refactoring, and give up on resources being noncopyable structs 2024-12-05 03:11:11 +00:00
Guillaume Lessard 61a2af5e8b Merge pull request #210 from ADKaster/remove-nbsp
Internals: Remove non-breaking spaces from Windows syscall adapter
2024-11-22 19:38:54 -05:00
Andrew Kaster eb3b1fa54b Internals: Remove non-breaking spaces from Windows syscall adapter
This was causing a warning with Swift 6.0.2
2024-11-21 15:03:28 -07:00
Andrew Kaster f1393b76f3 CSystem: Set build and install interfaces on included headers 2024-11-21 14:48:57 -07:00
David Smith f369347b73 Fix mismerge 2024-10-28 17:25:31 -07:00
David Smith 1a3e37d791 Fix mismerge 2024-10-28 17:24:46 -07:00
David Smith a9f92a6e31 Delete stray Package.resolved changes 2024-10-28 17:23:25 -07:00
David Smith 6f793cfe60 Merge branch 'main' into david/ioring 2024-10-29 00:21:42 +00:00
David Smith fcb0b69df6 Merge branch 'main' into david/ioring 2024-10-28 17:20:36 -07:00
David Smith 822e4814d1 Adopt isolation parameters 2024-10-28 23:49:37 +00:00
David Smith 32966f975d It builds again! With some horrible hacks 2024-10-28 23:43:59 +00:00
David Smith 10c070abd6 WIP, more ~Copyable adoption 2024-10-28 20:00:07 +00:00
David Smith 60299362ed One more noncopyable struct 2024-10-24 21:27:22 +00:00
David Smith baab9b26b7 Starting to move to noncopyable structs, and away from swift-atomics 2024-10-24 21:21:07 +00:00
Guillaume Lessard fbd61a676d Merge pull request #207 from glessard/merge-1.4.0-into-main
Merge 1.4.0 into main
2024-10-18 22:39:45 -07:00
Guillaume Lessard f21f6a8866 Merge branch 'release/1.4.0' into merge-1.4.0-into-main
# Conflicts:
#	.gitignore
#	.swiftci/5_10_ubuntu2204
#	.swiftci/5_8_ubuntu2204
#	.swiftci/5_9_ubuntu2204
#	.swiftci/nightly_6_0_macos
#	.swiftci/nightly_6_0_ubuntu2204
#	.swiftci/nightly_main_macos
#	.swiftci/nightly_main_ubuntu2204
#	.swiftci/nightly_main_windows
#	Package.swift
#	Sources/System/FileOperations.swift
#	Sources/System/FilePath/FilePath.swift
#	Sources/System/Internals/WindowsSyscallAdapters.swift
2024-10-17 17:24:38 -07:00
Guillaume Lessard c8a44d836f Merge pull request #206 from glessard/1.4.0-readme
[1.4.0] Updates to the README file
2024-10-17 16:12:10 -07:00
Guillaume Lessard b80d743dab Update README.md 2024-10-17 15:52:41 -07:00
Guillaume Lessard eeeb81d0cd [readme] update usage example, reword stability 2024-10-17 15:14:38 -07:00
Guillaume Lessard 234e15320e Merge pull request #204 from glessard/1.4.0-ci-adjustment
[1.4.0] Swift 5.8 is not supported on this branch
2024-10-17 15:01:46 -07:00
Guillaume Lessard 154cbf7c95 Merge pull request #205 from glessard/1.4.0-pipe-correction
[windows] expose pipe’s buffer size parameter
2024-10-17 14:57:49 -07:00
Guillaume Lessard 3f4e7cb45c [windows] expose pipe’s buffer size parameter 2024-10-17 14:31:37 -07:00
Guillaume Lessard 11d481252d [1.4.0] Updates to the README file 2024-10-17 13:17:08 -07:00
Guillaume Lessard 2e8f58ac41 [1.4.0] Swift 5.8 is not supported on this branch 2024-10-17 08:49:29 -07:00
Guillaume Lessard 5cd7eade6d Merge pull request #203 from glessard/systemstring-tweaks-1.4.0
[1.4.0] SystemString consistency improvements
2024-10-16 23:25:29 -07:00
Guillaume Lessard b2d4917ebe Update copyright notices 2024-10-16 23:09:09 -07:00
Guillaume Lessard d96435c72b Rename withSystemChars
- `withNullTerminatedSystemChars` makes it clear that the null-termination is included. Operations where the null-termination is included should be obvious.
2024-10-16 23:09:09 -07:00
Guillaume Lessard 95784d018f Fix behaviour of withCodeUnits()
- The original implementation includes a trailing zero with the full collection, but the implementation for a slice does not. As a result, given a `let s: SystemString`, `s.string` was not equal to `s[…].string`
2024-10-16 23:09:09 -07:00
Guillaume Lessard 448bef7c38 Test SystemString.string property consistency 2024-10-16 23:09:09 -07:00
Guillaume Lessard 69e737de3d Generate SystemString.string consistently
- SystemString.string and Slice<SystemString>.string should be generated in the same manner. Now they are.
2024-10-16 23:09:09 -07:00
Guillaume Lessard afeecb6c28 Merge pull request #201 from glessard/32-are-too-few-bits-1.4.0
[1.4.0] fix a 32-bit overflow issue
2024-10-16 18:30:16 -07:00
Guillaume Lessard 69eee996ac Merge pull request #202 from glessard/platform-support-1.4.0
[1.4.0] cherry-pick platform support changes
2024-10-16 18:29:59 -07:00
Finagolfin 209dfeacb8 Import new Android overlay
Use Bionic module instead where possible
2024-10-16 18:22:35 -07:00
Finagolfin b2b60a6b94 Android: DIR* is an OpaquePointer in Bionic too 2024-10-16 18:22:19 -07:00
Max Desiatov e11703d915 Add support for WASILibc module (#159)
Quoting the [wasi.dev landing page](https://wasi.dev):
> The WebAssembly System Interface (WASI) is a group of standard API specifications for software compiled to the W3C WebAssembly (Wasm) standard. WASI is designed to provide a secure standard interface for applications that can be compiled to Wasm from any language, and that may run anywhere—from browsers to clouds to embedded devices.

Currently support for WASI in Swift is based on [`wasi-libc`](https://github.com/WebAssembly/wasi-libc).

Adding support for `wasi-libc` mostly amounted to excluding unsupported errnos, adding TLS dictionary storage shim for single-threaded environment, and adding constants in C headers for macros that Clang importer currently doesn't support.

Co-authored-by: Guillaume Lessard <guillaume.lessard@apple.com>

# Conflicts:
#	Sources/System/FileOperations.swift
#	Sources/System/Internals/Syscalls.swift
2024-10-16 18:22:19 -07:00
Guillaume Lessard 8df901cb24 fix a 32-bit overflow issue
- ensures compatibility with watchOS
2024-10-16 17:57:36 -07:00
Guillaume Lessard 938fda53e2 Merge pull request #200 from glessard/private-aeic-init-removal-1.4.0
[1.4.0] backport #191
2024-10-16 17:41:50 -07:00
Guillaume Lessard e7ffa45882 Remove private-and-@_aEIC initializers
These were just passthroughs.
2024-10-16 17:38:24 -07:00
Guillaume Lessard 607542a559 Merge pull request #198 from glessard/1.4.0-backport-158&176 2024-10-16 17:28:28 -07:00
Guillaume Lessard b9e4d2b2ba Remove more accidentally public functions 2024-10-16 17:03:59 -07:00
Guillaume Lessard 473b493ab0 Merge pull request #199 from glessard/1.4.0-backport-193
Add support for macCatalyst
2024-10-16 14:15:25 -07:00
George Barnett 9eb1f34cbf Add support for macCatalyst
Building swift-system for macCatalyst fails as there is no import of the
Darwin module.

# Conflicts:
#	Package.swift
2024-10-16 14:00:47 -07:00
Guillaume Lessard 7a18b4bf34 Merge pull request #193 from glbrntt/mac-catalyst
Add support for macCatalyst
2024-10-16 13:57:03 -07:00
Alastair Houghton 6c64372b85 [Windows] Add a comment to explain the O_RDONLY/O_WRONLY/O_RDWR logic.
The values of these flags on Windows do not overlap, and more
particularly, `O_RDONLY` is actually zero on Windows, which means we
cannot test for it by AND-ing.
2024-10-14 16:01:01 -07:00
Alastair Houghton 3a4e2f8071 [Windows] Fix tests.
We need to use `@testable` when importing `SystemPackage` in order to
let us test the `internal` functions.

Also, use `NUL` instead of `/dev/null`, and generate random bytes in a
file instead of reading from `/dev/random`.
2024-10-14 16:01:01 -07:00
Alastair Houghton 53471ce33b [Windows] Fix a problem with opening files read only.
`_O_RDONLY` is zero, so we can't test for it by AND-ing.
2024-10-14 16:01:01 -07:00
Alastair Houghton f1d7eb52c6 Remove accidentally public functions.
These can't be new API as they haven't been reviewed.
2024-10-14 16:01:01 -07:00
Alastair Houghton cf7530848e [Linux] Glibc's DIR doesn't get imported into Swift.
Swift ends up with OpaquePointer instead of a typed pointer.

rdar://125087707
2024-10-14 15:59:36 -07:00
Alastair Houghton 5ae5d5a3af Refactor FilePathTemp, add tests for permission code.
Broke `FilePathTemp.swift` into separate files for POSIX and
Windows.

Added tests for permissions code on Windows.

Added leading underscores to some function names.

Made some other functions `fileprivate`.

rdar://125087707
2024-10-14 15:59:36 -07:00
Alastair HoughtonandKaroy Lorentey bcc7f6d569 Update Sources/System/FilePath/FilePathTemp.swift
Co-authored-by: Karoy Lorentey <klorentey@apple.com>
2024-10-14 15:59:36 -07:00
Alastair Houghton e293300430 Map mode bits to Windows ACLs.
This adds support for mapping POSIX-style mode bits to Windows ACLs when
calling `open()` or `mkdir()`.

rdar://125087707
2024-10-14 15:59:36 -07:00
Alastair Houghton 4cafcc96f6 Changes after comments from Saleem.
Use idiomatic Swift notation, not `Optional<Bool>`.

Prefer Win32 APIs to UCRT APIs.

rdar://125087707
2024-10-14 15:59:36 -07:00
Alastair Houghton 85de4e51e2 Use the proper temporary directory on Darwin.
It seems we can get the temporary directory from confstr().

rdar://125087707
2024-10-14 15:59:36 -07:00
Alastair Houghton d4e2b09c37 Fix swift-system to work on Windows.
The swift-system tests were not passing, for various reasons, mostly
to do with path related confusion.

As part of this, add a function to create a temporary directory, as that
was one of the problems.

Also add Windows support for pipe() and ftruncate(), which was missing.

rdar://125087707
2024-10-14 15:59:36 -07:00
Guillaume Lessard 5ea5b2e89a Merge pull request #197 from lorentey/merge-1.3.0→1.4.0
Merge release/1.3.0 to release/1.4.0
2024-10-14 11:02:40 -07:00
Karoy Lorentey 8564f96d1f Merge branch 'release/1.3.0' into release/1.4.0
# Conflicts:
#	.gitignore
#	.swiftci/5_10_ubuntu2204
#	.swiftci/5_8_ubuntu2204
#	.swiftci/5_9_ubuntu2204
#	.swiftci/nightly_6_0_macos
#	.swiftci/nightly_6_0_ubuntu2204
#	.swiftci/nightly_main_macos
#	.swiftci/nightly_main_ubuntu2204
#	.swiftci/nightly_main_windows
#	Package.swift
#	Sources/System/FilePath/FilePath.swift
#	Sources/System/Internals/CInterop.swift
2024-09-19 16:50:34 -07:00
Karoy Lorentey b85a788897 Merge pull request #196 from lorentey/metadata-updates
[1.4] Metadata updates
2024-09-19 15:31:34 -07:00
Karoy Lorentey 88a60e08b3 Update README
- Clarify swift-system’s stance on cross-platform abstractions. Stop using the term “multi-platform”.
- Expand source stability section.
- Add a section on our branching strategy.
- Link to the Code of Conduct document.
2024-09-19 13:01:48 -07:00
Karoy Lorentey 4c612a1e29 Bump required toolchain version to 5.9. Sanitize Package manifest
- Don’t define _CRT_SECURE_NO_WARNINGS outside Windows
- Let all targets share the same settings
2024-09-19 12:57:57 -07:00
Karoy Lorentey 603c451818 Add code of conduct 2024-09-19 12:49:08 -07:00
George Barnett 2662793bd6 Add support for macCatalyst
Building swift-system for macCatalyst fails as there is no import of the
Darwin module.
2024-08-19 10:20:12 +01:00
Guillaume Lessard d581098eeb Merge pull request #191 from glessard/private-aeic-init-removal
Remove private-and-@_aEIC initializers
2024-07-31 16:56:38 -07:00
Guillaume Lessard edbc9e4fdc Remove private-and-@_aEIC initializers
These were just passthroughs.
2024-07-31 16:30:25 -07:00
Guillaume Lessard d2ba781702 Merge pull request #190 from glessard/enforce-file-path-invariants-in-decode-1.3.x
Cherry-pick: ensure invariants are enforced when decoding
2024-07-23 12:42:13 -07:00
Stephen Canon a1f77d0e1a Cherry-pick: ensure invariants are enforced when decoding
Ensure that FilePath and SystemString's invariants are enforced when decoding.

Cherry-pick of merge-commit 9c42c54644
from PR #189

# Conflicts:
#	Sources/System/FilePath/FilePath.swift
2024-07-23 11:26:26 -07:00
Stephen Canon 9c42c54644 Merge pull request #189 from stephentyrone/enforce-file-path-invariants-in-decode
Ensure that FilePath and SystemString's invariants are enforced when …
2024-07-17 14:49:19 -04:00
Stephen Canon 3841a7531f Add some notes explaining what invariants are violated. 2024-07-17 13:49:15 -04:00
Stephen Canon 3b43b391b5 Add some comments and remove leftover WIP noise. 2024-07-17 12:49:37 -04:00
Stephen Canon c64775ef71 Another invariant to check 2024-07-17 12:25:34 -04:00
Stephen Canon 4c96faa6d8 Insure that FilePath and SystemString's invariants are enforced when decoding. 2024-07-17 12:14:43 -04:00
Guillaume Lessard 19e7f0fdd4 Merge pull request #187 from finagolfin/droid
Import new Android overlay
2024-07-08 17:20:28 -07:00
Finagolfin 02811ea6b4 Import new Android overlay
Use Bionic module instead where possible
2024-07-08 17:53:39 +05:30
Guillaume Lessard 2ce971a831 Merge pull request #155 from glessard/system-string-api-consistency
SystemString api consistency improvements
2024-07-05 14:26:21 -07:00
Guillaume Lessard 80788529b5 Merge pull request #170 from glessard/platform-flags
Make a platform-specific flag explicitly platform-specific
2024-07-05 14:24:12 -07:00
Guillaume Lessard 05fb1f1142 Merge pull request #178 from apple/dev/merge-1.3.0-back-to-main
[gardening] Merge the release/1.3.0 branch back into main
2024-07-03 16:22:44 -07:00
Guillaume Lessard 8d2dda76fa Merge pull request #186 from futurejones/add-riscv64-support
add support for riscv64
2024-06-18 16:21:38 -07:00
Neil Jones c1789e0525 add support for riscv64 2024-06-18 10:45:08 +09:00
Guillaume Lessard 6a9e38e7bd Merge pull request #185 from glessard/disfavoredOverload-1.3.0
[1.3.x] Disfavor String.init(platformString: UnsafePointer<CChar>)
2024-06-07 17:43:21 -07:00
Yuta Saito 848a927122 Merge pull request #184 from kateinoigakukun/katei/suppress-cmakelists-warning-1.4
[1.4] Suppress unhandled CMakeLists.txt warning by SwiftPM
2024-06-07 11:46:19 +09:00
Guillaume Lessard 2b30f8820c Merge pull request #183 from kateinoigakukun/katei/suppress-cmakelists-warning-1.3
[1.3] Suppress unhandled CMakeLists.txt warning by SwiftPM
2024-06-06 13:44:13 -07:00
Yuta Saito 318d2159d1 Merge pull request #182 from kateinoigakukun/katei/suppress-cmakelists-warning
Suppress unhandled CMakeLists.txt warning by SwiftPM
2024-06-06 03:08:41 +09:00
Yuta Saito 1a8d472f35 Suppress unhandled CMakeLists.txt warning by SwiftPM 2024-06-05 18:06:54 +00:00
Yuta Saito f9d6b48027 Suppress unhandled CMakeLists.txt warning by SwiftPM 2024-06-05 18:05:57 +00:00
Karoy Lorentey d82bccbb17 Merge pull request #164 from lorentey/retarget-to-1.4.0
Retarget pending changes to 1.4.0
2024-06-05 09:15:44 -07:00
Yuta Saito 9c17c8562d Suppress unhandled CMakeLists.txt warning by SwiftPM 2024-06-03 02:15:29 +00:00
Guillaume Lessard 0d6be7ac22 Merge branch 'release/1.3.0'
# Conflicts:
#	.gitignore
#	.swiftci/5_10_ubuntu2204
#	.swiftci/5_8_ubuntu2204
#	.swiftci/5_9_ubuntu2204
#	.swiftci/nightly_6_0_macos
#	.swiftci/nightly_6_0_ubuntu2204
#	.swiftci/nightly_main_macos
#	.swiftci/nightly_main_ubuntu2204
#	.swiftci/nightly_main_windows
#	Package.swift
#	Sources/System/Internals/CInterop.swift
#	Sources/System/Internals/Constants.swift
#	Sources/System/Internals/Exports.swift
#	Sources/System/Internals/Syscalls.swift
#	Tests/SystemTests/FileOperationsTest.swift
2024-05-16 11:51:10 -07:00
Karoy Lorentey f9266c8518 Merge pull request #177 from lorentey/fix-cmake
[1.3][CMake] Restore to working order on Apple platforms
2024-05-15 14:48:03 -07:00
Karoy Lorentey b7dc8e8e41 [CMake] Restore to working order on Apple platforms 2024-05-15 14:30:14 -07:00
Guillaume Lessard b642f54526 Merge pull request #175 from glessard/32-are-too-few-bits
fix a 32-bit overflow issue
2024-05-14 11:32:44 -07:00
Alastair Houghton 36987d6d37 Merge pull request #176 from al45tair/remove-unintended-public
Remove unintentional public functions and fix a couple of Windows issues.
2024-05-14 14:52:12 +01:00
Alastair Houghton 082adfe732 [Windows] Add a comment to explain the O_RDONLY/O_WRONLY/O_RDWR logic.
The values of these flags on Windows do not overlap, and more
particularly, `O_RDONLY` is actually zero on Windows, which means we
cannot test for it by AND-ing.
2024-05-14 14:42:57 +01:00
Alastair Houghton abc0a6d26f [Windows] Fix tests.
We need to use `@testable` when importing `SystemPackage` in order to
let us test the `internal` functions.

Also, use `NUL` instead of `/dev/null`, and generate random bytes in a
file instead of reading from `/dev/random`.
2024-05-13 15:13:31 +01:00
Alastair Houghton c3559ecd61 [Windows] Fix a problem with opening files read only.
`_O_RDONLY` is zero, so we can't test for it by AND-ing.
2024-05-13 14:18:17 +01:00
Alastair Houghton 8e09ede76d Remove accidentally public functions.
These can't be new API as they haven't been reviewed.
2024-05-13 11:19:43 +01:00
Guillaume Lessard 25c4b1ad75 fix a 32-bit overflow issue
- ensures compatibility with watchOS
2024-05-12 14:07:11 -07:00
Guillaume Lessard 7d45e0dd46 Update README.md to refer to 1.3.0 2024-05-12 11:40:14 -07:00
Karoy Lorentey aac7f54e89 Merge pull request #174 from lorentey/codeowners
Add CODEOWNERS
2024-05-10 17:17:48 -07:00
Karoy Lorentey 62e62b3a7c Add CODEOWNERS 2024-05-10 17:10:08 -07:00
Guillaume Lessard ab09f04cfe Merge pull request #173 from lorentey/codeowners-1.3.0
Add CODEOWNERS
2024-05-10 17:07:55 -07:00
Karoy Lorentey a6fd8ba9ba Add CODEOWNERS 2024-05-10 17:06:59 -07:00
Karoy Lorentey 0cf079efea Add CODEOWNERS 2024-05-10 17:05:37 -07:00
Mishal Shah 3433699e6e [CI] Remove support for Swift 5.7 2024-05-10 16:32:21 -07:00
Mishal Shah 52f603c6b3 [CI] Remove support for Swift 5.7 2024-05-10 16:31:46 -07:00
Mishal Shah d18980c960 [CI] Remove support for Swift 5.7 2024-05-10 16:30:41 -07:00
Mishal Shah 08800445eb Add support for Swift CI on release/1.4.0 2024-05-10 16:27:47 -07:00
Guillaume Lessard de1f8bce5e Merge pull request #172 from glessard/visionOS-support-for-1.3.0
[1.3.0] visionOS support for 1.3.0
2024-05-10 16:23:53 -07:00
Mishal Shah 0368ce547b Add support for Swift CI on release/1.3.0 2024-05-10 16:18:08 -07:00
Guillaume Lessard 7b14e48d0d Remove the repeated list of Darwin-based platforms
Replaced with a constant defined in the package manifest.
2024-05-10 16:09:22 -07:00
Guillaume Lessard c456f4186e Change the package manifest to support visionOS 2024-05-10 16:02:32 -07:00
Karoy Lorentey ec395a7aa2 Merge pull request #171 from lorentey/require-5.8
[1.3.0] Require Swift 5.8
2024-05-10 15:59:40 -07:00
Karoy Lorentey f1f59e148f Update gitignore 2024-05-10 15:55:04 -07:00
Karoy Lorentey 37a5bbb965 Require Swift 5.8 or better 2024-05-10 15:54:56 -07:00
Guillaume Lessard d8c0e24651 Merge pull request #169 from glessard/manifest-fix
Improved compatibility for visionOS support
2024-05-10 15:42:15 -07:00
Karoy Lorentey f07d14ddb1 Merge pull request #168 from glessard/cherry-pick-pr148
Cherry-pick changes from PR148
2024-05-10 15:41:26 -07:00
Guillaume Lessard 63b05e24e8 Improved compatibility for visionOS support 2024-05-10 15:37:04 -07:00
Guillaume Lessard b0e2a510ed Make a platform-specific flag explicitly platform-specific 2024-05-10 15:28:43 -07:00
Guillaume LessardandFinagolfin 9620c1d30e Cherry-pick changes from PR148
Co-authored-by: Finagolfin <finagolfin@tuta.io>
2024-05-09 22:24:04 -07:00
Guillaume LessardandHiroshi Yamauchi c7259554b5 Cherry-pick changes from PR151
Co-authored-by: Hiroshi Yamauchi <hjyamauchi@gmail.com>
2024-05-09 22:10:26 -07:00
Guillaume LessardandMax Desiatov c3a7235bf7 Cherry-pick changes from PR133
Co-authored-by: Max Desiatov <m_desiatov@apple.com>
2024-05-09 19:10:58 -07:00
Guillaume Lessard e5a56da50e Cherry-pick changes from PR154 2024-05-09 16:03:48 -07:00
Karoy Lorentey 73baf1113d Retarget pending changes to 1.4.0
We decided to spend the 1.3.0 version number on a small interim release; retarget the currently pending changes to 1.4.0.
2024-05-09 14:31:11 -07:00
Guillaume Lessard cf5e688e70 Merge pull request #162 from finagolfin/droid
Android: DIR* is an OpaquePointer in Bionic too
2024-05-09 09:31:47 -07:00
Guillaume Lessard 93d600b5c9 Merge pull request #161 from jmschonfeld/string-init-ambiguity
Disfavor String.init(platformString: UnsafePointer<CChar>)
2024-05-09 09:26:56 -07:00
Finagolfin 7fe8e6cfc2 Android: DIR* is an OpaquePointer in Bionic too 2024-05-09 19:29:36 +05:30
Mishal Shah 84077b3b4b Add Swift CI Support 2024-05-08 15:21:09 -07:00
Alastair Houghton 027c936a26 Merge pull request #158 from al45tair/eng/PR-125087707
Fix swift-system to work on Windows.
2024-05-08 16:13:21 +01:00
Alastair Houghton f5ad5e57fb [Linux] Glibc's DIR doesn't get imported into Swift.
Swift ends up with OpaquePointer instead of a typed pointer.

rdar://125087707
2024-05-08 16:09:56 +01:00
Alastair Houghton 2357d6932c Refactor FilePathTemp, add tests for permission code.
Broke `FilePathTemp.swift` into separate files for POSIX and
Windows.

Added tests for permissions code on Windows.

Added leading underscores to some function names.

Made some other functions `fileprivate`.

rdar://125087707
2024-05-08 16:09:56 +01:00
Alastair HoughtonandKaroy Lorentey 33773a8eb9 Update Sources/System/FilePath/FilePathTemp.swift
Co-authored-by: Karoy Lorentey <klorentey@apple.com>
2024-05-08 16:09:56 +01:00
Alastair Houghton 21638a06b1 Map mode bits to Windows ACLs.
This adds support for mapping POSIX-style mode bits to Windows ACLs when
calling `open()` or `mkdir()`.

rdar://125087707
2024-05-08 16:09:56 +01:00
Alastair Houghton ec7d406cd4 Changes after comments from Saleem.
Use idiomatic Swift notation, not `Optional<Bool>`.

Prefer Win32 APIs to UCRT APIs.

rdar://125087707
2024-05-08 16:09:56 +01:00
Alastair Houghton c6456a9c03 Use the proper temporary directory on Darwin.
It seems we can get the temporary directory from confstr().

rdar://125087707
2024-05-08 16:09:56 +01:00
Alastair Houghton cfd3f9da90 Fix swift-system to work on Windows.
The swift-system tests were not passing, for various reasons, mostly
to do with path related confusion.

As part of this, add a function to create a temporary directory, as that
was one of the problems.

Also add Windows support for pipe() and ftruncate(), which was missing.

rdar://125087707
2024-05-08 16:09:54 +01:00
Jeremy Schonfeld dd45c80062 Disfavor String.init(platformString: UnsafePointer<CChar>) 2024-05-02 13:25:04 -07:00
Max DesiatovandGuillaume Lessard 40b6b0ef8c Add support for WASILibc module (#159)
Quoting the [wasi.dev landing page](https://wasi.dev):
> The WebAssembly System Interface (WASI) is a group of standard API specifications for software compiled to the W3C WebAssembly (Wasm) standard. WASI is designed to provide a secure standard interface for applications that can be compiled to Wasm from any language, and that may run anywhere—from browsers to clouds to embedded devices.

Currently support for WASI in Swift is based on [`wasi-libc`](https://github.com/WebAssembly/wasi-libc).

Adding support for `wasi-libc` mostly amounted to excluding unsupported errnos, adding TLS dictionary storage shim for single-threaded environment, and adding constants in C headers for macros that Clang importer currently doesn't support.

Co-authored-by: Guillaume Lessard <guillaume.lessard@apple.com>
2024-04-30 17:11:39 +01:00
Guillaume Lessard dae787c199 Merge pull request #148 from finagolfin/droid
Android: update pread/pwrite for nullability annotations in NDK 26
2024-03-19 18:23:38 -07:00
Guillaume Lessard 5ca37e7d39 Android: more targeted approach to unusual nullabilities 2024-03-11 09:10:11 -07:00
Guillaume Lessard 14597334dc [test] test reading and writing empty, nil-based buffers 2024-03-08 16:28:11 -08:00
Guillaume Lessard 403776dc2a Merge pull request #152 from noahpistilli/visionPro
Add support for visionOS
2024-03-08 14:54:35 -08:00
Guillaume Lessard 6609a401b9 Update copyright notices 2024-03-08 12:16:44 -08:00
Guillaume Lessard 17e9790792 Rename withSystemChars
- `withNullTerminatedSystemChars` makes it clear that the null-termination is included. Operations where the null-termination is included should be obvious.
2024-03-08 12:16:43 -08:00
Guillaume Lessard def7b1a70c Fix behaviour of withCodeUnits()
- The original implementation includes a trailing zero with the full collection, but the implementation for a slice does not. As a result, given a `let s: SystemString`, `s.string` was not equal to `s[…].string`
2024-03-08 12:13:04 -08:00
Guillaume Lessard c86758849a Test SystemString.string property consistency 2024-03-08 12:13:04 -08:00
Guillaume Lessard afb7fa4eef Generate SystemString.string consistently
- SystemString.string and Slice<SystemString>.string should be generated in the same manner. Now they are.
2024-03-08 12:13:04 -08:00
Sketch f59a0b73ce Add support for visionOS 2024-03-08 10:39:54 -05:00
Guillaume Lessard 8441d4a310 Merge pull request #154 from glessard/system-string-collection-fix 2024-03-07 18:20:02 -08:00
Guillaume Lessard adca1f70b1 Fix SystemString.withCSIA()
- The original implementation simply forwarded to the underlying `nullTerminatedStorage`, which contains one element – a null terminator – more than the actual `String`.
- This isn’t in keeping with the sperit of `withContiguousStorageIfAvailable()`, which should present exactly the elements of the collection.
2024-03-07 15:15:56 -08:00
Saleem Abdulrasool cc1962b882 Merge pull request #151 from hjyamauchi/arm64
Support Windows ARM64
2024-02-14 07:54:19 -08:00
Hiroshi Yamauchi 6b15689813 Support Windows ARM64 2024-02-13 10:32:39 -08:00
Guillaume Lessard 51f6be041f Merge pull request #149 from Kyle-Ye/optimize/doc
Enable Swift Package Index documentation and add API doc link
2024-02-02 15:56:58 -08:00
KyleandMax Desiatov e49d2b9bd2 Update .spi.yml
Co-authored-by: Max Desiatov <m_desiatov@apple.com>
2024-01-22 17:23:31 +08:00
Kyle c6b2119c81 Enable SPI documentation and add API doc link 2024-01-22 17:00:46 +08:00
Guillaume Lessard c2e8f24c7c avoid passing null pointer to pread() or pwrite() 2024-01-04 17:53:38 -08:00
Finagolfin 5c3617b9e9 Android: update pread/pwrite for nullability annotations in NDK 26 2023-11-24 19:01:31 +05:30
Guillaume Lessard 9a812b5fef Merge pull request #147 from glessard/availability 2023-10-13 22:11:51 -07:00
Guillaume Lessard 882466a730 apply missing availability attributes to Mach.Port 2023-10-13 18:55:23 -07:00
Guillaume Lessard 11f1c6da5a Merge pull request #146 from glessard/availability
Update availability declarations for swift-system 1.1.0 API
2023-10-13 18:53:06 -07:00
Guillaume Lessard b92be8a02a Update availability declarations for swift-system 1.1.0 API 2023-10-13 10:21:57 -07:00
Guillaume Lessard c81d5f35e1 Merge pull request #145 from glessard/reenable-mach-port 2023-10-12 19:40:03 -07:00
Guillaume Lessard fb0efe832c [gardening] finish cleaning up old test files
This should have been removed alongside XCTestManifests.swift
2023-10-12 15:02:31 -07:00
Guillaume Lessard 495f729347 [noncopyability] explicitly prevent a capture
This may be needed because of a bug involving resilient structs.
2023-10-12 15:01:08 -07:00
Guillaume Lessard 7654f14f8c [gardening] add some more availability annotations 2023-10-11 14:28:43 -07:00
Guillaume Lessard 0e060b7a7a Merge pull request #144 from kateinoigakukun/katei/fix-rename-typo
Fix typos in renaming message for `Errno`
2023-09-07 15:21:20 -07:00
Yuta Saito 1ccaee141c Fix typos in renaming message for Errno 2023-09-05 11:36:08 -07:00
Guillaume Lessard 8a8552f617 Merge pull request #129 from glessard/reenable-mach-port
Re-enable Mach.Port
2023-08-16 16:04:53 -07:00
Guillaume Lessard ad407249fe make test expression return Void
- It can’t return `Mach.Port<SendRight>`, because a noncopyable type cannot currently be a generic type argument.
2023-08-16 13:34:41 -07:00
Guillaume Lessardandloffgren faffb9a15a Apply suggestions from code review
This better communicates the intention.

Co-authored-by: loffgren <117697138+loffgren@users.noreply.github.com>
2023-08-16 13:19:52 -07:00
Guillaume Lessard 547b2a5828 Merge pull request #141 from glessard/requirement-update 2023-08-16 11:52:22 -07:00
Guillaume Lessard 87e68fca36 declare Sendable conformances along with the types
- `Sendable` is fundamental, it is preferably not declared as an extension.
2023-08-16 11:19:06 -07:00
Guillaume Lessard f32faad415 remove code depending on Swift older than 5.6 2023-08-16 11:02:51 -07:00
Guillaume Lessard a3aff2f913 require Swift 5.6 2023-08-16 11:01:36 -07:00
Guillaume Lessard 8730f2cf25 [gardening] 80-column enforcement 2023-08-15 09:34:05 -07:00
Guillaume Lessard 65693b8b80 improve memory rebinding for mach_port_get_attributes call 2023-08-15 09:11:46 -07:00
Guillaume Lessard f5edd720bd clarify some tests 2023-08-11 18:03:24 -07:00
Guillaume Lessard 6189c1f553 fix copySendRight() for send rights that become dead names 2023-08-11 14:09:44 -07:00
Lucy Satheesan 6b4084c69f introduce IORing unit tests 2023-08-11 09:08:43 -07:00
Lucy Satheesan b596783bd9 implement closing 2023-08-11 09:07:47 -07:00
Lucy Satheesan b58450413e fix off-by-one in IORequest.openat 2023-08-11 09:07:08 -07:00
Lucy Satheesan d099546787 fix access control 2023-08-11 09:06:17 -07:00
Lucy Satheesan 0762f57d80 migrate CSystem to systemLibrary
for some reason, the linker on my linux machine fails
to link the tests otherwise. investigate / fix before merging.
2023-08-10 16:03:21 -07:00
Guillaume Lessard e4d06ae3ea simplify deinit 2023-08-10 15:35:27 -07:00
Guillaume Lessard d259ef476e test two-parameter withBorrowedName 2023-08-10 15:35:27 -07:00
Guillaume Lessard 5e03246e4e test copies of dead mach port names 2023-08-10 15:32:19 -07:00
Guillaume Lessard 40b5b3068b test all the relinquish() methods 2023-08-10 15:32:19 -07:00
Guillaume Lessard e8bb779909 use inout conversion
- this is the situation where it is appropriate
2023-08-10 15:32:19 -07:00
Guillaume Lessard 6ee96ffdb5 modify consuming methods to call discard self 2023-08-09 15:58:56 -07:00
Guillaume Lessard 0539daa364 fix test of receive-right deallocation 2023-08-09 15:58:56 -07:00
Guillaume Lessard 669dcf2c25 ensure Mach.Port lives until the function returns 2023-08-09 15:58:56 -07:00
Guillaume Lessard 9123120c08 destroy Send rights with mach_port_deallocate 2023-08-09 15:58:56 -07:00
Guillaume Lessard bf16d3da30 [test] use XCTAssertEqual or XCTAssertNotEqual 2023-08-09 15:58:56 -07:00
Daniel Loffgren 2df5b0b031 srdelta argument to mach_port_destruct should be zero
This should never have been -1, as there is no send right for
it to balance when `RightType.self == ReceiveRight.self`.
2023-08-09 15:58:56 -07:00
Guillaume Lessard af4544c869 Re-enable Mach.Port 2023-08-09 15:58:56 -07:00
Lucy Satheesan 1f821a8539 AsyncSequence draft implementation 2023-08-08 09:44:32 -07:00
Lucy Satheesan 996e940942 initial AsyncFileDescriptor work 2023-07-31 22:28:54 -07:00
Lucy Satheesan 6338029b74 stage 2: IORequest enum 2023-07-31 22:28:43 -07:00
Lucy Satheesan 15794f5cad ioring pitch: first steps 2023-07-18 21:04:39 -07:00
Saleem Abdulrasool 164fe8ce93 Merge pull request #136 from compnerd/singularity
Tests: avoid unnecessary duplication (NFCI)
2023-07-13 10:11:23 -07:00
Saleem Abdulrasool e1ab868059 Tests: avoid unnecessary duplication (NFCI)
Rather than specialising the function with the same implementation,
prefer to use the `CInterop.PlatformUnicodeEncoding` to determine the
correct code point encoding.  This allows us to share the implementation
across the platforms.
2023-07-13 10:00:45 -07:00
Saleem Abdulrasool 022a7fe638 Merge pull request #135 from compnerd/encoding
Tests: adjust the `FilePathTest.testFilePath` to build on Windows
2023-07-13 08:56:56 -07:00
Saleem Abdulrasool 32026456ba Tests: adjust the FilePathTest.testFilePath to build on Windows
UTF-8 is not the universal encoding for file systems.  Use a platform
specific invalid string encoding for testing the sequence.  The internal
representation of a `FilePath` is dependent on the system, and Windows
uses UTF-16 as the base encoding for C interoperability.  Adjust the
test to use an invalid sequence in the proper encoding.  This allows the
tests to now build on Windows once again.
2023-07-13 08:42:12 -07:00
Max Desiatov 0062c82c90 Add support for Musl libc (#133)
Since Musl is sufficiently different from Glibc (see https://wiki.musl-libc.org/functional-differences-from-glibc.html), it requires a different import, which now should be applied to files that have `import Glibc` in them.
2023-07-04 16:50:13 +01:00
Guillaume Lessard 4116b8cbfb Merge pull request #131 from glessard/sendable-availability
Add availability attributes to `Sendable` conformances
2023-06-21 16:47:51 -07:00
Guillaume Lessard adbf8d2856 Add availability attributes to Sendable conformances 2023-06-21 14:50:47 -07:00
Guillaume Lessard a87eaf71f6 Merge pull request #130 from amartini51/abstracts
Fix abstracts to follow reference style
2023-06-21 14:11:40 -07:00
Alex Martini 1d1bef36c9 Fix abstracts to follow reference style.
- Use a present tense verb phrase
- Avoid repeating the symbol's name
2023-06-21 10:26:04 -07:00
Guillaume Lessard a74751c99c Merge pull request #128 from apple/maxd/fix-comment-typo
FilePathSyntax.swift: fix doc comment typo
2023-06-10 00:18:26 -07:00
Guillaume Lessard 1cbb2cbcc6 Merge pull request #127 from loffgren/no-tuple-api 2023-06-09 23:57:08 -07:00
Guillaume Lessard 7bcc01f0bf deactivate Mach.Port
Will reactivate when the following issue is fixed:
https://github.com/apple/swift/issues/66299 (rdar://110496872)
2023-06-09 16:46:48 -07:00
Guillaume Lessard 6bbed6b199 update non-copyable type declaration syntax 2023-06-09 16:40:32 -07:00
Guillaume Lessard 2d6c6a82b3 import module correctly in test file 2023-06-09 16:40:32 -07:00
Daniel Loffgren 5b1b4cab56 Remove allocatePortRightPair(), as move only types are not permitted in tuples 2023-06-09 16:40:32 -07:00
Max Desiatov 7c6609eaca FilePathSyntax.swift: fix doc comment typo
`Appliations` -> `Applications`
2023-06-01 17:01:30 +01:00
Karoy Lorentey aabb8d0019 Merge pull request #123 from lorentey/update-gitignore
Update gitignore
2023-04-10 17:02:04 -07:00
Karoy Lorentey f059b4bfb3 Merge pull request #125 from compnerd/arm64
build: add ARM64 for mapping on Windows
2023-03-02 11:37:14 -08:00
Karoy Lorentey 64486e7d26 Merge pull request #124 from lorentey/tweak-availability-declarations
Fix expand-availability syntax not to interfere with doc comment parsing
2023-03-02 11:34:38 -08:00
Saleem Abdulrasool 9674a9fee8 build: add ARM64 for mapping on Windows
Windows uses `ARM64` for `CMAKE_SYSTEM_PROCESSOR` which doesn't match
the current spellings.
2023-03-02 10:56:49 -08:00
Karoy Lorentey bb6ab43e44 Update availability declarations 2023-03-01 18:10:40 -08:00
Karoy Lorentey e86702b34a Fix expand-availability syntax not to interfere with doc comment parsing
This was our previous convention:

    /// Fiddle with the thing.
    /*System 0.0.2*/
    public func foo()

    /// Fiddle with the thing.
    /*System 0.0.2, @available(macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0, *)*/
    public func foo()

    /// Fiddle with the thing.
    /*System 0.0.2*/@available(macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0, *)
    public func foo()

Unfortunately, regular comments in between a declaration and its
preceding doc comments interfere with documentation tools.

Change things to the style below instead:

    /// Fiddle with the thing.
    @available(/*System 0.0.2*/macOS 10, *)
    public func foo()

    /// Fiddle with the thing.
    @available(/*SwiftSystem 0.0.2: macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0*/macOS 10, *)
    public func foo()

    /// Fiddle with the thing.
    @available(/*SwiftSystem 0.0.2*/macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0, *)
    public func foo()

Unfortunately, `@available(*)` isn’t valid syntax, so we have to
add a dummy “macOS 10” version spec. It should have no actual effect.
2023-03-01 18:10:38 -08:00
Karoy Lorentey cee9335aeb Update gitignore 2023-03-01 16:29:39 -08:00
Karoy Lorentey f572e4becb Merge pull request #122 from lorentey/inlinable-mach-ports
Mach: Avoid non-inlinable generics where possible
2023-02-28 18:22:00 -08:00
Karoy Lorentey e708e4adda Mach: Avoid non-inlinable generics where possible
- Leave Ports as non-frozen for now, but expose its two stored
  properties.
- Make most members inlinable. The core initializers and the
  deinitializer must remain opaque for now.
- Mark the empty `MachPortRight` types as `@frozen` — these are
  markers, not carrying any data.

rdar://106057781
2023-02-28 17:05:18 -08:00
Karoy Lorentey cc96d40bee Merge pull request #76 from apple/lorentey/post-back-ios15-system
Update package with changes from recent ABI stable releases
2023-02-28 16:13:44 -08:00
loffgren 9cdaaa356e Merge pull request #121 from loffgren/machport_fixes
Mach.Port: Tidiness
2023-02-22 09:55:03 -08:00
Daniel Loffgren 16c7885387 Move public annotations from extensions down to each function explicitly 2023-02-21 16:03:31 -08:00
Alex Martini 08e9abe4e6 Merge pull request #119 from amartini51/doc_comment_placement
Fix doc comment placement
2023-02-14 11:23:02 -08:00
Daniel Loffgren 0fb71dd6ad Fit all function signatures within 80 cols 2023-02-13 23:53:06 -08:00
Daniel Loffgren 16a2775645 Annotate entire Mach namespace as being available in System 1.3.0 2023-02-13 17:53:42 -08:00
Daniel Loffgren 7c11f19259 Add System 1.3.0 to expand-availability.py 2023-02-13 17:53:03 -08:00
Daniel Loffgren 13bf719c29 Freeze the Mach namespace, as it should only ever be used as a namespace 2023-02-10 18:04:55 -08:00
Daniel Loffgren 3750b96b2e name and context should have leading underscores 2023-02-10 18:03:31 -08:00
Daniel Loffgren 12baba9706 machPrecondition should have a leading underscore 2023-02-10 17:59:16 -08:00
Alex Martini 2c2a831f66 Remove blank lines at the end of doc comments. 2023-01-31 12:35:33 -08:00
Alex Martini deb56e1ad2 Keep doc comments immediately before declarations.
If there's anything between them, DocC doesn't recognize that the doc
comment belongs to the declaration that comes after the interruption,
resulting in that declaration being undocumented.
2023-01-31 12:07:17 -08:00
Karoy Lorentey a2bf0d5708 Merge pull request #118 from apple/maxd/fix-5.7-errors 2023-01-10 09:40:44 -08:00
Max Desiatov b5e330163a MachPortTests: fix build issues with Swift 5.7 2023-01-05 14:35:22 +00:00
Max Desiatov 3f66dfbaf8 MachPort: fix build issues with Swift 5.7
It seems that `#if $MoveOnly` check has no effect on Swift 5.7, so we should check whether Swift 5.8 or later are available first.

Resolves #117.
2023-01-05 10:58:04 +00:00
Karoy Lorentey ccea4eed1a Merge pull request #116 from loffgren/machports
Add Mach.Port
2022-12-22 18:15:38 -08:00
Daniel Loffgren 700b8f867e Use two space indentation 2022-12-22 18:01:40 -08:00
loffgrenandKaroy Lorentey d129f62ce9 Use Markdown code voice for initializer comment
Co-authored-by: Karoy Lorentey <klorentey@apple.com>
2022-12-22 17:12:26 -08:00
loffgrenandMichael Ilseman ae6b1f24a9 Remove space before inheritance colon
Co-authored-by: Michael Ilseman <michael.ilseman@gmail.com>
2022-12-22 14:52:36 -08:00
Daniel Loffgren 47feb93a38 Add a test that ensures makeSendOnce is creating unique send-once rights 2022-12-21 13:43:26 -08:00
Daniel Loffgren 6a9ebce259 Add public annotations where applicable 2022-12-21 13:20:38 -08:00
Daniel Loffgren 7f4560f022 Remove unnecessary RightTypes for Mach.Ports being constructed inline with a return 2022-12-21 13:12:13 -08:00
Daniel Loffgren 6dd57fe3a9 Add a friendly precondition message for the MACH_PORT_NULL check 2022-12-21 12:57:25 -08:00
Daniel Loffgren 551d7b897f Use mach_port_destruct() to deinit receive rights eliminating the second syscall, and use mach_port_mod_refs() for all other right types to get a free type check at deinit time
mach_port_mod_refs() requires the type of right being modified.  So,
MACH_PORT_DEAD must be identified as a separate type. As this is
something that shouldn't be possible for receive rights, preconditions
have also been added to protect against this particular error.
2022-12-21 12:53:47 -08:00
Daniel Loffgren 296374ecef Label tuple contents for allocatePortPair() and relinquish() 2022-12-21 11:46:06 -08:00
Daniel Loffgren 213165ab72 size should be the number of natural_t's 2022-12-20 15:45:17 -08:00
Daniel Loffgren bd036acda6 Storage should be initialized to MACH_PORT_NULL, rather than 0 2022-12-20 15:45:17 -08:00
Daniel Loffgren 4536c47763 Use precondition instead of assert, adding a machPrecondition for the common KERN_SUCCESS check 2022-12-20 15:45:17 -08:00
Daniel Loffgren bdc776bd3e Correct parameter whitespace 2022-12-19 17:14:53 -08:00
loffgrenandMatt Wright c2d940ecf3 Remove parens around RightType condition in initializer
Co-authored-by: Matt Wright <mww@apple.com>
2022-12-19 16:41:33 -08:00
Daniel Loffgren 304ccc3abb Add Mach.Port 2022-12-07 17:24:26 -08:00
Florian Friedrich 77d9ca18c1 Add Sendable conformances (#115) 2022-11-30 14:04:49 -07:00
3405691582 18cceda484 Support OpenBSD. (#113)
Add the usual `os` conditionals and exclude errno constants that aren't
present on this platform.

Maybe availability annotations are a better way to deal with this, but
that is likely something that requires more careful consideration.
2022-10-31 09:22:05 -06:00
Saleem Abdulrasool 252c0f0905 Merge pull request #109 from krzyzanowskim/marcin/quote-cmake-include
Quote cmake include path
2022-09-17 08:42:39 -07:00
Marcin Krzyzanowski e1f6974ba6 Quote include path 2022-09-10 02:21:53 +02:00
Alex Martini 015e9baf40 Fix a broken link. (#107) 2022-08-23 07:21:09 -06:00
Daniel Duan 036f567f23 Remove Windows warnings (#105)
These calls are missing their Windows counter parts, resulting warnings
stating `X is deprecated: The POSIX name for this item is deprecated.
Instead, use the ISO C and C++ conformant name: Y. See online help for
details`.

Add them like the rest.
2022-06-21 09:50:24 -06:00
Saleem Abdulrasool 348b4de820 Merge pull request #99 from compnerd/file-flags
Tests: remove some flags from file tests
2022-06-18 09:44:43 -07:00
Saleem Abdulrasool e378fb2f0d Tests: ignore XCTest manifest on newer Swift (#91)
This is motivated by the desire to build the test suite on Windows.
Newer versions of SPM have test discovery which obviates the test
manifest, which incidentally repairs the build on Windows while adopting
newer functionality and reducing management complexity.
2022-06-15 10:00:23 -06:00
Karoy Lorentey e9886bf251 Merge branch 'main' into lorentey/post-back-ios15-system
# Conflicts:
#	Sources/System/FilePath/FilePathString.swift
2022-06-13 16:45:25 -07:00
Karoy Lorentey 63cdebeff6 Merge pull request #95 from compnerd/chartype
Tests: explicitly convert the character type
2022-06-13 16:32:28 -07:00
Karoy Lorentey 97a03f97c8 Merge pull request #103 from compnerd/array
Tests: change the conversion for string to array
2022-06-13 16:30:40 -07:00
Karoy Lorentey 0a7e8e121b Merge pull request #100 from compnerd/utf16
Tests: explicitly convert to UTF16 on Windows
2022-06-13 16:14:41 -07:00
Karoy Lorentey a102156af3 Merge pull request #96 from compnerd/not-errno
Tests: remove error codes that are unavailable on windows
2022-06-13 14:59:59 -07:00
Karoy Lorentey dc5a3107c0 Merge pull request #102 from compnerd/underlying
Tests: adjust the Windows error codes
2022-06-13 14:55:14 -07:00
Karoy Lorentey bcba321273 Merge pull request #104 from compnerd/validity
Tests: adjust invalid character
2022-06-13 14:34:45 -07:00
Saleem Abdulrasool a5c43b17a9 Tests: adjust invalid character
Adjust the injected character to be an invalid UTF-16 and UTF-8
character.  This is required to make the tests pass on Windows.
2022-06-12 14:34:12 -07:00
Saleem Abdulrasool 429f64259f Tests: adjust the Windows error codes
The Windows error codes are not re-exported, explicitly import the
WinSDK module to gain access to the error codes.  Add Windows specific
checks to ensure that the named forms match the underlying
implementation.
2022-06-12 12:35:54 -07:00
Saleem Abdulrasool 18c5f7a54b Tests: change the conversion for string to array
Windows uses UTF16 for the platform character, not UTF8, and does not
map to CChar.  Add a Windows path for the conversion.
2022-06-12 11:59:43 -07:00
Saleem Abdulrasool f9a514897e Tests: explicitly convert to UTF16 on Windows
File paths on Windows are represented in UTF16, while Swift strings are
UTF8.  Explicitly convert from UTF16 on Windows.
2022-06-12 11:37:47 -07:00
Saleem Abdulrasool 8e247d927e Tests: remove some flags from file tests
Windows does not support some flags (e.g. `O_CLOEXEC`).  This removes
the unsupported options on Windows.
2022-06-12 11:33:45 -07:00
Saleem Abdulrasool 59ddf00c8e Tests: remove error codes that are unavailable on windows
Not all the error codes are available on Windows, this matches
SystemErrno cases to remove the cases that have no definition on
Windows.
2022-06-12 11:21:16 -07:00
Saleem Abdulrasool 6d8abddbc8 Tests: explicitly convert the character type
The platform character type is different across Unix and Windows.
Explicitly convert the value to the expected type.
2022-06-11 14:50:35 -07:00
Karoy Lorentey 025bcb1165 Merge pull request #93 from apple/revert-89-sb/resize-windows
Revert "FileOperations: Add Windows implementation for FileDescriptor.resize(to:)"
2022-06-11 12:57:28 -07:00
Karoy Lorentey f5e4aac51b Revert "FileOperations: Add Windows implementation for FileDescriptor.resize(to:) (#89)"
This reverts commit 94fa6bd2ff.
2022-06-11 12:54:19 -07:00
Si Beaumont 94fa6bd2ff FileOperations: Add Windows implementation for FileDescriptor.resize(to:) (#89)
* FileOperations: Add Windows implementation for FileDescriptor.resize(to:)

Replace _chsize with _chsize_s on Windows
2022-06-09 09:51:28 -06:00
Alsey Coleman Miller a552fda216 Import C module as @_implementationOnly (#83) 2022-06-08 19:54:55 -06:00
Guillaume Lessard bdb13a5a80 Merge pull request #80 from apple/glessard/rdar91436410
Mitigate misuse of Swift's pointer conversion feature
2022-06-03 16:52:30 -06:00
Guillaume Lessard 3920df78d9 Correct deprecation messages 2022-06-03 16:43:25 -06:00
Guillaume Lessard 469ede0fa2 Add tests for every new overload added 2022-06-03 16:43:25 -06:00
Guillaume Lessard afe2d35d0b Mitigate misuse of pointer conversion in FilePath inits 2022-06-03 16:43:25 -06:00
Guillaume Lessard 25380a1bea Mitigate misuse of pointer conversion in String inits 2022-06-03 16:43:25 -06:00
Karoy Lorentey 74eb6f4ef8 Merge pull request #77 from amartini51/docs/develop
Fix broken links.
2022-06-03 15:37:23 -07:00
Alex Martini 6db5a4a43b Fix broken links.
Fixes rdar://79096457
2022-06-03 15:23:53 -07:00
Karoy Lorentey 5ba9e8fa77 Merge pull request #79 from apple/glessard/binding-fixes
Rebind byte types safely
2022-06-03 15:16:40 -07:00
Guillaume Lessard 914c782b96 Replace assumingMemoryBound with temporary rebinding
- this doesn’t use the new memory binding API.
2022-05-27 18:09:45 -06:00
Karoy Lorentey 82a6704912 Merge pull request #88 from apple/lorentey/unbroke-windows
Unbreak the Windows port
2022-05-21 12:46:19 -07:00
Karoy Lorentey bd5a7bb703 Remove test of minimal value 2022-05-21 12:44:00 -07:00
Karoy Lorentey 147ebc053a Unbreak the Windows port 2022-05-21 12:43:59 -07:00
Karoy Lorentey 5c18991f29 Merge pull request #82 from simonjbeaumont/sb/resize
FileDescriptor: Add resize(to newSize:) and fileSize() APIs
2022-05-20 11:30:26 -07:00
Si Beaumont 7bb5279b57 fixup: Tests run in parallel; use unique temp file name
Signed-off-by: Si Beaumont <beaumont@apple.com>
2022-05-20 19:25:41 +01:00
Si Beaumont 865fd70605 Merge branch 'main' into sb/resize 2022-05-20 18:26:33 +01:00
Si Beaumont ca6e888455 Utilities: Add version 1.2.0 to expand-availability.py tool
Signed-off-by: Si Beaumont <beaumont@apple.com>
2022-05-20 18:24:28 +01:00
Si Beaumont fea7d5030d docs: Removed duplicate paragraph from FileDescriptor.writeAll(_:) docs (#85) 2022-05-16 07:28:47 -07:00
Si Beaumont d90bf8529a fixup: Move FileDescriptor.fileSize() to an internal extension in SystemTests 2022-05-06 11:55:00 +01:00
Si Beaumont 02daf4b6a7 fixup: Move FileDescriptor.resize to extension with #if !os(Windows) 2022-05-06 11:55:00 +01:00
Si Beaumont 7fab65f340 fixup: Remove Windows syscall adaptor for ftruncate 2022-05-06 11:09:20 +01:00
Si Beaumont 5d3519dcef FileOperations: Add FileDescriptor.resize, using ftruncate(2)
Signed-off-by: Si Beaumont <beaumont@apple.com>
2022-05-05 08:24:48 +01:00
Si Beaumont 23ac190631 FileHelpers: Add FileDescriptor.fileSize
Signed-off-by: Si Beaumont <beaumont@apple.com>
2022-05-04 12:33:03 +01:00
Daniel Duan a77a331dc7 Update Linux test manifests (#81)
Run `swift package --generate-linuxmain` results in this patch.
2022-04-20 14:22:03 -06:00
Karoy Lorentey ca700460b1 Fix compatibility with Swift 5.3.3 2021-12-26 22:00:07 -08:00
Karoy Lorentey 81d78be499 Fix Windows build 2021-12-26 21:53:28 -08:00
Karoy Lorentey 915070e006 Add Internals/Backcompat.swift to CMake config 2021-12-21 18:40:27 -08:00
Karoy Lorentey 6469433909 Work around memset taking a non-optional pointer on Linux 2021-12-21 17:50:21 -08:00
Karoy Lorentey c0e8ef346b Update package with changes from recent ABI stable releases
This brings the contents of this package up to date with versions of the ABI stable `System` module that shipped in recent iOS/macOS releases.

Most changes only touch internal implementation details, but some ABI-related fixes also affect the public API. There are no source-incompatible changes.

- ABI stability fixes (un-deprecate CModeT, don't use PlatformChar in inlinable contexts that need to deploy to iOS 14)
- New utilities: `_RawBuffer`, `Array<String>._withCStringArray`, `_withOptionalUnsafePointerOrNull`, `_withStackBuffer`, `system_memset`
- Prefer using explicit optionals to implicitly-unwrapped ones
- Add support for wildcard matching in mocking tests
- A bunch of new availability annotations. (I expect there will be more of these coming in future PRs.)
2021-12-21 17:50:21 -08:00
Karoy Lorentey 1d5e35a460 Merge pull request #75 from lorentey/introduce-availability-macros
Unify availability annotations & introduce a script to manage them
2021-12-21 13:07:07 -08:00
Karoy Lorentey fd82b5a0ce Fix docs 2021-12-20 17:52:59 -08:00
Karoy Lorentey 0c24d31e08 Add script to manage availability annotations
By running this script, we can expand comments of the form

```
/*System 0.0.1*/
```

Into either a longer comment that includes the associated OS versions numbers,

```
/*System 0.0.1, @available(macOS 11.0, iOS 14.0, watchOS 7.0, tvOS 14.0, *)*/
```

or, when the `--attribute` option is used, into an actual `@available` attribute:

```
/*System 0.0.1*/@available(macOS 11.0, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
```

The script can be run repeatedly to switch between these two forms, as needed.
2021-12-20 17:14:42 -08:00
Karoy Lorentey 1daa0c9677 Unify availability annotations and synchronize them with macOS 12 / iOS 15
Availability annotations now follow a rigid syntax that mentions the swift-system version that introduced the entry point:

```
/*System 0.0.2, @available(macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0, *)*/
public func greeting() -> String {
  "Hello"
}
```

This is designed to be processed by automated source generation tools.
2021-12-20 17:10:59 -08:00
Saleem Abdulrasool 836bc4557b Merge pull request #74 from compnerd/leaky-cauldron
build: install CSystem into the system
2021-12-02 11:22:32 -08:00
Saleem Abdulrasool 5d68cf0eca build: install CSystem into the system
CSystem is a leaky library dependency from System and must be
distributed.  Install the files and make the dependency public so that
it is emitted into the clients.
2021-12-02 09:19:43 -08:00
tomer doron 5703dc2b4d update cmake setup so that the library can be used by SwiftPM cmake build (#73)
Update cmake setup so that the library can be used by SwiftPM cmake build

Motivation: integrate with SwiftPM

changes:
* rename the top level project to SwiftSystem instead of swift-system to align with other projects
* rename System to SystemPackage to align with SwifPM setup
* update architectures to include arm64
* Update cmake/modules/SwiftSystemConfig.cmake.in
* Update cmake/modules/SwiftSupport.cmake
2021-11-30 10:50:50 -07:00
Alex Martini 2fa26782e1 Merge pull request #69 from amartini51/docs/develop
Minor fixes in documentation comments
2021-11-09 10:11:05 -08:00
Alex Martini 0c291a65c2 Fix typo.
Fixes <rdar://problem/84559893>.
2021-11-08 19:43:49 -08:00
Alex Martini 0ac080ea56 Add missing period at end of abstract. 2021-11-08 19:43:30 -08:00
Alex Martini d2c4e4507a Fix spacing and indentation. 2021-11-08 19:43:30 -08:00
Alex Martini 78847afcd4 Remove stray word. 2021-11-08 19:43:30 -08:00
George Lyon 689390f50f Implement FileDescriptor.Pipe() (#58)
Adds support for pipe(2)
2021-09-27 16:02:52 -06:00
Michael Ilseman ce8b491073 Update README for 1.0 2021-09-01 09:26:18 -06:00
YR Chen 39774ef16a Simplify Package.swift 2021-08-05 10:05:06 -06:00
YR Chen 58a2725013 Fix building on Windows 2021-08-05 10:05:06 -06:00
Rauhul Varma e520e61616 Fix SystemChar isLetter logic
- Fixes range expression in isLetter logic and adds test coverage.
2021-08-05 10:03:53 -06:00
Rauhul Varma 4f36710d0b Expose O_DIRECTORY as api
- Adds a `directory` OpenOptions as a type-safe version of O_DIRECTORY.
  Allows clients to only open a FileDescriptor for FilePaths that refer
  to directories.
2021-07-14 18:24:52 -06:00
Alex Martini 591ff41944 Move TODO and FIXME markers to normal comments.
When they appear in triple-slash comments, that makes them part of the
actual documentation that gets published.

Fixes <rdar://problem/79071171>.
2021-06-10 16:34:32 -06:00
Michael Ilseman 2bc160bfe3 FilePath.Component.Kind is meant to be frozen 2021-05-13 15:42:38 -06:00
Michael Ilseman 578586ab80 Un-deprecate withCString
Un-deprecate withCString, but make sure it's not available on Windows (because
the types will not match). withPlatformString is still the preferred
expression of this and favors more portable code.
2021-05-10 13:32:31 -06:00
Michael Ilseman 8e3c23987f [testing] Generalize interruptable behavior to support non-erroring syscalls 2021-03-22 15:58:10 -06:00
Michael Ilseman 090d109c0f Make retryOnInterrupt always explicit internally 2021-03-22 15:58:10 -06:00
Saleem Abdulrasool 603718e247 FilePath: enable building on Windows (#41)
When building on Windows, we rely on the `withPlatformString` to convert
the strings to the native platform encoding (UTF-16).  The public
`FilePath.withPlatformString` is marked as `@_alwaysEmitIntoClient` and
references the `_withPlatformString` which is marked as `internal`.
Annotate the function as `@usableFromInline` to enable the inlined
method to reference this function.
2021-03-20 17:29:54 -06:00
Saleem Abdulrasool 65a906baf1 Internals: replace CModeT with CInterop.Mode (#40)
The typealias was renamed but the reference to it was not fully removed.
This updates the instance enabling building System on Windows.
2021-03-20 12:32:13 -06:00
Michael Ilseman a973b97147 [docs] Fixup code example (#39) 2021-03-18 16:18:39 -06:00
Saleem Abdulrasool b614185c90 build: add a CMake based build system (#38)
This will allow using Swift System in the toolchain stack, allowing us
to bootstrap a toolchain.
2021-03-18 16:18:24 -06:00
Saleem Abdulrasool dd1da2991e Internals: add Windows error code equivalences (#37)
Windows does not have the same set of error codes as a POSIX system.
However, the WinSock subsystem provides a set of error codes which are
meant to provide a means for handling similar error scenarios with
sockets.  This additionally adds an additional error code which allows
us to add back a previously ignored error code.
2021-03-16 19:25:12 -06:00
Saleem Abdulrasool bdfeb29148 Internals: adjust the definition of CInterop.Mode for Windows (#36)
Windows does not have a `mode_t` type, instead it uses `int` as a
stand in.  Adjust the type alias to reflect this.
2021-03-16 19:24:59 -06:00
Saleem Abdulrasool 83875613ec Internals: use CInterop.PlatformUnicodeString on Windows (#34)
The typealias was renamed but the Windows side of the build was not
updated.  This prevents building System on Windows.
2021-03-16 19:24:10 -06:00
Saleem Abdulrasool b761517c25 Merge pull request #35 from compnerd/swap
git: ignore vim swap files
2021-03-16 18:23:24 -07:00
Michael Ilseman e191da860c Merge pull request #32 from milseman/at_available_eject
Emit withPlatformString as an availability workaround for open
2021-03-16 19:10:48 -06:00
Saleem Abdulrasool eb215cf414 git: ignore vim swap files 2021-03-15 18:24:20 -07:00
Michael Ilseman 58e9e1c0c9 Ugly, ugly workaround for Swift 5.3.3 bug 2021-03-15 17:43:14 -06:00
Michael Ilseman cd4b42e03d Mocking helper for path strings 2021-03-15 15:18:54 -06:00
Michael Ilseman a611ed59c4 Update linux test main 2021-03-15 15:18:54 -06:00
Michael Ilseman 8031239cef Emit withPlatformString as an availability workaround for open 2021-03-15 15:18:51 -06:00
Michael Ilseman 2ac0cdc24b Merge pull request #29 from milseman/bypassing_customs
Normal imports
2021-02-27 20:01:58 -07:00
Michael Ilseman 8b989f724f Do not import CSystem on Darwin 2021-02-27 10:59:54 -07:00
Michael Ilseman b28263a910 Fixup some merge issues 2021-02-26 12:59:31 -07:00
Michael Ilseman bae68a5651 Use C type in typealias 2021-02-25 21:49:27 -07:00
Michael Ilseman b6558a3a90 Normal imports
System is not an overlay and will not pull C and platform modules into the
user's namespace. Import constants normally rather than redefining them.
2021-02-25 21:40:25 -07:00
Michael Ilseman 16667a30c4 Merge pull request #25 from milseman/dyadically_distributed
Ease binary distribution
2021-02-25 21:40:00 -07:00
Karoy Lorentey b9d290dc1e Add missing @_implementationOnly attribute 2021-02-25 21:14:46 -07:00
Michael Ilseman 0734450867 Fixup compilation failures for some compilers 2021-02-25 21:14:46 -07:00
Michael Ilseman d7611ca8ad Internalize SystemInternals
Scrap the separate module SystemInternals and instead have it be a
subdirectory. Adjust all access control accordingly. One day, when Swift gets
proper submodules or supermodules (i.e. resilience domains), we can reinstate
it. For now, a separate module makes binary distribution much more
complicated.
2021-02-25 21:14:46 -07:00
Michael Ilseman b63554656d [gardening] Privatization of Mocking 2021-02-25 21:14:44 -07:00
Michael Ilseman 7b33caf850 Add commented out availability.
Add it for public APIs, though we will likely have to add it for internal
stuff too as a compiler workaround.
2021-02-25 21:11:15 -07:00
Michael Ilseman 4f0eafd24e Ease binary distribution: testing
Add a SYSTEM_PACKAGE define and conditionalize import statements in tests to
ease testing of binary distributions of System.
2021-02-25 21:11:15 -07:00
Michael Ilseman 37e23f208a Merge pull request #28 from lorentey/whoop-de-dup
Add support for dup/dup2
2021-02-24 18:40:40 -07:00
Karoy Lorentey 2d24a58a41 Add support for dup/dup2 2021-02-24 13:30:07 -08:00
Michael Ilseman a5b2501f9a Merge pull request #27 from milseman/issue_26
[test] Add a test for issue-26
2021-02-24 08:25:15 -07:00
Michael Ilseman b5a89a4601 [test] Add a test for issue-26 2021-02-21 09:49:16 -07:00
Michael Ilseman 2e9c1a7118 Merge pull request #24 from milseman/fatal_assertion
Fix release builds by making assert into fatalError
2021-02-08 09:22:46 -07:00
Michael Ilseman 03c0b7ada5 Fix release builds by making assert into fatalError 2021-02-08 09:21:35 -07:00
Michael Ilseman 90d412b6f3 Merge pull request #19 from prabal4546/main
Update README.md
2021-02-06 09:16:05 -07:00
Michael Ilseman 47da6f147f Merge pull request #21 from lorentey/standard-fds
Add symbolic names for standard file descriptors
2021-02-05 22:58:42 -07:00
Karoy Lorentey 2904f9ead3 Add symbolic names for standard file descriptors 2021-02-05 19:35:18 -08:00
Prabaljit Walia 11cc26a46b Update README.md 2021-02-05 13:05:23 +05:30
Prabaljit Walia ac6f82162c Update README.md 2021-02-05 13:04:16 +05:30
Michael Ilseman 5bea53afe7 Merge pull request #14 from milseman/route_morphology
FilePath syntactic operations
2021-02-04 17:12:32 -07:00
Michael IlsemanandKyle Macomber d24083e1be Integrate API review
Fix bug in _modify and add better testing. Change lexicallyNormal to
lexicallyNormalized() to match "ed" rule.

Fix up some comments and remove some dead code

Co-authored-by: Kyle Macomber <kmacomber@apple.com>
2021-02-04 16:34:20 -07:00
Michael Ilseman 05e3d04b0c Drop Component.isSpecialDirectory
This API is fully redundant with .kind == .regular and could be a source of
confusion and namespace pollution. Drop it for now, and we can add something
equivalent in the future when we have more component-analysis APIs.
2021-02-02 07:49:42 -07:00
Michael Ilseman 2167575e66 Add FilePath Syntactic Operations API
Add the proposed non-file-system-interacting FilePath operations, Component,
Root, and ComponentView.

Proposal: https://forums.swift.org/t/api-review-filepath-syntactic-apis-version-2/44197

This change includes API/ABI additions and deprecations.
2021-02-01 08:42:44 -07:00
Michael Ilseman 920ef3085d Add PlatformString and Windows support
Add CInterop namespace and PlatformChar/PlatformEncoding typealiases for
narrow/wide characters.

Change Windows syscalls to use wide-character variants. Add full Windows root
parser to error-correct malformed roots and correctly normalize roots and
post-root portions of the path.

Add platformString APIs as replacements for cString APIs.

Add internal SystemString as backing storage type for FilePath.

Add Windows path mocking support.

This change includes API/ABI additions and deprecations.
2021-02-01 08:20:05 -07:00
Michael Ilseman 79eed1f99d Enforce at construction/mutation that FilePath's separators are normalized 2020-11-13 17:28:05 -08:00
Michael Ilseman 3367b485e1 Follow test convention of expected as first parameter 2020-11-13 17:00:33 -08:00
Michael Ilseman 5d1b2fb985 Folders for FilePath and Platform sources 2020-11-13 16:57:25 -08:00
Michael Ilseman 0627d28e6a Merge pull request #6 from compnerd/windows
Initial port to Windows
2020-11-04 09:27:21 -08:00
Saleem Abdulrasool 4ffcc62e9b Initial port to Windows
This adds enough shims and tweaks the types sufficiently to allow
building System on Windows.
2020-11-03 15:03:51 -08:00
Michael Ilseman 0b0d9d5fbb Merge pull request #12 from compnerd/compile
Follow up to #11 to repair the build
2020-10-25 15:21:33 -07:00
Saleem Abdulrasool ac6ec0b19d SystemInternals: make WindowsSyscallAdapters build
Correct some type errors, missing return type.  Add a FIXME comment
regarding large file access.
2020-10-24 12:16:33 -07:00
Saleem Abdulrasool bf90fedc88 SystemInternals: make Mocking build on Windows
Fix some of the type errors and add missing imports.
2020-10-23 14:32:24 -07:00
Michael Ilseman 28916d22fb Merge pull request #11 from milseman/aperture_adapters
Windows syscall adapters
2020-10-23 13:52:04 -07:00
Michael Ilseman 1eeeaf7200 Initial Windows syscall adapters 2020-10-23 09:07:41 -07:00
Michael Ilseman 5712a28377 Windows TLS mocking support 2020-10-23 09:07:41 -07:00
Michael Ilseman 8f2622ad40 Merge pull request #10 from milseman/yarn_regional_warehouse
TLS helpers to ease Windows support
2020-10-23 08:12:54 -07:00
Michael Ilseman 173c684973 TLS helpers to ease Windows support 2020-10-22 14:42:03 -07:00
Michael Ilseman d93ee62bbd Merge pull request #8 from milseman/mimus_polyglottos
Syscall mock testing
2020-10-22 11:14:11 -07:00
Michael Ilseman ab94d189df More mocking infra testing 2020-10-22 10:53:09 -07:00
Michael Ilseman d2e26f72f3 Fix memory leak in withMockingEnabled 2020-10-22 10:43:12 -07:00
Michael Ilseman a8d07f8a04 Leverage conditional compilation to reduce mocking boilerplate 2020-10-22 10:39:09 -07:00
Michael Ilseman 98a1531ea0 Remove mocking infrastructure from non-mocking builds 2020-10-21 16:09:04 -07:00
Michael Ilseman 138c7f1a71 Add Linux support for syscall mocking 2020-10-21 09:40:08 -07:00
Michael Ilseman 9489545fed Syscall mock testing
Adds mocking and tracing infrastructure, test
infrastructure, and trace-based tests.
2020-10-21 09:22:46 -07:00
88 changed files with 13767 additions and 1677 deletions

No files matched your search

+13
View File
@@ -0,0 +1,13 @@
# Lines starting with '#' are comments.
# Each line is a case-sensitive file pattern followed by one or more owners.
# Order is important. The last matching pattern has the most precedence.
# More information: https://docs.github.com/en/articles/about-code-owners
#
# Please mirror the repository's file hierarchy in case-sensitive lexicographic
# order.
# Default owners
* @glessard @lorentey @milseman
# Swift CI configuration files
.swiftci/ @shahmishal
+54
View File
@@ -0,0 +1,54 @@
name: Pull request
on:
pull_request:
types: [opened, reopened, synchronize]
jobs:
tests:
name: Test
uses: swiftlang/github-workflows/.github/workflows/swift_package_test.yml@main
with:
linux_os_versions: '["jammy", "focal"]'
enable_macos_checks: true
# FIXME: https://github.com/swiftlang/github-workflows/pull/140
# Xcode 16.0 and 16.1 are not actually available
macos_exclude_xcode_versions: |
[
{"xcode_version": "16.0"},
{"xcode_version": "16.1"},
]
swift_flags: "-Xbuild-tools-swiftc -DSYSTEM_CI"
enable_linux_static_sdk_build: true
enable_wasm_sdk_build: true
build-abi-stable:
name: Build ABI Stable
uses: swiftlang/github-workflows/.github/workflows/swift_package_test.yml@main
with:
enable_linux_checks: false
enable_macos_checks: true
enable_windows_checks: false
# Only build
macos_build_command: "xcrun swift build --build-tests"
# FIXME: https://github.com/swiftlang/github-workflows/pull/140
# Xcode 16.0 and 16.1 are not actually available
macos_exclude_xcode_versions: |
[
{"xcode_version": "16.0"},
{"xcode_version": "16.1"},
]
# Enable availability to match ABI stable verion of system.
swift_flags: "-Xbuild-tools-swiftc -DSYSTEM_CI -Xbuild-tools-swiftc -DSYSTEM_ABI_STABLE"
soundness:
name: Soundness
uses: swiftlang/github-workflows/.github/workflows/soundness.yml@main
with:
license_header_check_project_name: "Swift.org"
# https://github.com/apple/swift-system/issues/224
docs_check_enabled: false
unacceptable_language_check_enabled: false
license_header_check_enabled: false
format_check_enabled: false
python_lint_check_enabled: false
+4
View File
@@ -1,5 +1,9 @@
.DS_Store
/.swiftpm
/.build
/Packages
/*.xcodeproj
xcuserdata/
.*.sw?
/.swiftpm
.docc-build
+4
View File
@@ -0,0 +1,4 @@
version: 1
builder:
configs:
- documentation_targets: [SystemPackage]
+5
View File
@@ -0,0 +1,5 @@
LinuxSwiftPackageJob {
swift_version_tag = "5.10-jammy"
repo = "swift-system"
branch = "main"
}
+5
View File
@@ -0,0 +1,5 @@
LinuxSwiftPackageJob {
swift_version_tag = "5.9-jammy"
repo = "swift-system"
branch = "main"
}
+5
View File
@@ -0,0 +1,5 @@
macOSSwiftPackageJob {
swift_version = "6.0"
repo = "swift-system"
branch = "main"
}
+5
View File
@@ -0,0 +1,5 @@
LinuxSwiftPackageJob {
nightly_docker_tag = "nightly-6.0-jammy"
repo = "swift-system"
branch = "main"
}
+5
View File
@@ -0,0 +1,5 @@
macOSSwiftPackageJob {
swift_version = "main"
repo = "swift-system"
branch = "main"
}
+5
View File
@@ -0,0 +1,5 @@
LinuxSwiftPackageJob {
nightly_docker_tag = "nightly-jammy"
repo = "swift-system"
branch = "main"
}
+7
View File
@@ -0,0 +1,7 @@
WindowsSwiftPackageWithDockerImageJob {
docker_image = "swiftlang/swift:nightly-windowsservercore-1809"
repo = "swift-system"
branch = "main"
sub_dir = "swift-system"
label = "windows-server-2019"
}
+26
View File
@@ -0,0 +1,26 @@
#[[
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
#]]
cmake_minimum_required(VERSION 3.16.0)
project(SwiftSystem
LANGUAGES C Swift)
include(GNUInstallDirs)
list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake/modules)
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set(CMAKE_Swift_MODULE_DIRECTORY ${CMAKE_BINARY_DIR}/swift)
include(SwiftSupport)
add_subdirectory(Sources)
add_subdirectory(cmake/modules)
+38
View File
@@ -0,0 +1,38 @@
# Code of Conduct
To be a truly great community, Swift.org needs to welcome developers from all walks of life, with different backgrounds, and with a wide range of experience. A diverse and friendly community will have more great ideas, more unique perspectives, and produce more great code. We will work diligently to make the Swift community welcoming to everyone.
To give clarity of what is expected of our members, this code of conduct is based on [contributor-covenant.org](http://contributor-covenant.org). This document is used across many open source communities, and we think it articulates our values well.
### Contributor Code of Conduct v1.4
In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to make participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
Examples of behavior that contributes to creating a positive environment include:
* Using welcoming and inclusive language (e.g., prefer non-gendered words like “folks” to “guys”, non-ableist words like “soundness check” to “sanity check”, etc.)
* Being respectful of differing viewpoints and experiences
* Gracefully accepting constructive criticism
* Focusing on what is best for the community
* Showing empathy towards other community members
Examples of unacceptable behavior by participants include:
* The use of sexualized language or imagery and unwelcome sexual attention or advances
* Trolling, insulting/derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others’ private information, such as a physical or electronic address, without explicit permission
* Other conduct which could reasonably be considered inappropriate in a professional setting
Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
This Code of Conduct applies within all project spaces managed by Swift.org, including (but not limited to) source code repositories, bug trackers, web sites, documentation, and online forums. It also applies when an individual is representing the project or its community in public spaces. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting a member of the [Swift Core Team](https://swift.org/community/#community-structure) or by flagging the behavior for moderation (e.g., in the Forums), whether you are the target of that behavior or not. All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. Maintainers are obligated to maintain confidentiality with regard to the reporter of an incident. The site of the disputed behavior is usually not an acceptable place to discuss moderation decisions, and moderators may move or remove any such discussion.
Project maintainers are held to a higher standard, and project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project’s leadership.
If you disagree with a moderation action, you can appeal to the Core Team (or individual Core Team members) privately.
This policy is adapted from the Contributor Code of Conduct [version 1.4](https://www.contributor-covenant.org/version/1/4/code-of-conduct/).
+136 -32
View File
@@ -1,39 +1,143 @@
// swift-tools-version:5.2
// The swift-tools-version declares the minimum version of Swift required to build this package.
/*
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
*/
// swift-tools-version:5.9
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift System open source project
//
// Copyright (c) 2020 - 2024 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
//
//===----------------------------------------------------------------------===//
import PackageDescription
let targets: [PackageDescription.Target] = [
.target(
name: "SystemPackage",
dependencies: ["SystemInternals"],
path: "Sources/System"),
.target(
name: "SystemInternals",
dependencies: ["CSystem"]),
.target(
name: "CSystem",
dependencies: []),
struct Available {
var name: String
var version: String
var osAvailability: String
var sourceAvailability: String
.testTarget(
name: "SystemTests",
dependencies: ["SystemPackage"]),
init(
_ version: String,
_ osAvailability: String
) {
self.name = "System"
self.version = version
self.osAvailability = osAvailability
self.sourceAvailability = "macOS 10.10, iOS 8.0, watchOS 2.0, tvOS 9.0, visionOS 1.0"
}
var swiftSetting: SwiftSetting {
#if SYSTEM_ABI_STABLE
// Use availability matching Darwin API.
let availability = self.osAvailability
#else
// Use availability matching SwiftPM default.
let availability = self.sourceAvailability
#endif
return .enableExperimentalFeature(
"AvailabilityMacro=\(self.name) \(version):\(availability)")
}
}
let availability: [Available] = [
Available("0.0.1", "macOS 11.0, iOS 14.0, watchOS 7.0, tvOS 14.0"),
Available("0.0.2", "macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0"),
Available("0.0.3", "macOS 12.3, iOS 15.4, watchOS 8.5, tvOS 15.4"),
Available("1.1.0", "macOS 12.3, iOS 15.4, watchOS 8.5, tvOS 15.4"),
Available("1.1.1", "macOS 14.4, iOS 17.4, watchOS 10.4, tvOS 17.4"),
Available("1.2.0", "macOS 14.4, iOS 17.4, watchOS 10.4, tvOS 17.4"),
Available("1.2.1", "macOS 14.4, iOS 17.4, watchOS 10.4, tvOS 17.4"),
Available("1.3.0", "macOS 14.4, iOS 17.4, watchOS 10.4, tvOS 17.4"),
Available("1.3.1", "macOS 14.4, iOS 17.4, watchOS 10.4, tvOS 17.4, visionOS 1.0"),
Available("1.3.2", "macOS 14.4, iOS 17.4, watchOS 10.4, tvOS 17.4, visionOS 1.0"),
Available("1.4.0", "macOS 14.4, iOS 17.4, watchOS 10.4, tvOS 17.4, visionOS 1.0"),
Available("1.4.1", "macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, visionOS 9999"),
Available("1.4.2", "macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, visionOS 9999"),
Available("1.5.0", "macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, visionOS 9999"),
Available("1.6.0", "macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, visionOS 9999"),
Available("1.6.1", "macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, visionOS 9999"),
]
let swiftSettingsAvailability = availability.map(\.swiftSetting)
#if SYSTEM_CI
let swiftSettingsCI: [SwiftSetting] = [
.unsafeFlags(["-require-explicit-availability=error"]),
]
#else
let swiftSettingsCI: [SwiftSetting] = []
#endif
let swiftSettings = swiftSettingsAvailability + swiftSettingsCI + [
.define(
"SYSTEM_PACKAGE_DARWIN",
.when(platforms: [.macOS, .macCatalyst, .iOS, .watchOS, .tvOS, .visionOS])),
.define("SYSTEM_PACKAGE"),
.define("ENABLE_MOCKING", .when(configuration: .debug)),
.enableExperimentalFeature("Lifetimes"),
]
let cSettings: [CSetting] = [
.define("_CRT_SECURE_NO_WARNINGS", .when(platforms: [.windows])),
]
#if SYSTEM_ABI_STABLE
let platforms: [SupportedPlatform] = [
.macOS("26"),
.iOS("26"),
.watchOS("26"),
.tvOS("26"),
.visionOS("26"),
]
#else
let platforms: [SupportedPlatform]? = nil
#endif
#if os(Linux)
let filesToExclude = ["CMakeLists.txt"]
#else
let filesToExclude = ["CMakeLists.txt", "IORing"]
#endif
#if os(Linux)
let testsToExclude:[String] = []
#else
let testsToExclude = ["IORequestTests.swift", "IORingTests.swift"]
#endif
let package = Package(
name: "swift-system",
products: [
.library(name: "SystemPackage", targets: ["SystemPackage"]),
],
dependencies: [],
targets: targets
)
name: "swift-system",
platforms: platforms,
products: [
.library(name: "SystemPackage", targets: ["SystemPackage"]),
],
dependencies: [],
targets: [
.target(
name: "CSystem",
dependencies: [],
exclude: ["CMakeLists.txt"],
cSettings: cSettings),
.target(
name: "SystemPackage",
dependencies: ["CSystem"],
path: "Sources/System",
exclude: filesToExclude,
cSettings: cSettings,
swiftSettings: swiftSettings),
.testTarget(
name: "SystemTests",
dependencies: ["SystemPackage"],
exclude: testsToExclude,
cSettings: cSettings,
swiftSettings: swiftSettings),
])
+82 -15
View File
@@ -2,11 +2,13 @@
Swift System provides idiomatic interfaces to system calls and low-level currency types. Our vision is for System to act as the single home for low-level system interfaces for all supported Swift platforms.
## Multi-platform not Cross-platform
## No Cross-platform Abstractions
System is a multi-platform library, not a cross-platform one. It provides a separate set of APIs and behaviors on every supported platform, closely reflecting the underlying OS interfaces. A single import will pull in the native platform interfaces specific for the targeted OS.
Swift System is not a cross-platform library. It provides a separate set of APIs and behaviors on every supported platform, closely reflecting the underlying OS interfaces. A single import will pull in the native platform interfaces specific for the targeted OS.
Our immediate goal is to simplify building cross-platform libraries and applications such as SwiftNIO and SwiftPM. System does not eliminate the need for `#if os()` conditionals to implement cross-platform abstractions, but it does make it safer and more expressive to fill out the platform-specific parts.
Our immediate goal is to simplify building cross-platform libraries and applications such as SwiftNIO and SwiftPM. It is not a design goal for System to eliminate the need for `#if os()` conditionals to implement cross-platform abstractions; rather, our goal is to make it safer and more expressive to fill out the platform-specific parts.
(That said, it is desirable to avoid unnecessary differences -- for example, when two operating systems share the same C name for a system call, ideally Swift System would expose them using the same Swift name. This is a particularly obvious expectation for system interfaces that implement an industry standard, such as POSIX.)
## Usage
@@ -22,22 +24,15 @@ try fd.closeAfter {
}
```
[API documentation](https://swiftpackageindex.com/apple/swift-system/documentation/SystemPackage)
## Adding `SystemPackage` as a Dependency
To use the `SystemPackage` library in a SwiftPM project,
To use the `SystemPackage` library in a SwiftPM project,
add the following line to the dependencies in your `Package.swift` file:
```swift
.package(url: "https://github.com/apple/swift-system", from: "0.0.1"),
```
Because `SystemPackage` is under active development,
source-stability is only guaranteed within minor versions (e.g. between `0.0.3` and `0.0.4`).
If you don't want potentially source-breaking package updates,
use this dependency specification instead:
```swift
.package(url: "https://github.com/apple/swift-system", .upToNextMinor(from: "0.0.1")),
.package(url: "https://github.com/apple/swift-system", from: "1.6.1"),
```
Finally, include `"SystemPackage"` as a dependency for your executable target:
@@ -46,7 +41,7 @@ Finally, include `"SystemPackage"` as a dependency for your executable target:
let package = Package(
// name, platforms, products, etc.
dependencies: [
.package(url: "https://github.com/apple/swift-system", from: "0.0.1"),
.package(url: "https://github.com/apple/swift-system", from: "1.6.1"),
// other dependencies
],
targets: [
@@ -57,3 +52,75 @@ let package = Package(
]
)
```
## Source Stability
At this time, the Swift System package supports three types of operating systems: Darwin-based, POSIX-like, and Windows. The source-stability status of the package differs according to the platform:
| Platform type | Source Stability |
| ----------------- | --------------- |
| Darwin (macOS, iOS, etc.) | Stable |
| POSIX (Linux, WASI, etc.) | Stable |
| Windows | Unstable |
The package version numbers follow [Semantic Versioning][semver] -- source breaking changes to source-stable public API can only land in a new major version. However, platforms for which support has not reached source stability may see source-breaking changes in a new minor version.
[semver]: https://semver.org
The public API of the swift-system package consists of non-underscored declarations that are marked `public` in the `SystemPackage` module.
By "underscored declarations" we mean declarations that have a leading underscore anywhere in their fully qualified name. For instance, here are some names that wouldn't be considered part of the public API, even if they were technically marked public:
- `FooModule.Bar._someMember(value:)` (underscored member)
- `FooModule._Bar.someMember` (underscored type)
- `_FooModule.Bar` (underscored module)
- `FooModule.Bar.init(_value:)` (underscored initializer)
Interfaces that aren't part of the public API may continue to change in any release, including patch releases. If you have a use case that requires using non-public APIs, please submit a Feature Request describing it! We'd like the public interface to be as useful as possible -- although preferably without compromising safety or limiting future evolution.
Future minor versions of the package may update these rules as needed.
## Toolchain Requirements
The following table maps existing package releases to their minimum required Swift toolchain release:
| Package version | Swift version | Xcode release |
| ----------------------- | --------------- | ------------- |
| swift-system 1.3.x | >= Swift 5.8 | >= Xcode 14.3 |
| swift-system 1.4.x through 1.6.x | >= Swift 5.9 | >= Xcode 15.0 |
We'd like this package to quickly embrace Swift language and toolchain improvements that are relevant to its mandate. Accordingly, from time to time, new versions of this package require clients to upgrade to a more recent Swift toolchain release. (This allows the package to make use of new language/stdlib features, build on compiler bug fixes, and adopt new package manager functionality as soon as they are available.) Patch (i.e., bugfix) releases will not increase the required toolchain version, but any minor (i.e., new feature) release may do so.
(Note: the package has no minimum deployment target, so while it does require clients to use a recent Swift toolchain to build it, the code itself is able to run on any OS release that supports running Swift code.)
## Licensing
See [LICENSE](LICENSE.txt) for license information.
## Contributing
Before contributing, please read [CONTRIBUTING.md](CONTRIBUTING.md).
### Branching Strategy
We maintain separate branches for each active minor version of the package:
| Package version | Branch |
| ----------------------- | ----------- |
| swift-system 1.3.x | release/1.3 |
| swift-system 1.4.x | release/1.4 |
| swift-system 1.5.x | release/1.5 |
| swift-system 1.6.x | release/1.6 |
| swift-system 1.7.x (unreleased) | main |
Changes must land on the branch corresponding to the earliest release that they will need to ship on. They are periodically propagated to subsequent branches, in the following direction:
`release/1.3` → `release/1.4` → `main`
For example, anything landing on `release/1.3` will eventually appear on `release/1.4` and then `main` too; there is no need to file standalone PRs for each release line. (Change propagation currently requires manual work -- it is performed by project maintainers.)
### Code of Conduct
Like all Swift.org projects, we would like the Swift System project to foster a diverse and friendly community. We expect contributors to adhere to the [Swift.org Code of Conduct](https://swift.org/code-of-conduct/). A copy of this document is [available in this repository][coc].
[coc]: CODE_OF_CONDUCT.md
+11
View File
@@ -0,0 +1,11 @@
#[[
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
#]]
add_subdirectory(CSystem)
add_subdirectory(System)
+20
View File
@@ -0,0 +1,20 @@
#[[
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
#]]
add_library(CSystem INTERFACE)
target_include_directories(CSystem INTERFACE
"$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
$<INSTALL_INTERFACE:include/CSystem>)
install(FILES
include/CSystemLinux.h
include/CSystemWindows.h
include/module.modulemap
DESTINATION include/CSystem)
set_property(GLOBAL APPEND PROPERTY SWIFT_SYSTEM_EXPORTS CSystem)
+1
View File
@@ -21,5 +21,6 @@
#include <pthread.h>
#include <sched.h>
#include <unistd.h>
#include "io_uring.h"
#endif
+66
View File
@@ -0,0 +1,66 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2024 - 2025 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
*/
#pragma once
#if __wasi__
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h> // For NAME_MAX
// wasi-libc defines the following constants in a way that Clang Importer can't
// understand, so we need to expose them manually.
static inline int32_t _getConst_O_ACCMODE(void) { return O_ACCMODE; }
static inline int32_t _getConst_O_APPEND(void) { return O_APPEND; }
static inline int32_t _getConst_O_CREAT(void) { return O_CREAT; }
static inline int32_t _getConst_O_DIRECTORY(void) { return O_DIRECTORY; }
static inline int32_t _getConst_O_EXCL(void) { return O_EXCL; }
static inline int32_t _getConst_O_NONBLOCK(void) { return O_NONBLOCK; }
static inline int32_t _getConst_O_TRUNC(void) { return O_TRUNC; }
static inline int32_t _getConst_O_WRONLY(void) { return O_WRONLY; }
static inline int32_t _getConst_EWOULDBLOCK(void) { return EWOULDBLOCK; }
static inline int32_t _getConst_EOPNOTSUPP(void) { return EOPNOTSUPP; }
static inline uint8_t _getConst_DT_DIR(void) { return DT_DIR; }
// Modified dirent struct that can be imported to Swift
struct _system_dirent {
ino_t d_ino;
unsigned char d_type;
// char d_name[] cannot be imported to Swift
char d_name[NAME_MAX + 1];
};
// Convert WASI dirent with d_name[] to _system_dirent
static inline
struct _system_dirent *
_system_dirent_from_wasi_dirent(const struct dirent *wasi_dirent) {
// Match readdir behavior and use thread-local storage for the converted dirent
static __thread struct _system_dirent _converted_dirent;
if (wasi_dirent == NULL) {
return NULL;
}
memset(&_converted_dirent, 0, sizeof(struct _system_dirent));
_converted_dirent.d_ino = wasi_dirent->d_ino;
_converted_dirent.d_type = wasi_dirent->d_type;
strncpy(_converted_dirent.d_name, wasi_dirent->d_name, NAME_MAX);
_converted_dirent.d_name[NAME_MAX] = '\0';
return &_converted_dirent;
}
#endif
@@ -7,11 +7,11 @@
See https://swift.org/LICENSE.txt for license information
*/
import XCTest
#if defined(_WIN32)
import SystemTests
#define NOMINMAX
#define WIN32_LEAN_AND_MEAN
#define VC_EXTRA_LEAN
#include <Windows.h>
var tests = [XCTestCaseEntry]()
tests += SystemTests.__allTests()
XCTMain(tests)
#endif
+245
View File
@@ -0,0 +1,245 @@
#include <unistd.h>
#include <sys/syscall.h>
#include <sys/uio.h>
#include <signal.h>
#define __SWIFT_IORING_SQE_FALLBACK_STRUCT { \
__u8 opcode; \
__u8 flags; \
__u16 ioprio; \
__s32 fd; \
union { \
__u64 off; \
__u64 addr2; \
struct { \
__u32 cmd_op; \
__u32 __pad1; \
}; \
}; \
union { \
__u64 addr; \
__u64 splice_off_in; \
struct { \
__u32 level; \
__u32 optname; \
}; \
}; \
__u32 len; \
union { \
__kernel_rwf_t rw_flags; \
__u32 fsync_flags; \
__u16 poll_events; \
__u32 poll32_events; \
__u32 sync_range_flags; \
__u32 msg_flags; \
__u32 timeout_flags; \
__u32 accept_flags; \
__u32 cancel_flags; \
__u32 open_flags; \
__u32 statx_flags; \
__u32 fadvise_advice; \
__u32 splice_flags; \
__u32 rename_flags; \
__u32 unlink_flags; \
__u32 hardlink_flags; \
__u32 xattr_flags; \
__u32 msg_ring_flags; \
__u32 uring_cmd_flags; \
__u32 waitid_flags; \
__u32 futex_flags; \
__u32 install_fd_flags; \
__u32 nop_flags; \
}; \
__u64 user_data; \
union { \
__u16 buf_index; \
__u16 buf_group; \
} __attribute__((packed)); \
__u16 personality; \
union { \
__s32 splice_fd_in; \
__u32 file_index; \
__u32 optlen; \
struct { \
__u16 addr_len; \
__u16 __pad3[1]; \
}; \
}; \
union { \
struct { \
__u64 addr3; \
__u64 __pad2[1]; \
}; \
__u64 optval; \
__u8 cmd[0]; \
}; \
}
#if __has_include(<linux/io_uring.h>)
#include <linux/io_uring.h>
#ifdef IORING_TIMEOUT_BOOTTIME
// Kernel version >= 5.15, io_uring_sqe has file_index
// and all current Swift operations are supported.
#define __SWIFT_IORING_SUPPORTED true
typedef struct io_uring_sqe swift_io_uring_sqe;
#else
// io_uring_sqe is missing properties that IORequest expects.
// This configuration is not supported for now.
//
// Define a fallback struct to avoid build errors, but IORing
// will throw ENOTSUP on initialization.
#define __SWIFT_IORING_SUPPORTED false
typedef struct __SWIFT_IORING_SQE_FALLBACK_STRUCT swift_io_uring_sqe;
#endif
// We can define more specific availability later
#ifdef IORING_FEAT_RW_CUR_POS
// Kernel version >= 5.6, io_uring_sqe has open_flags
#endif
#ifdef IORING_FEAT_NODROP
// Kernel version >= 5.5, io_uring_sqe has cancel_flags
#endif
#else
// Minimal fallback definitions when linux/io_uring.h is not available (e.g. static SDK)
#include <stdint.h>
#define __SWIFT_IORING_SUPPORTED false
#define IORING_OFF_SQ_RING 0ULL
#define IORING_OFF_CQ_RING 0x8000000ULL
#define IORING_OFF_SQES 0x10000000ULL
#define IORING_ENTER_GETEVENTS (1U << 0)
#define IORING_FEAT_SINGLE_MMAP (1U << 0)
#define IORING_FEAT_NODROP (1U << 1)
#define IORING_FEAT_SUBMIT_STABLE (1U << 2)
#define IORING_FEAT_RW_CUR_POS (1U << 3)
#define IORING_FEAT_CUR_PERSONALITY (1U << 4)
#define IORING_FEAT_FAST_POLL (1U << 5)
#define IORING_FEAT_POLL_32BITS (1U << 6)
#define IORING_FEAT_SQPOLL_NONFIXED (1U << 7)
#define IORING_FEAT_EXT_ARG (1U << 8)
#define IORING_FEAT_NATIVE_WORKERS (1U << 9)
#define IORING_FEAT_RSRC_TAGS (1U << 10)
#define IORING_FEAT_CQE_SKIP (1U << 11)
#define IORING_FEAT_LINKED_FILE (1U << 12)
#define IORING_FEAT_REG_REG_RING (1U << 13)
#define IORING_FEAT_RECVSEND_BUNDLE (1U << 14)
#define IORING_FEAT_MIN_TIMEOUT (1U << 15)
#define IORING_FEAT_RW_ATTR (1U << 16)
#define IORING_FEAT_NO_IOWAIT (1U << 17)
typedef uint8_t __u8;
typedef uint16_t __u16;
typedef uint32_t __u32;
typedef uint64_t __u64;
typedef int32_t __s32;
#ifndef __kernel_rwf_t
typedef int __kernel_rwf_t;
#endif
typedef struct __SWIFT_IORING_SQE_FALLBACK_STRUCT swift_io_uring_sqe;
struct io_uring_cqe {
__u64 user_data;
__s32 res;
__u32 flags;
};
struct io_sqring_offsets {
__u32 head;
__u32 tail;
__u32 ring_mask;
__u32 ring_entries;
__u32 flags;
__u32 dropped;
__u32 array;
__u32 resv1;
__u64 user_addr;
};
struct io_cqring_offsets {
__u32 head;
__u32 tail;
__u32 ring_mask;
__u32 ring_entries;
__u32 overflow;
__u32 cqes;
__u32 flags;
__u32 resv1;
__u64 user_addr;
};
struct io_uring_params {
__u32 sq_entries;
__u32 cq_entries;
__u32 flags;
__u32 sq_thread_cpu;
__u32 sq_thread_idle;
__u32 features;
__u32 wq_fd;
__u32 resv[3];
struct io_sqring_offsets sq_off;
struct io_cqring_offsets cq_off;
};
#endif // __has_include(<linux/io_uring.h>)
#ifndef SWIFT_IORING_C_WRAPPER
#define SWIFT_IORING_C_WRAPPER
# ifndef __NR_io_uring_setup
# define __NR_io_uring_setup 425
# endif
# ifndef __NR_io_uring_enter
# define __NR_io_uring_enter 426
# endif
# ifndef __NR_io_uring_register
# define __NR_io_uring_register 427
# endif
/*
struct io_uring_getevents_arg {
__u64 sigmask;
__u32 sigmask_sz;
__u32 min_wait_usec; //used to be called `pad`. This compatibility wrapper avoids dealing with that.
__u64 ts;
};
*/
struct swift_io_uring_getevents_arg {
__u64 sigmask;
__u32 sigmask_sz;
__u32 min_wait_usec;
__u64 ts;
};
static inline int io_uring_register(int fd, unsigned int opcode, void *arg,
unsigned int nr_args)
{
return syscall(__NR_io_uring_register, fd, opcode, arg, nr_args);
}
static inline int io_uring_setup(unsigned int entries, struct io_uring_params *p)
{
return syscall(__NR_io_uring_setup, entries, p);
}
static inline int io_uring_enter2(int fd, unsigned int to_submit, unsigned int min_complete,
unsigned int flags, void *args, size_t sz)
{
return syscall(__NR_io_uring_enter, fd, to_submit, min_complete,
flags, args, _NSIG / 8);
}
static inline int io_uring_enter(int fd, unsigned int to_submit, unsigned int min_complete,
unsigned int flags, sigset_t *sig)
{
return io_uring_enter2(fd, to_submit, min_complete, flags, sig, _NSIG / 8);
}
#endif
+6
View File
@@ -0,0 +1,6 @@
module CSystem {
header "CSystemLinux.h"
header "CSystemWASI.h"
header "CSystemWindows.h"
export *
}
+5 -1
View File
@@ -11,4 +11,8 @@
#include <CSystemLinux.h>
#endif
#endif
#if defined(_WIN32)
#include <CSystemWindows.h>
#endif
+50
View File
@@ -0,0 +1,50 @@
#[[
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
#]]
add_library(SystemPackage
Errno.swift
FileDescriptor.swift
FileHelpers.swift
FileOperations.swift
FilePermissions.swift
MachPort.swift
PlatformString.swift
SystemString.swift
Util.swift
Util+StringArray.swift
UtilConsumers.swift)
set_target_properties(SystemPackage PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_Swift_MODULE_DIRECTORY})
target_sources(SystemPackage PRIVATE
FilePath/FilePath.swift
FilePath/FilePathComponents.swift
FilePath/FilePathComponentView.swift
FilePath/FilePathParsing.swift
FilePath/FilePathString.swift
FilePath/FilePathSyntax.swift
FilePath/FilePathWindows.swift)
target_sources(SystemPackage PRIVATE
Internals/Backcompat.swift
Internals/CInterop.swift
Internals/Constants.swift
Internals/Exports.swift
Internals/Mocking.swift
Internals/RawBuffer.swift
Internals/Syscalls.swift
Internals/WindowsSyscallAdapters.swift)
target_link_libraries(SystemPackage PUBLIC
CSystem)
set(SWIFT_SYSTEM_APPLE_PLATFORMS "Darwin" "iOS" "watchOS" "tvOS" "visionOS")
if(CMAKE_SYSTEM_NAME IN_LIST SWIFT_SYSTEM_APPLE_PLATFORMS)
target_compile_definitions(SystemPackage PRIVATE SYSTEM_PACKAGE_DARWIN)
endif()
_install_target(SystemPackage)
set_property(GLOBAL APPEND PROPERTY SWIFT_SYSTEM_EXPORTS SystemPackage)
@@ -1,427 +0,0 @@
/*
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
*/
#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
// For platform constants redefined in Swift. We redefine them here so that they
// can be @_alwaysEmitIntoClient without depending on Darwin or re-including a
// header (and applying attributes).
// MARK: errno
@_alwaysEmitIntoClient
internal var _ERRNO_NOT_USED: CInt { 0 }
@_alwaysEmitIntoClient
internal var _EPERM: CInt { 1 }
@_alwaysEmitIntoClient
internal var _ENOENT: CInt { 2 }
@_alwaysEmitIntoClient
internal var _ESRCH: CInt { 3 }
@_alwaysEmitIntoClient
internal var _EINTR: CInt { 4 }
@_alwaysEmitIntoClient
internal var _EIO: CInt { 5 }
@_alwaysEmitIntoClient
internal var _ENXIO: CInt { 6 }
@_alwaysEmitIntoClient
internal var _E2BIG: CInt { 7 }
@_alwaysEmitIntoClient
internal var _ENOEXEC: CInt { 8 }
@_alwaysEmitIntoClient
internal var _EBADF: CInt { 9 }
@_alwaysEmitIntoClient
internal var _ECHILD: CInt { 10 }
@_alwaysEmitIntoClient
internal var _EDEADLK: CInt { 11 }
@_alwaysEmitIntoClient
internal var _ENOMEM: CInt { 12 }
@_alwaysEmitIntoClient
internal var _EACCES: CInt { 13 }
@_alwaysEmitIntoClient
internal var _EFAULT: CInt { 14 }
@_alwaysEmitIntoClient
internal var _ENOTBLK: CInt { 15 }
@_alwaysEmitIntoClient
internal var _EBUSY: CInt { 16 }
@_alwaysEmitIntoClient
internal var _EEXIST: CInt { 17 }
@_alwaysEmitIntoClient
internal var _EXDEV: CInt { 18 }
@_alwaysEmitIntoClient
internal var _ENODEV: CInt { 19 }
@_alwaysEmitIntoClient
internal var _ENOTDIR: CInt { 20 }
@_alwaysEmitIntoClient
internal var _EISDIR: CInt { 21 }
@_alwaysEmitIntoClient
internal var _EINVAL: CInt { 22 }
@_alwaysEmitIntoClient
internal var _ENFILE: CInt { 23 }
@_alwaysEmitIntoClient
internal var _EMFILE: CInt { 24 }
@_alwaysEmitIntoClient
internal var _ENOTTY: CInt { 25 }
@_alwaysEmitIntoClient
internal var _ETXTBSY: CInt { 26 }
@_alwaysEmitIntoClient
internal var _EFBIG: CInt { 27 }
@_alwaysEmitIntoClient
internal var _ENOSPC: CInt { 28 }
@_alwaysEmitIntoClient
internal var _ESPIPE: CInt { 29 }
@_alwaysEmitIntoClient
internal var _EROFS: CInt { 30 }
@_alwaysEmitIntoClient
internal var _EMLINK: CInt { 31 }
@_alwaysEmitIntoClient
internal var _EPIPE: CInt { 32 }
@_alwaysEmitIntoClient
internal var _EDOM: CInt { 33 }
@_alwaysEmitIntoClient
internal var _ERANGE: CInt { 34 }
@_alwaysEmitIntoClient
internal var _EAGAIN: CInt { 35 }
@_alwaysEmitIntoClient
internal var _EWOULDBLOCK: CInt { _EAGAIN }
@_alwaysEmitIntoClient
internal var _EINPROGRESS: CInt { 36 }
@_alwaysEmitIntoClient
internal var _EALREADY: CInt { 37 }
@_alwaysEmitIntoClient
internal var _ENOTSOCK: CInt { 38 }
@_alwaysEmitIntoClient
internal var _EDESTADDRREQ: CInt { 39 }
@_alwaysEmitIntoClient
internal var _EMSGSIZE: CInt { 40 }
@_alwaysEmitIntoClient
internal var _EPROTOTYPE: CInt { 41 }
@_alwaysEmitIntoClient
internal var _ENOPROTOOPT: CInt { 42 }
@_alwaysEmitIntoClient
internal var _EPROTONOSUPPORT: CInt { 43 }
@_alwaysEmitIntoClient
internal var _ESOCKTNOSUPPORT: CInt { 44 }
@_alwaysEmitIntoClient
internal var _ENOTSUP: CInt { 45 }
@_alwaysEmitIntoClient
internal var _EPFNOSUPPORT: CInt { 46 }
@_alwaysEmitIntoClient
internal var _EAFNOSUPPORT: CInt { 47 }
@_alwaysEmitIntoClient
internal var _EADDRINUSE: CInt { 48 }
@_alwaysEmitIntoClient
internal var _EADDRNOTAVAIL: CInt { 49 }
@_alwaysEmitIntoClient
internal var _ENETDOWN: CInt { 50 }
@_alwaysEmitIntoClient
internal var _ENETUNREACH: CInt { 51 }
@_alwaysEmitIntoClient
internal var _ENETRESET: CInt { 52 }
@_alwaysEmitIntoClient
internal var _ECONNABORTED: CInt { 53 }
@_alwaysEmitIntoClient
internal var _ECONNRESET: CInt { 54 }
@_alwaysEmitIntoClient
internal var _ENOBUFS: CInt { 55 }
@_alwaysEmitIntoClient
internal var _EISCONN: CInt { 56 }
@_alwaysEmitIntoClient
internal var _ENOTCONN: CInt { 57 }
@_alwaysEmitIntoClient
internal var _ESHUTDOWN: CInt { 58 }
@_alwaysEmitIntoClient
internal var _ETOOMANYREFS: CInt { 59 }
@_alwaysEmitIntoClient
internal var _ETIMEDOUT: CInt { 60 }
@_alwaysEmitIntoClient
internal var _ECONNREFUSED: CInt { 61 }
@_alwaysEmitIntoClient
internal var _ELOOP: CInt { 62 }
@_alwaysEmitIntoClient
internal var _ENAMETOOLONG: CInt { 63 }
@_alwaysEmitIntoClient
internal var _EHOSTDOWN: CInt { 64 }
@_alwaysEmitIntoClient
internal var _EHOSTUNREACH: CInt { 65 }
@_alwaysEmitIntoClient
internal var _ENOTEMPTY: CInt { 66 }
@_alwaysEmitIntoClient
internal var _EPROCLIM: CInt { 67 }
@_alwaysEmitIntoClient
internal var _EUSERS: CInt { 68 }
@_alwaysEmitIntoClient
internal var _EDQUOT: CInt { 69 }
@_alwaysEmitIntoClient
internal var _ESTALE: CInt { 70 }
@_alwaysEmitIntoClient
internal var _EREMOTE: CInt { 71 }
@_alwaysEmitIntoClient
internal var _EBADRPC: CInt { 72 }
@_alwaysEmitIntoClient
internal var _ERPCMISMATCH: CInt { 73 }
@_alwaysEmitIntoClient
internal var _EPROGUNAVAIL: CInt { 74 }
@_alwaysEmitIntoClient
internal var _EPROGMISMATCH: CInt { 75 }
@_alwaysEmitIntoClient
internal var _EPROCUNAVAIL: CInt { 76 }
@_alwaysEmitIntoClient
internal var _ENOLCK: CInt { 77 }
@_alwaysEmitIntoClient
internal var _ENOSYS: CInt { 78 }
@_alwaysEmitIntoClient
internal var _EFTYPE: CInt { 79 }
@_alwaysEmitIntoClient
internal var _EAUTH: CInt { 80 }
@_alwaysEmitIntoClient
internal var _ENEEDAUTH: CInt { 81 }
@_alwaysEmitIntoClient
internal var _EPWROFF: CInt { 82 }
@_alwaysEmitIntoClient
internal var _EDEVERR: CInt { 83 }
@_alwaysEmitIntoClient
internal var _EOVERFLOW: CInt { 84 }
@_alwaysEmitIntoClient
internal var _EBADEXEC: CInt { 85 }
@_alwaysEmitIntoClient
internal var _EBADARCH: CInt { 86 }
@_alwaysEmitIntoClient
internal var _ESHLIBVERS: CInt { 87 }
@_alwaysEmitIntoClient
internal var _EBADMACHO: CInt { 88 }
@_alwaysEmitIntoClient
internal var _ECANCELED: CInt { 89 }
@_alwaysEmitIntoClient
internal var _EIDRM: CInt { 90 }
@_alwaysEmitIntoClient
internal var _ENOMSG: CInt { 91 }
@_alwaysEmitIntoClient
internal var _EILSEQ: CInt { 92 }
@_alwaysEmitIntoClient
internal var _ENOATTR: CInt { 93 }
@_alwaysEmitIntoClient
internal var _EBADMSG: CInt { 94 }
@_alwaysEmitIntoClient
internal var _EMULTIHOP: CInt { 95 }
@_alwaysEmitIntoClient
internal var _ENODATA: CInt { 96 }
@_alwaysEmitIntoClient
internal var _ENOLINK: CInt { 97 }
@_alwaysEmitIntoClient
internal var _ENOSR: CInt { 98 }
@_alwaysEmitIntoClient
internal var _ENOSTR: CInt { 99 }
@_alwaysEmitIntoClient
internal var _EPROTO: CInt { 100 }
@_alwaysEmitIntoClient
internal var _ETIME: CInt { 101 }
@_alwaysEmitIntoClient
internal var _EOPNOTSUPP: CInt { 102 }
@_alwaysEmitIntoClient
internal var _ENOPOLICY: CInt { 103 }
@_alwaysEmitIntoClient
internal var _ENOTRECOVERABLE: CInt { 104 }
@_alwaysEmitIntoClient
internal var _EOWNERDEAD: CInt { 105 }
@_alwaysEmitIntoClient
internal var _EQFULL: CInt { 106 }
@_alwaysEmitIntoClient
internal var _ELAST: CInt { 106 }
// MARK: File Operations
@_alwaysEmitIntoClient
internal var _O_RDONLY: CInt { 0x0000 }
@_alwaysEmitIntoClient
internal var _O_WRONLY: CInt { 0x0001 }
@_alwaysEmitIntoClient
internal var _O_RDWR: CInt { 0x0002 }
// TODO: API?
@_alwaysEmitIntoClient
internal var _O_ACCMODE: CInt { 0x0003 }
@_alwaysEmitIntoClient
internal var _O_NONBLOCK: CInt { 0x0004 }
@_alwaysEmitIntoClient
internal var _O_APPEND: CInt { 0x0008 }
@_alwaysEmitIntoClient
internal var _O_SHLOCK: CInt { 0x0010 }
@_alwaysEmitIntoClient
internal var _O_EXLOCK: CInt { 0x0020 }
// TODO: API?
@_alwaysEmitIntoClient
internal var _O_ASYNC: CInt { 0x0040 }
@_alwaysEmitIntoClient
internal var _O_NOFOLLOW: CInt { 0x0100 }
@_alwaysEmitIntoClient
internal var _O_CREAT: CInt { 0x0200 }
@_alwaysEmitIntoClient
internal var _O_TRUNC: CInt { 0x0400 }
@_alwaysEmitIntoClient
internal var _O_EXCL: CInt { 0x0800 }
@_alwaysEmitIntoClient
internal var _O_EVTONLY: CInt { 0x8000 }
// TODO: API?
@_alwaysEmitIntoClient
internal var _O_NOCTTY: CInt { 0x20000 }
// TODO: API?
@_alwaysEmitIntoClient
internal var _O_DIRECTORY: CInt { 0x100000 }
@_alwaysEmitIntoClient
internal var _O_SYMLINK: CInt { 0x200000 }
@_alwaysEmitIntoClient
internal var _O_CLOEXEC: CInt { 0x1000000 }
// TODO: API?
@_alwaysEmitIntoClient
internal var _O_DP_GETRAWENCRYPTED: CInt { 0x0001 }
// TODO: API?
@_alwaysEmitIntoClient
internal var _O_DP_GETRAWUNENCRYPTED: CInt { 0x0002 }
@_alwaysEmitIntoClient
internal var _SEEK_SET: CInt { 0 }
@_alwaysEmitIntoClient
internal var _SEEK_CUR: CInt { 1 }
@_alwaysEmitIntoClient
internal var _SEEK_END: CInt { 2 }
@_alwaysEmitIntoClient
internal var _SEEK_HOLE: CInt { 3 }
@_alwaysEmitIntoClient
internal var _SEEK_DATA: CInt { 4 }
#endif
+207 -134
View File
File diff suppressed because it is too large. Load diff
+20
View File
@@ -0,0 +1,20 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2024 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
*/
#if os(Windows)
import WinSDK
extension Errno {
internal init(windowsError: DWORD) {
self.init(rawValue: _mapWindowsErrorToErrno(windowsError))
}
}
#endif
+127 -34
View File
@@ -1,7 +1,7 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 Apple Inc. and the Swift System project authors
Copyright (c) 2020 - 2021 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
@@ -14,8 +14,8 @@
/// of `FileDescriptor` values,
/// in the same way as you manage a raw C file handle.
@frozen
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
public struct FileDescriptor: RawRepresentable, Hashable, Codable {
@available(System 0.0.1, *)
public struct FileDescriptor: RawRepresentable, Hashable {
/// The raw C file handle.
@_alwaysEmitIntoClient
public let rawValue: CInt
@@ -25,11 +25,28 @@ public struct FileDescriptor: RawRepresentable, Hashable, Codable {
public init(rawValue: CInt) { self.rawValue = rawValue }
}
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
// Standard file descriptors.
@available(System 0.0.1, *)
extension FileDescriptor {
/// The standard input file descriptor, with a numeric value of 0.
@_alwaysEmitIntoClient
public static var standardInput: FileDescriptor { .init(rawValue: 0) }
/// The standard output file descriptor, with a numeric value of 1.
@_alwaysEmitIntoClient
public static var standardOutput: FileDescriptor { .init(rawValue: 1) }
/// The standard error file descriptor, with a numeric value of 2.
@_alwaysEmitIntoClient
public static var standardError: FileDescriptor { .init(rawValue: 2) }
}
@available(System 0.0.1, *)
extension FileDescriptor {
/// The desired read and write access for a newly opened file.
@frozen
public struct AccessMode: RawRepresentable, Hashable, Codable {
@available(System 0.0.1, *)
public struct AccessMode: RawRepresentable, Sendable, Hashable {
/// The raw C access mode.
@_alwaysEmitIntoClient
public var rawValue: CInt
@@ -71,7 +88,8 @@ extension FileDescriptor {
/// Options that specify behavior for a newly-opened file.
@frozen
public struct OpenOptions: OptionSet, Hashable, Codable {
@available(System 0.0.1, *)
public struct OpenOptions: OptionSet, Sendable, Hashable {
/// The raw C options.
@_alwaysEmitIntoClient
public var rawValue: CInt
@@ -80,9 +98,7 @@ extension FileDescriptor {
@_alwaysEmitIntoClient
public init(rawValue: CInt) { self.rawValue = rawValue }
@_alwaysEmitIntoClient
private init(_ raw: CInt) { self.init(rawValue: raw) }
#if !os(Windows)
/// Indicates that opening the file doesn't
/// wait for the file or device to become available.
///
@@ -90,7 +106,7 @@ extension FileDescriptor {
/// the system doesn't wait for the device or file
/// to be ready or available.
/// If the
/// <doc:System/FileDescriptor/open(_:_:options:permissions:)-10dcs>
/// <doc:FileDescriptor/open(_:_:options:permissions:retryOnInterrupt:)-2266j>
/// call would result in the process being blocked for some reason,
/// that method returns immediately.
/// This flag also has the effect of making all
@@ -98,11 +114,12 @@ extension FileDescriptor {
///
/// The corresponding C constant is `O_NONBLOCK`.
@_alwaysEmitIntoClient
public static var nonBlocking: OpenOptions { OpenOptions(_O_NONBLOCK) }
public static var nonBlocking: OpenOptions { .init(rawValue: _O_NONBLOCK) }
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "nonBlocking")
public static var O_NONBLOCK: OpenOptions { nonBlocking }
#endif
/// Indicates that each write operation appends to the file.
///
@@ -113,7 +130,7 @@ extension FileDescriptor {
///
/// The corresponding C constant is `O_APPEND`.
@_alwaysEmitIntoClient
public static var append: OpenOptions { OpenOptions(_O_APPEND) }
public static var append: OpenOptions { .init(rawValue: _O_APPEND) }
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "append")
@@ -123,7 +140,7 @@ extension FileDescriptor {
///
/// The corresponding C constant is `O_CREAT`.
@_alwaysEmitIntoClient
public static var create: OpenOptions { OpenOptions(_O_CREAT) }
public static var create: OpenOptions { .init(rawValue: _O_CREAT) }
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "create")
@@ -137,7 +154,7 @@ extension FileDescriptor {
///
/// The corresponding C constant is `O_TRUNC`.
@_alwaysEmitIntoClient
public static var truncate: OpenOptions { OpenOptions(_O_TRUNC) }
public static var truncate: OpenOptions { .init(rawValue: _O_TRUNC) }
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "truncate")
@@ -147,25 +164,25 @@ extension FileDescriptor {
/// expecting that it doesn't exist.
///
/// If this option and ``create`` are both specified and the file exists,
/// <doc:System/FileDescriptor/open(_:_:options:permissions:)-10dcs>
/// <doc:FileDescriptor/open(_:_:options:permissions:retryOnInterrupt:)-2266j>
/// returns an error instead of creating the file.
/// You can use this, for example,
/// to implement a simple exclusive-access locking mechanism.
///
/// If this option and ``create`` are both specified
/// and the last component of the file's path is a symbolic link,
/// <doc:System/FileDescriptor/open(_:_:options:permissions:)-10dcs>
/// <doc:FileDescriptor/open(_:_:options:permissions:retryOnInterrupt:)-2266j>
/// fails even if the symbolic link points to a nonexistent name.
///
/// The corresponding C constant is `O_EXCL`.
@_alwaysEmitIntoClient
public static var exclusiveCreate: OpenOptions { OpenOptions(_O_EXCL) }
public static var exclusiveCreate: OpenOptions { .init(rawValue: _O_EXCL) }
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "exclusiveCreate")
public static var O_EXCL: OpenOptions { exclusiveCreate }
#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
/// Indicates that opening the file
/// atomically obtains a shared lock on the file.
///
@@ -177,7 +194,7 @@ extension FileDescriptor {
///
/// The corresponding C constant is `O_SHLOCK`.
@_alwaysEmitIntoClient
public static var sharedLock: OpenOptions { OpenOptions(_O_SHLOCK) }
public static var sharedLock: OpenOptions { .init(rawValue: _O_SHLOCK) }
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "sharedLock")
@@ -194,42 +211,74 @@ extension FileDescriptor {
///
/// The corresponding C constant is `O_EXLOCK`.
@_alwaysEmitIntoClient
public static var exclusiveLock: OpenOptions { OpenOptions(_O_EXLOCK) }
public static var exclusiveLock: OpenOptions { .init(rawValue: _O_EXLOCK) }
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "exclusiveLock")
public static var O_EXLOCK: OpenOptions { exclusiveLock }
#endif
#if !os(Windows)
/// Indicates that opening the file doesn't follow symlinks.
///
/// If you specify this option
/// and the file path you pass to
/// <doc:System/FileDescriptor/open(_:_:options:permissions:)-10dcs>
/// <doc:FileDescriptor/open(_:_:options:permissions:retryOnInterrupt:)-2266j>
/// is a symbolic link,
/// then that open operation fails.
///
/// The corresponding C constant is `O_NOFOLLOW`.
@_alwaysEmitIntoClient
public static var noFollow: OpenOptions { OpenOptions(_O_NOFOLLOW) }
public static var noFollow: OpenOptions { .init(rawValue: _O_NOFOLLOW) }
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "noFollow")
public static var O_NOFOLLOW: OpenOptions { noFollow }
#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
/// Indicates that opening the file only succeeds if the file is a directory.
///
/// If you specify this option and the file path you pass to
/// <doc:FileDescriptor/open(_:_:options:permissions:retryOnInterrupt:)-2266j>
/// is a not a directory, then that open operation fails.
///
/// The corresponding C constant is `O_DIRECTORY`.
@_alwaysEmitIntoClient
public static var directory: OpenOptions { .init(rawValue: _O_DIRECTORY) }
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "directory")
public static var O_DIRECTORY: OpenOptions { directory }
#endif
#if os(FreeBSD)
/// Indicates that each write operation is synchronous.
///
/// If this option is specified,
/// each time you write to the file,
/// the new data is written immediately and synchronously to the disk.
///
/// The corresponding C constant is `O_SYNC`.
@_alwaysEmitIntoClient
public static var sync: OpenOptions { .init(rawValue: _O_SYNC) }
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "sync")
public static var O_SYNC: OpenOptions { sync }
#endif
#if SYSTEM_PACKAGE_DARWIN
/// Indicates that opening the file
/// opens symbolic links instead of following them.
///
/// If you specify this option
/// and the file path you pass to
/// <doc:System/FileDescriptor/open(_:_:options:permissions:)-10dcs>
/// <doc:FileDescriptor/open(_:_:options:permissions:retryOnInterrupt:)-2266j>
/// is a symbolic link,
/// then the link itself is opened instead of what it links to.
///
/// The corresponding C constant is `O_SYMLINK`.
@_alwaysEmitIntoClient
public static var symlink: OpenOptions { OpenOptions(_O_SYMLINK) }
public static var symlink: OpenOptions { .init(rawValue: _O_SYMLINK) }
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "symlink")
@@ -245,13 +294,14 @@ extension FileDescriptor {
///
/// The corresponding C constant is `O_EVTONLY`.
@_alwaysEmitIntoClient
public static var eventOnly: OpenOptions { OpenOptions(_O_EVTONLY) }
public static var eventOnly: OpenOptions { .init(rawValue: _O_EVTONLY) }
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "eventOnly")
public static var O_EVTONLY: OpenOptions { eventOnly }
#endif
#if !os(Windows)
/// Indicates that executing a program closes the file.
///
/// Normally, file descriptors remain open
@@ -266,16 +316,18 @@ extension FileDescriptor {
///
/// The corresponding C constant is `O_CLOEXEC`.
@_alwaysEmitIntoClient
public static var closeOnExec: OpenOptions { OpenOptions(_O_CLOEXEC) }
public static var closeOnExec: OpenOptions { .init(rawValue: _O_CLOEXEC) }
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "closeOnExec")
public static var O_CLOEXEC: OpenOptions { closeOnExec }
#endif
}
/// Options for specifying what a file descriptor's offset is relative to.
@frozen
public struct SeekOrigin: RawRepresentable, Hashable, Codable {
@available(System 0.0.1, *)
public struct SeekOrigin: RawRepresentable, Sendable, Hashable {
/// The raw C value.
@_alwaysEmitIntoClient
public var rawValue: CInt
@@ -318,7 +370,7 @@ extension FileDescriptor {
// TODO: These are available on some versions of Linux with appropriate
// macro defines.
#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
/// Indicates that the offset should be set
/// to the next hole after the specified number of bytes.
///
@@ -350,7 +402,23 @@ extension FileDescriptor {
}
}
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
#if !$Embedded
@available(System 0.0.1, *)
extension FileDescriptor: Codable {}
@available(System 0.0.1, *)
extension FileDescriptor.AccessMode: Codable {}
@available(System 0.0.1, *)
extension FileDescriptor.OpenOptions: Codable {}
@available(System 0.0.1, *)
extension FileDescriptor.SeekOrigin: Codable {}
#endif // !$Embedded
@available(System 0.0.1, *)
extension FileDescriptor.AccessMode
: CustomStringConvertible, CustomDebugStringConvertible
{
@@ -369,7 +437,7 @@ extension FileDescriptor.AccessMode
public var debugDescription: String { self.description }
}
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
@available(System 0.0.1, *)
extension FileDescriptor.SeekOrigin
: CustomStringConvertible, CustomDebugStringConvertible
{
@@ -380,7 +448,7 @@ extension FileDescriptor.SeekOrigin
case .start: return "start"
case .current: return "current"
case .end: return "end"
#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
#if SYSTEM_PACKAGE_DARWIN
case .nextHole: return "nextHole"
case .nextData: return "nextData"
#endif
@@ -392,14 +460,14 @@ extension FileDescriptor.SeekOrigin
public var debugDescription: String { self.description }
}
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
@available(System 0.0.1, *)
extension FileDescriptor.OpenOptions
: CustomStringConvertible, CustomDebugStringConvertible
{
/// A textual representation of the open options.
@inline(never)
public var description: String {
#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
#if SYSTEM_PACKAGE_DARWIN
let descriptions: [(Element, StaticString)] = [
(.nonBlocking, ".nonBlocking"),
(.append, ".append"),
@@ -413,6 +481,26 @@ extension FileDescriptor.OpenOptions
(.eventOnly, ".eventOnly"),
(.closeOnExec, ".closeOnExec")
]
#elseif os(Windows)
let descriptions: [(Element, StaticString)] = [
(.append, ".append"),
(.create, ".create"),
(.truncate, ".truncate"),
(.exclusiveCreate, ".exclusiveCreate"),
]
#elseif os(FreeBSD)
let descriptions: [(Element, StaticString)] = [
(.nonBlocking, ".nonBlocking"),
(.append, ".append"),
(.create, ".create"),
(.truncate, ".truncate"),
(.exclusiveCreate, ".exclusiveCreate"),
(.sharedLock, ".sharedLock"),
(.exclusiveLock, ".exclusiveLock"),
(.sync, ".sync"),
(.noFollow, ".noFollow"),
(.closeOnExec, ".closeOnExec")
]
#else
let descriptions: [(Element, StaticString)] = [
(.nonBlocking, ".nonBlocking"),
@@ -431,3 +519,8 @@ extension FileDescriptor.OpenOptions
/// A textual representation of the open options, suitable for debugging.
public var debugDescription: String { self.description }
}
// The decision on whether to make FileDescriptor Sendable or not
// is currently being discussed in https://github.com/apple/swift-system/pull/112
//@available(*, unavailable, message: "File descriptors are not completely thread-safe.")
//extension FileDescriptor: Sendable {}
+1 -4
View File
@@ -7,7 +7,7 @@
See https://swift.org/LICENSE.txt for license information
*/
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
@available(System 0.0.1, *)
extension FileDescriptor {
/// Runs a closure and then closes the file descriptor, even if an error occurs.
///
@@ -46,9 +46,6 @@ extension FileDescriptor {
/// increments that position by the number of bytes written.
/// See also ``seek(offset:from:)``.
///
/// This method either writes the entire contents of `sequence`,
/// or throws an error if only part of the content was written.
///
/// If `sequence` doesn't implement
/// the <doc://com.apple.documentation/documentation/swift/sequence/3128824-withcontiguousstorageifavailable> method,
/// temporary space will be allocated as needed.
+270 -29
View File
@@ -1,15 +1,13 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 Apple Inc. and the Swift System project authors
Copyright (c) 2020 - 2025 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
*/
@_implementationOnly import SystemInternals
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
@available(System 0.0.1, *)
extension FileDescriptor {
/// Opens or creates a file for reading or writing.
///
@@ -32,13 +30,24 @@ extension FileDescriptor {
options: FileDescriptor.OpenOptions = FileDescriptor.OpenOptions(),
permissions: FilePermissions? = nil,
retryOnInterrupt: Bool = true
) throws -> FileDescriptor {
try path.withCString {
) throws(SystemError) -> FileDescriptor {
#if !os(Windows)
return try path.withCString { (cString) throws(SystemError) in
try FileDescriptor.open(
$0, mode, options: options, permissions: permissions, retryOnInterrupt: retryOnInterrupt)
cString, mode, options: options, permissions: permissions, retryOnInterrupt: retryOnInterrupt)
}
#else
return try path.withPlatformString { (platformString) throws(SystemError) in
try FileDescriptor.open(
platformString, mode, options: options, permissions: permissions, retryOnInterrupt: retryOnInterrupt)
}
#endif
}
#if !os(Windows)
// On Darwin, `CInterop.PlatformChar` is less available than
// `FileDescriptor.open`, so we need to use `CChar` instead.
/// Opens or creates a file for reading or writing.
///
/// - Parameters:
@@ -60,7 +69,7 @@ extension FileDescriptor {
options: FileDescriptor.OpenOptions = FileDescriptor.OpenOptions(),
permissions: FilePermissions? = nil,
retryOnInterrupt: Bool = true
) throws -> FileDescriptor {
) throws(SystemError) -> FileDescriptor {
try FileDescriptor._open(
path, mode, options: options, permissions: permissions, retryOnInterrupt: retryOnInterrupt
).get()
@@ -72,7 +81,7 @@ extension FileDescriptor {
_ mode: FileDescriptor.AccessMode,
options: FileDescriptor.OpenOptions,
permissions: FilePermissions?,
retryOnInterrupt: Bool = true
retryOnInterrupt: Bool
) -> Result<FileDescriptor, Errno> {
let oFlag = mode.rawValue | options.rawValue
let descOrError: Result<CInt, Errno> = valueOrErrno(retryOnInterrupt: retryOnInterrupt) {
@@ -85,6 +94,52 @@ extension FileDescriptor {
}
return descOrError.map { FileDescriptor(rawValue: $0) }
}
#else
/// Opens or creates a file for reading or writing.
///
/// - Parameters:
/// - path: The location of the file to open.
/// - mode: The read and write access to use.
/// - options: The behavior for opening the file.
/// - permissions: The file permissions to use for created files.
/// - retryOnInterrupt: Whether to retry the open operation
/// if it throws ``Errno/interrupted``.
/// The default is `true`.
/// Pass `false` to try only once and throw an error upon interruption.
/// - Returns: A file descriptor for the open file
///
/// The corresponding C function is `open`.
@_alwaysEmitIntoClient
public static func open(
_ path: UnsafePointer<CInterop.PlatformChar>,
_ mode: FileDescriptor.AccessMode,
options: FileDescriptor.OpenOptions = FileDescriptor.OpenOptions(),
permissions: FilePermissions? = nil,
retryOnInterrupt: Bool = true
) throws(SystemError) -> FileDescriptor {
try FileDescriptor._open(
path, mode, options: options, permissions: permissions, retryOnInterrupt: retryOnInterrupt
).get()
}
@usableFromInline
internal static func _open(
_ path: UnsafePointer<CInterop.PlatformChar>,
_ mode: FileDescriptor.AccessMode,
options: FileDescriptor.OpenOptions,
permissions: FilePermissions?,
retryOnInterrupt: Bool
) -> Result<FileDescriptor, Errno> {
let oFlag = mode.rawValue | options.rawValue
let descOrError: Result<CInt, Errno> = valueOrErrno(retryOnInterrupt: retryOnInterrupt) {
if let permissions = permissions {
return system_open(path, oFlag, permissions.rawValue)
}
return system_open(path, oFlag)
}
return descOrError.map { FileDescriptor(rawValue: $0) }
}
#endif
/// Deletes a file descriptor.
///
@@ -94,14 +149,14 @@ extension FileDescriptor {
///
/// The corresponding C function is `close`.
@_alwaysEmitIntoClient
public func close() throws { try _close().get() }
public func close() throws(SystemError) { try _close().get() }
@usableFromInline
internal func _close() -> Result<(), Errno> {
nothingOrErrno(system_close(self.rawValue))
nothingOrErrno(retryOnInterrupt: false) { system_close(self.rawValue) }
}
/// Reposition the offset for the given file descriptor.
/// Repositions the offset for the given file descriptor.
///
/// - Parameters:
/// - offset: The new offset for the file descriptor.
@@ -114,7 +169,7 @@ extension FileDescriptor {
@discardableResult
public func seek(
offset: Int64, from whence: FileDescriptor.SeekOrigin
) throws -> Int64 {
) throws(SystemError) -> Int64 {
try _seek(offset: offset, from: whence).get()
}
@@ -122,8 +177,9 @@ extension FileDescriptor {
internal func _seek(
offset: Int64, from whence: FileDescriptor.SeekOrigin
) -> Result<Int64, Errno> {
let newOffset = system_lseek(self.rawValue, COffT(offset), whence.rawValue)
return valueOrErrno(Int64(newOffset))
valueOrErrno(retryOnInterrupt: false) {
Int64(system_lseek(self.rawValue, _COffT(offset), whence.rawValue))
}
}
@@ -131,7 +187,7 @@ extension FileDescriptor {
@available(*, unavailable, renamed: "seek")
public func lseek(
offset: Int64, from whence: FileDescriptor.SeekOrigin
) throws -> Int64 {
) throws(SystemError) -> Int64 {
try seek(offset: offset, from: whence)
}
@@ -145,7 +201,7 @@ extension FileDescriptor {
/// Pass `false` to try only once and throw an error upon interruption.
/// - Returns: The number of bytes that were read.
///
/// The <doc://com.apple.documentation/documentation/swift/unsafemutablerawbufferpointer/3019191-count> property of `buffer`
/// The <doc://com.apple.documentation/documentation/swift/unsafemutablerawbufferpointer/count-95usp> property of `buffer`
/// determines the maximum number of bytes that are read into that buffer.
///
/// After reading,
@@ -158,15 +214,15 @@ extension FileDescriptor {
public func read(
into buffer: UnsafeMutableRawBufferPointer,
retryOnInterrupt: Bool = true
) throws -> Int {
) throws(SystemError) -> Int {
try _read(into: buffer, retryOnInterrupt: retryOnInterrupt).get()
}
@usableFromInline
internal func _read(
into buffer: UnsafeMutableRawBufferPointer,
retryOnInterrupt: Bool = true
) throws -> Result<Int, Errno> {
retryOnInterrupt: Bool
) throws(SystemError) -> Result<Int, Errno> {
valueOrErrno(retryOnInterrupt: retryOnInterrupt) {
system_read(self.rawValue, buffer.baseAddress, buffer.count)
}
@@ -183,10 +239,10 @@ extension FileDescriptor {
/// Pass `false` to try only once and throw an error upon interruption.
/// - Returns: The number of bytes that were read.
///
/// The <doc://com.apple.documentation/documentation/swift/unsafemutablerawbufferpointer/3019191-count> property of `buffer`
/// The <doc://com.apple.documentation/documentation/swift/unsafemutablerawbufferpointer/count-95usp> property of `buffer`
/// determines the maximum number of bytes that are read into that buffer.
///
/// Unlike <doc:System/FileDescriptor/read(into:retryOnInterrupt:)>,
/// Unlike <doc:FileDescriptor/read(into:retryOnInterrupt:)>,
/// this method leaves the file's existing offset unchanged.
///
/// The corresponding C function is `pread`.
@@ -195,7 +251,7 @@ extension FileDescriptor {
fromAbsoluteOffset offset: Int64,
into buffer: UnsafeMutableRawBufferPointer,
retryOnInterrupt: Bool = true
) throws -> Int {
) throws(SystemError) -> Int {
try _read(
fromAbsoluteOffset: offset,
into: buffer,
@@ -210,7 +266,7 @@ extension FileDescriptor {
retryOnInterrupt: Bool
) -> Result<Int, Errno> {
valueOrErrno(retryOnInterrupt: retryOnInterrupt) {
system_pread(self.rawValue, buffer.baseAddress, buffer.count, COffT(offset))
system_pread(self.rawValue, buffer.baseAddress, buffer.count, _COffT(offset))
}
}
@@ -220,7 +276,7 @@ extension FileDescriptor {
fromAbsoluteOffset offset: Int64,
into buffer: UnsafeMutableRawBufferPointer,
retryOnInterrupt: Bool = true
) throws -> Int {
) throws(SystemError) -> Int {
try read(
fromAbsoluteOffset: offset,
into: buffer,
@@ -247,7 +303,7 @@ extension FileDescriptor {
public func write(
_ buffer: UnsafeRawBufferPointer,
retryOnInterrupt: Bool = true
) throws -> Int {
) throws(SystemError) -> Int {
try _write(buffer, retryOnInterrupt: retryOnInterrupt).get()
}
@@ -281,7 +337,7 @@ extension FileDescriptor {
toAbsoluteOffset offset: Int64,
_ buffer: UnsafeRawBufferPointer,
retryOnInterrupt: Bool = true
) throws -> Int {
) throws(SystemError) -> Int {
try _write(toAbsoluteOffset: offset, buffer, retryOnInterrupt: retryOnInterrupt).get()
}
@@ -292,7 +348,7 @@ extension FileDescriptor {
retryOnInterrupt: Bool
) -> Result<Int, Errno> {
valueOrErrno(retryOnInterrupt: retryOnInterrupt) {
system_pwrite(self.rawValue, buffer.baseAddress, buffer.count, COffT(offset))
system_pwrite(self.rawValue, buffer.baseAddress, buffer.count, _COffT(offset))
}
}
@@ -303,10 +359,195 @@ extension FileDescriptor {
toAbsoluteOffset offset: Int64,
into buffer: UnsafeRawBufferPointer,
retryOnInterrupt: Bool = true
) throws -> Int {
) throws(SystemError) -> Int {
try write(
toAbsoluteOffset: offset,
buffer,
retryOnInterrupt: retryOnInterrupt)
}
}
#if !os(WASI)
@available(System 0.0.2, *)
extension FileDescriptor {
/// Duplicates this file descriptor and return the newly created copy.
///
/// - Parameters:
/// - `target`: The desired target file descriptor, or `nil`, in which case
/// the copy is assigned to the file descriptor with the lowest raw value
/// that is not currently in use by the process.
/// - retryOnInterrupt: Whether to retry the write operation
/// if it throws ``Errno/interrupted``. The default is `true`.
/// Pass `false` to try only once and throw an error upon interruption.
/// - Returns: The new file descriptor.
///
/// If the `target` descriptor is already in use, then it is first
/// deallocated as if a close(2) call had been done first.
///
/// File descriptors are merely references to some underlying system resource.
/// The system does not distinguish between the original and the new file
/// descriptor in any way. For example, read, write and seek operations on
/// one of them also affect the logical file position in the other, and
/// append mode, non-blocking I/O and asynchronous I/O options are shared
/// between the references. If a separate pointer into the file is desired,
/// a different object reference to the file must be obtained by issuing an
/// additional call to `open`.
///
/// However, each file descriptor maintains its own close-on-exec flag.
///
///
/// The corresponding C functions are `dup` and `dup2`.
@_alwaysEmitIntoClient
@available(System 0.0.2, *)
public func duplicate(
as target: FileDescriptor? = nil,
retryOnInterrupt: Bool = true
) throws(SystemError) -> FileDescriptor {
try _duplicate(as: target, retryOnInterrupt: retryOnInterrupt).get()
}
@available(System 0.0.2, *)
@usableFromInline
internal func _duplicate(
as target: FileDescriptor?,
retryOnInterrupt: Bool
) throws(SystemError) -> Result<FileDescriptor, Errno> {
valueOrErrno(retryOnInterrupt: retryOnInterrupt) {
if let target = target {
return system_dup2(self.rawValue, target.rawValue)
}
return system_dup(self.rawValue)
}.map(FileDescriptor.init(rawValue:))
}
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "duplicate")
public func dup() throws(SystemError) -> FileDescriptor {
fatalError("Not implemented")
}
@_alwaysEmitIntoClient
@available(*, unavailable, renamed: "duplicate")
public func dup2() throws(SystemError) -> FileDescriptor {
fatalError("Not implemented")
}
}
#endif
#if !os(WASI)
@available(System 1.1.0, *)
extension FileDescriptor {
/// Creates a unidirectional data channel, which can be used for interprocess communication.
///
/// - Returns: The pair of file descriptors.
///
/// The corresponding C function is `pipe`.
@_alwaysEmitIntoClient
@available(System 1.1.0, *)
public static func pipe() throws(SystemError) -> (readEnd: FileDescriptor, writeEnd: FileDescriptor) {
try _pipe().get()
}
@available(System 1.1.0, *)
@usableFromInline
internal static func _pipe() -> Result<(readEnd: FileDescriptor, writeEnd: FileDescriptor), Errno> {
var fds: (Int32, Int32) = (-1, -1)
return withUnsafeMutablePointer(to: &fds) { pointer in
pointer.withMemoryRebound(to: Int32.self, capacity: 2) { fds in
valueOrErrno(retryOnInterrupt: false) {
system_pipe(fds)
}.map { _ in (.init(rawValue: fds[0]), .init(rawValue: fds[1])) }
}
}
}
}
#endif
@available(System 1.2.0, *)
extension FileDescriptor {
/// Truncates or extends the file referenced by this file descriptor.
///
/// - Parameters:
/// - newSize: The length in bytes to resize the file to.
/// - retryOnInterrupt: Whether to retry the write operation
/// if it throws ``Errno/interrupted``. The default is `true`.
/// Pass `false` to try only once and throw an error upon interruption.
///
/// The file referenced by this file descriptor will by truncated (or extended) to `newSize`.
///
/// If the current size of the file exceeds `newSize`, any extra data is discarded. If the current
/// size of the file is smaller than `newSize`, the file is extended and filled with zeros to the
/// provided size.
///
/// This function requires that the file has been opened for writing.
///
/// - Note: This function does not modify the current offset for any open file descriptors
/// associated with the file.
///
/// The corresponding C function is `ftruncate`.
@available(System 1.2.0, *)
@_alwaysEmitIntoClient
public func resize(
to newSize: Int64,
retryOnInterrupt: Bool = true
) throws(SystemError) {
try _resize(
to: newSize,
retryOnInterrupt: retryOnInterrupt
).get()
}
@available(System 1.2.0, *)
@usableFromInline
internal func _resize(
to newSize: Int64,
retryOnInterrupt: Bool
) -> Result<(), Errno> {
nothingOrErrno(retryOnInterrupt: retryOnInterrupt) {
system_ftruncate(self.rawValue, _COffT(newSize))
}
}
}
#if !os(WASI) // WASI has no umask
extension FilePermissions {
/// The file creation permission mask (aka "umask").
///
/// Permissions set in this mask will be cleared by functions that create
/// files or directories. Note that this mask is process-wide, and that
/// *getting* it is not thread safe.
internal static var creationMask: FilePermissions {
get {
let oldMask = _umask(0o22)
_ = _umask(oldMask)
return FilePermissions(rawValue: oldMask)
}
set {
_ = _umask(newValue.rawValue)
}
}
/// Change the file creation permission mask, run some code, then
/// restore it to its original value.
///
/// - Parameters:
/// - permissions: The new permission mask.
///
/// This is more efficient than reading `creationMask` and restoring it
/// afterwards, because of the way reading the creation mask works.
internal static func withCreationMask<R>(
_ permissions: FilePermissions,
body: () throws(SystemError) -> R
) rethrows -> R {
let oldMask = _umask(permissions.rawValue)
defer {
_ = _umask(oldMask)
}
return try body()
}
internal static func _umask(_ mode: CModeT) -> CModeT {
return system_umask(mode)
}
}
#endif
-210
View File
@@ -1,210 +0,0 @@
/*
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
*/
extension UnsafePointer where Pointee == UInt8 {
internal var _asCChar: UnsafePointer<CChar> {
UnsafeRawPointer(self).assumingMemoryBound(to: CChar.self)
}
}
extension UnsafePointer where Pointee == CChar {
internal var _asUInt8: UnsafePointer<UInt8> {
UnsafeRawPointer(self).assumingMemoryBound(to: UInt8.self)
}
}
extension UnsafeBufferPointer where Element == UInt8 {
internal var _asCChar: UnsafeBufferPointer<CChar> {
let base = baseAddress?._asCChar
return UnsafeBufferPointer<CChar>(start: base, count: self.count)
}
}
extension UnsafeBufferPointer where Element == CChar {
internal var _asUInt8: UnsafeBufferPointer<UInt8> {
let base = baseAddress?._asUInt8
return UnsafeBufferPointer<UInt8>(start: base, count: self.count)
}
}
// NOTE: FilePath not frozen for ABI flexibility
/// A null-terminated sequence of bytes
/// that represents a location in the file system.
///
/// This structure doesn't give any meaning to the bytes that it contains,
/// except for the requirement that the last byte is a NUL (`0x0`).
/// The file system defines how this string is interpreted;
/// for example, by its choice of string encoding.
///
/// The code below creates a file path from a string literal,
/// and then uses it to open and append to a log file:
///
/// let message: String = "This is a log message."
/// let path: FilePath = "/tmp/log"
/// let fd = try FileDescriptor.open(path, .writeOnly, options: .append)
/// try fd.closeAfter { try fd.writeAll(message.utf8) }
///
/// File paths conform to the
/// and <doc://com.apple.documentation/documentation/swift/equatable>
/// and <doc://com.apple.documentation/documentation/swift/hashable> protocols
/// by performing the protocols' operations on their raw byte contents.
/// This conformance allows file paths to be used,
/// for example, as keys in a dictionary.
/// However, the rules for path equivalence
/// are file-system–specific and have additional considerations
/// like case insensitivity, Unicode normalization, and symbolic links.
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
public struct FilePath {
internal var bytes: [CChar]
/// Creates an empty, null-terminated path.
public init() {
self.bytes = [0]
_invariantCheck()
}
}
//
// MARK: - Public Interfaces
//
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
extension FilePath {
/// The length of the file path, excluding the null termination.
public var length: Int { bytes.count - 1 }
}
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
extension FilePath {
internal init<C: Collection>(nullTerminatedBytes: C) where C.Element == CChar {
self.bytes = Array(nullTerminatedBytes)
_invariantCheck()
}
internal init<C: Collection>(byteContents bytes: C) where C.Element == CChar {
var nulTermBytes = Array(bytes)
nulTermBytes.append(0)
self.init(nullTerminatedBytes: nulTermBytes)
}
}
@_implementationOnly import SystemInternals
//
// MARK: - CString interfaces
//
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
extension FilePath {
/// Creates a file path by copying bytes from a null-terminated C string.
///
/// - Parameter cString: A pointer to a null-terminated C string.
public init(cString: UnsafePointer<CChar>) {
self.init(nullTerminatedBytes:
UnsafeBufferPointer(start: cString, count: 1 + system_strlen(cString)))
}
/// Calls the given closure with a pointer to the contents of the file path,
/// represented as a null-terminated C string.
///
/// - Parameter body: A closure with a pointer parameter
/// that points to a null-terminated C string.
/// If `body` has a return value,
/// that value is also used as the return value for this method.
/// - Returns: The return value, if any, of the `body` closure parameter.
///
/// The pointer passed as an argument to `body` is valid
/// only during the execution of this method.
/// Don't try to store the pointer for later use.
public func withCString<Result>(
_ body: (UnsafePointer<Int8>) throws -> Result
) rethrows -> Result {
try bytes.withUnsafeBufferPointer { try body($0.baseAddress!) }
}
// TODO: in the future, with opaque result types with associated
// type constraints, we want to provide a RAC for terminated
// byte contents and unterminated byte contents.
}
//
// MARK: - String interfaces
//
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
extension FilePath: ExpressibleByStringLiteral {
/// Creates a file path from a string literal.
///
/// - Parameter stringLiteral: A string literal
/// whose UTF-8 contents to use as the contents of the path.
public init(stringLiteral: String) {
self.init(stringLiteral)
}
/// Creates a file path from a string.
///
/// - Parameter string: A string
/// whose UTF-8 contents to use as the contents of the path.
public init(_ string: String) {
var str = string
self = str.withUTF8 { FilePath(byteContents: $0._asCChar) }
}
}
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
extension String {
/// Creates a string by interpreting the file path's content as UTF-8.
///
/// - Parameter path: The file path to be interpreted as UTF-8.
///
/// If the content of the file path
/// isn't a well-formed UTF-8 string,
/// this initializer removes invalid bytes or replaces them with U+FFFD.
/// This means that, depending on the semantics of the specific file system,
/// conversion to a string and back to a path
/// might result in a value that's different from the original path.
public init(decoding path: FilePath) {
self = path.withCString { String(cString: $0) }
}
@available(*, deprecated, renamed: "String.init(decoding:)")
public init(_ path: FilePath) {
self.init(decoding: path)
}
/// Creates a string from a file path, validating its UTF-8 contents.
///
/// - Parameter path: The file path be interpreted as UTF-8.
///
/// If the contents of the file path
/// isn't a well-formed UTF-8 string,
/// this initializer returns `nil`.
public init?(validatingUTF8 path: FilePath) {
guard let str = path.withCString({ String(validatingUTF8: $0) }) else {
return nil
}
self = str
}
}
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
extension FilePath: CustomStringConvertible, CustomDebugStringConvertible {
/// A textual representation of the file path.
@inline(never)
public var description: String { String(decoding: self) }
/// A textual representation of the file path, suitable for debugging.
public var debugDescription: String { self.description.debugDescription }
}
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
extension FilePath: Hashable, Codable {}
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
extension FilePath {
fileprivate func _invariantCheck() {
precondition(bytes.last! == 0)
_debugPrecondition(bytes.firstIndex(of: 0) == bytes.count - 1)
}
}
+94
View File
@@ -0,0 +1,94 @@
/*
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
*/
/// Represents a location in the file system.
///
/// This structure recognizes directory separators (e.g. `/`), roots, and
/// requires that the content terminates in a NUL (`0x0`). Beyond that, it
/// does not give any meaning to the bytes that it contains. The file system
/// defines how the content is interpreted; for example, by its choice of string
/// encoding.
///
/// On construction, `FilePath` will normalize separators by removing
/// redundant intermediary separators and stripping any trailing separators.
/// On Windows, `FilePath` will also normalize forward slashes `/` into
/// backslashes `\`, as preferred by the platform.
///
/// The code below creates a file path from a string literal,
/// and then uses it to open and append to a log file:
///
/// let message: String = "This is a log message."
/// let path: FilePath = "/tmp/log"
/// let fd = try FileDescriptor.open(path, .writeOnly, options: .append)
/// try fd.closeAfter { try fd.writeAll(message.utf8) }
///
/// File paths conform to the
/// <doc://com.apple.documentation/documentation/swift/equatable>
/// and <doc://com.apple.documentation/documentation/swift/hashable> protocols
/// by performing the protocols' operations on their raw byte contents.
/// This conformance allows file paths to be used,
/// for example, as keys in a dictionary.
/// However, the rules for path equivalence
/// are file-system–specific and have additional considerations
/// like case insensitivity, Unicode normalization, and symbolic links.
@available(System 0.0.1, *)
public struct FilePath: Sendable {
// TODO(docs): Section on all the new syntactic operations, lexical normalization, decomposition,
// components, etc.
internal var _storage: SystemString
/// Creates an empty, null-terminated path.
public init() {
self._storage = SystemString()
_invariantCheck()
}
// In addition to the empty init, this init will properly normalize
// separators. All other initializers should be implemented by
// ultimately deferring to a normalizing init.
internal init(_ str: SystemString) {
self._storage = str
self._normalizeSeparators()
_invariantCheck()
}
}
@available(System 0.0.1, *)
extension FilePath {
/// The length of the file path, excluding the null terminator.
public var length: Int { _storage.length }
}
@available(System 0.0.1, *)
extension FilePath: Hashable {}
#if !$Embedded
@available(System 0.0.1, *)
extension FilePath: Codable {
// Encoder is synthesized; it probably should have been explicit and used
// a single-value container, but making that change now is somewhat risky.
// Decoder is written explicitly to ensure that we validate invariants on
// untrusted input.
public init(from decoder: any Decoder) throws {
let container = try decoder.container(keyedBy: CodingKeys.self)
self._storage = try container.decode(SystemString.self, forKey: ._storage)
guard _invariantsSatisfied() else {
throw DecodingError.dataCorruptedError(
forKey: ._storage,
in: container,
debugDescription:
"Encoding does not satisfy the invariants of FilePath"
)
}
}
}
#endif // !$Embedded
@@ -0,0 +1,219 @@
/*
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
*/
// MARK: - API
@available(System 0.0.2, *)
extension FilePath {
/// A bidirectional, range replaceable collection of the non-root components
/// that make up a file path.
///
/// ComponentView provides access to standard `BidirectionalCollection`
/// algorithms for accessing components from the front or back, as well as
/// standard `RangeReplaceableCollection` algorithms for modifying the
/// file path using component or range of components granularity.
///
/// Example:
///
/// var path: FilePath = "/./home/./username/scripts/./tree"
/// let scriptIdx = path.components.lastIndex(of: "scripts")!
/// path.components.insert("bin", at: scriptIdx)
/// // path is "/./home/./username/bin/scripts/./tree"
///
/// path.components.removeAll { $0.kind == .currentDirectory }
/// // path is "/home/username/bin/scripts/tree"
@available(System 0.0.2, *)
public struct ComponentView: Sendable {
internal var _path: FilePath
internal var _start: SystemString.Index
internal init(_ path: FilePath) {
self._path = path
self._start = path._relativeStart
_invariantCheck()
}
}
/// View the non-root components that make up this path.
public var components: ComponentView {
__consuming get { ComponentView(self) }
_modify {
// RRC's empty init means that we can't guarantee that the yielded
// view will restore our root. So copy it out first.
//
// TODO(perf): Small-form root (especially on Unix). Have Root
// always copy out (not worth ref counting). Make sure that we're
// not needlessly sliding values around or triggering a COW
let rootStr = self.root?._systemString ?? SystemString()
var comp = ComponentView(self)
self = FilePath()
defer {
self = comp._path
if root?._slice.elementsEqual(rootStr) != true {
self.root = Root(rootStr)
}
}
yield &comp
}
}
}
@available(System 0.0.2, *)
extension FilePath.ComponentView: BidirectionalCollection {
public typealias Element = FilePath.Component
@available(System 0.0.2, *)
public struct Index: Sendable, Comparable, Hashable {
internal typealias Storage = SystemString.Index
internal var _storage: Storage
public static func < (lhs: Self, rhs: Self) -> Bool {
lhs._storage < rhs._storage
}
fileprivate init(_ idx: Storage) {
self._storage = idx
}
}
public var startIndex: Index { Index(_start) }
public var endIndex: Index { Index(_path._storage.endIndex) }
public func index(after i: Index) -> Index {
return Index(_path._parseComponent(startingAt: i._storage).nextStart)
}
public func index(before i: Index) -> Index {
Index(_path._parseComponent(priorTo: i._storage).lowerBound)
}
public subscript(position: Index) -> FilePath.Component {
let end = _path._parseComponent(startingAt: position._storage).componentEnd
return FilePath.Component(_path, position._storage ..< end)
}
}
@available(System 0.0.2, *)
extension FilePath.ComponentView: RangeReplaceableCollection {
public init() {
self.init(FilePath())
}
// TODO(perf): We probably want to have concrete overrides or generic
// specializations taking FP.ComponentView and
// FP.ComponentView.SubSequence because we
// can just memcpy in those cases. We
// probably want to do that for all RRC operations.
public mutating func replaceSubrange<C>(
_ subrange: Range<Index>, with newElements: C
) where C : Collection, Self.Element == C.Element {
defer {
_path._invariantCheck()
_invariantCheck()
}
if isEmpty {
_path = FilePath(root: _path.root, newElements)
return
}
let range = subrange.lowerBound._storage ..< subrange.upperBound._storage
if newElements.isEmpty {
let fromEnd = subrange.upperBound == endIndex
_path._storage.removeSubrange(range)
if fromEnd {
_path._removeTrailingSeparator()
}
return
}
// TODO(perf): Avoid extra allocation by sliding elements down and
// filling in the bytes ourselves.
// If we're inserting at the end, we need a leading separator.
var str = SystemString()
let atEnd = subrange.lowerBound == endIndex
if atEnd {
str.append(platformSeparator)
}
str.appendComponents(components: newElements)
if !atEnd {
str.append(platformSeparator)
}
_path._storage.replaceSubrange(range, with: str)
}
}
@available(System 0.0.2, *)
extension FilePath {
/// Create a file path from a root and a collection of components.
public init<C: Collection>(
root: Root?, _ components: C
) where C.Element == Component {
var str = root?._systemString ?? SystemString()
str.appendComponents(components: components)
self.init(str)
}
/// Create a file path from a root and any number of components.
public init(root: Root?, components: Component...) {
self.init(root: root, components)
}
/// Create a file path from an optional root and a slice of another path's
/// components.
public init(root: Root?, _ components: ComponentView.SubSequence) {
var str = root?._systemString ?? SystemString()
let (start, end) =
(components.startIndex._storage, components.endIndex._storage)
str.append(contentsOf: components.base._slice[start..<end])
self.init(str)
}
}
// MARK: - Internals
@available(System 0.0.2, *)
extension FilePath.ComponentView: _PathSlice {
internal var _range: Range<SystemString.Index> {
_start ..< _path._storage.endIndex
}
internal init(_ str: SystemString) {
fatalError("TODO: consider dropping proto req")
}
}
// MARK: - Invariants
@available(System 0.0.2, *)
extension FilePath.ComponentView {
internal func _invariantCheck() {
#if DEBUG
if isEmpty {
precondition(_path.isEmpty == (_path.root == nil))
return
}
// If path has a root,
if _path.root != nil {
precondition(first!._slice.startIndex > _path._storage.startIndex)
precondition(first!._slice.startIndex == _path._relativeStart)
}
self.forEach { $0._invariantCheck() }
if let base = last {
precondition(base._slice.endIndex == _path._storage.endIndex)
}
precondition(FilePath(root: _path.root, self) == _path)
#endif // DEBUG
}
}
@@ -0,0 +1,306 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 - 2024 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
*/
// MARK: - API
@available(System 0.0.2, *)
extension FilePath {
/// Represents a root of a file path.
///
/// On Unix, a root is simply the directory separator `/`.
///
/// On Windows, a root contains the entire path prefix up to and including
/// the final separator.
///
/// Examples:
/// * Unix:
/// * `/`
/// * Windows:
/// * `C:\`
/// * `C:`
/// * `\`
/// * `\\server\share\`
/// * `\\?\UNC\server\share\`
/// * `\\?\Volume{12345678-abcd-1111-2222-123445789abc}\`
@available(System 0.0.2, *)
public struct Root: Sendable {
internal var _path: FilePath
internal var _rootEnd: SystemString.Index
internal init(_ path: FilePath, rootEnd: SystemString.Index) {
self._path = path
self._rootEnd = rootEnd
_invariantCheck()
}
// TODO: Definitely want a small form for this on Windows,
// and intern "/" for Unix.
}
/// Represents an individual, non-root component of a file path.
///
/// Components can be one of the special directory components (`.` or `..`)
/// or a file or directory name. Components are never empty and never
/// contain the directory separator.
///
/// Example:
///
/// var path: FilePath = "/tmp"
/// let file: FilePath.Component = "foo.txt"
/// file.kind == .regular // true
/// file.extension // "txt"
/// path.append(file) // path is "/tmp/foo.txt"
@available(System 0.0.2, *)
public struct Component: Sendable {
internal var _path: FilePath
internal var _range: Range<SystemString.Index>
// TODO: Make a small-component form to save on ARC overhead when
// extracted from a path, and especially to save on allocation overhead
// when constructing one from a String literal.
internal init<RE: RangeExpression>(_ path: FilePath, _ range: RE)
where RE.Bound == SystemString.Index {
self._path = path
self._range = range.relative(to: path._storage)
precondition(!self._range.isEmpty, "FilePath components cannot be empty")
self._invariantCheck()
}
}
}
@available(System 0.0.2, *)
extension FilePath.Component {
/// Whether a component is a regular file or directory name, or a special
/// directory `.` or `..`
@frozen
@available(System 0.0.2, *)
public enum Kind: Sendable {
/// The special directory `.`, representing the current directory.
case currentDirectory
/// The special directory `..`, representing the parent directory.
case parentDirectory
/// A file or directory name
case regular
}
/// The kind of this component
public var kind: Kind {
if _path._isCurrentDirectory(_range) { return .currentDirectory }
if _path._isParentDirectory(_range) { return .parentDirectory }
return .regular
}
}
@available(System 0.0.2, *)
extension FilePath.Root {
// TODO: Windows analysis APIs
}
// MARK: - Internals
extension SystemString {
// TODO: take insertLeadingSlash: Bool
// TODO: turn into an insert operation with slide
internal mutating func appendComponents<C: Collection>(
components: C
) where C.Element == FilePath.Component {
// TODO(perf): Consider pre-pass to count capacity, slide
defer {
_removeTrailingSeparator()
FilePath(self)._invariantCheck()
}
for idx in components.indices {
let component = components[idx]
component._withSystemChars { self.append(contentsOf: $0) }
self.append(platformSeparator)
}
}
}
#if !$Embedded
// Unifying protocol for common functionality between roots, components,
// and views onto SystemString and FilePath.
internal protocol _StrSlice: _PlatformStringable, Hashable, Codable {
var _storage: SystemString { get }
var _range: Range<SystemString.Index> { get }
init?(_ str: SystemString)
func _invariantCheck()
}
#else
internal protocol _StrSlice: _PlatformStringable, Hashable {
var _storage: SystemString { get }
var _range: Range<SystemString.Index> { get }
init?(_ str: SystemString)
func _invariantCheck()
}
#endif // !$Embedded
extension _StrSlice {
internal var _slice: Slice<SystemString> {
Slice(base: _storage, bounds: _range)
}
internal func _withSystemChars<T>(
_ f: (UnsafeBufferPointer<SystemChar>) throws -> T
) rethrows -> T {
try _storage.withNullTerminatedSystemChars {
try f(UnsafeBufferPointer(rebasing: $0[_range]))
}
}
internal func _withCodeUnits<T>(
_ f: (UnsafeBufferPointer<CInterop.PlatformUnicodeEncoding.CodeUnit>) throws -> T
) rethrows -> T {
try _slice.withCodeUnits(f)
}
internal init?(_platformString s: UnsafePointer<CInterop.PlatformChar>) {
self.init(SystemString(platformString: s))
}
internal func _withPlatformString<Result>(
_ body: (UnsafePointer<CInterop.PlatformChar>) throws -> Result
) rethrows -> Result {
try _slice.withPlatformString(body)
}
internal var _systemString: SystemString { SystemString(_slice) }
}
extension _StrSlice {
public static func == (lhs: Self, rhs: Self) -> Bool {
lhs._slice.elementsEqual(rhs._slice)
}
public func hash(into hasher: inout Hasher) {
hasher.combine(_slice.count) // discriminator
for element in _slice {
hasher.combine(element)
}
}
}
internal protocol _PathSlice: _StrSlice {
var _path: FilePath { get }
}
extension _PathSlice {
internal var _storage: SystemString { _path._storage }
}
@available(System 0.0.2, *)
extension FilePath.Component: _PathSlice {
}
@available(System 0.0.2, *)
extension FilePath.Root: _PathSlice {
internal var _range: Range<SystemString.Index> {
(..<_rootEnd).relative(to: _path._storage)
}
}
@available(System 0.0.1, *)
extension FilePath: _PlatformStringable {
func _withPlatformString<Result>(_ body: (UnsafePointer<CInterop.PlatformChar>) throws -> Result) rethrows -> Result {
try _storage.withPlatformString(body)
}
init(_platformString: UnsafePointer<CInterop.PlatformChar>) {
self.init(SystemString(platformString: _platformString))
}
}
@available(System 0.0.2, *)
extension FilePath.Component {
// The index of the `.` denoting an extension
internal func _extensionIndex() -> SystemString.Index? {
guard kind == .regular,
let idx = _slice.lastIndex(of: .dot),
idx != _slice.startIndex
else { return nil }
return idx
}
internal func _extensionRange() -> Range<SystemString.Index>? {
guard let idx = _extensionIndex() else { return nil }
return _slice.index(after: idx) ..< _slice.endIndex
}
internal func _stemRange() -> Range<SystemString.Index> {
_slice.startIndex ..< (_extensionIndex() ?? _slice.endIndex)
}
}
internal func _makeExtension(_ ext: String) -> SystemString {
var result = SystemString()
result.append(.dot)
result.append(contentsOf: ext.unicodeScalars.lazy.map(SystemChar.init))
return result
}
@available(System 0.0.2, *)
extension FilePath.Component {
internal init?(_ str: SystemString) {
// FIXME: explicit null root? Or something else?
let path = FilePath(str)
guard path.root == nil, path.components.count == 1 else {
return nil
}
self = path.components.first!
self._invariantCheck()
}
}
@available(System 0.0.2, *)
extension FilePath.Root {
internal init?(_ str: SystemString) {
// FIXME: explicit null root? Or something else?
let path = FilePath(str)
guard path.root != nil, path.components.isEmpty else {
return nil
}
self = path.root!
self._invariantCheck()
}
}
// MARK: - Invariants
@available(System 0.0.2, *)
extension FilePath.Component {
// TODO: ensure this all gets easily optimized away in release...
internal func _invariantCheck() {
#if DEBUG
precondition(!_slice.isEmpty)
precondition(_slice.last != .null)
precondition(_slice.allSatisfy { !isSeparator($0) } )
precondition(_path._relativeStart <= _slice.startIndex)
#endif // DEBUG
}
}
@available(System 0.0.2, *)
extension FilePath.Root {
internal func _invariantCheck() {
#if DEBUG
precondition(self._rootEnd > _path._storage.startIndex)
// TODO: Windows root invariants
#endif
}
}
@@ -0,0 +1,392 @@
/*
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
*/
// FIXME: Need to rewrite and simplify this code now that SystemString
// manages (and hides) the null terminator
// The separator we use internally
private var genericSeparator: SystemChar { .slash }
// The platform preferred separator
//
// TODO: Make private
internal var platformSeparator: SystemChar {
_windowsPaths ? .backslash : genericSeparator
}
// Whether the character is the canonical separator
// TODO: Make private
internal func isSeparator(_ c: SystemChar) -> Bool {
c == platformSeparator
}
// Whether the character is a pre-normalized separator
internal func isPrenormalSeparator(_ c: SystemChar) -> Bool {
c == genericSeparator || c == platformSeparator
}
// Separator normalization, checking, and root parsing is internally hosted
// on SystemString for ease of unit testing.
extension SystemString {
// For invariant enforcing/checking. Should always return false on
// a fully-formed path
fileprivate func _hasTrailingSeparator() -> Bool {
// Just a root: do nothing
guard _relativePathStart != endIndex else { return false }
assert(!isEmpty)
return isSeparator(self.last!)
}
// Enforce invariants by removing a trailing separator.
//
// Precondition: There is exactly zero or one trailing slashes
//
// Postcondition: Path is root, or has no trailing separator
internal mutating func _removeTrailingSeparator() {
if _hasTrailingSeparator() {
self.removeLast()
assert(!_hasTrailingSeparator())
}
}
// Enforce invariants by normalizing the internal separator representation.
//
// 1) Normalize all separators to platform-preferred separator
// 2) Drop redundant separators
// 3) Drop trailing separators
//
// On Windows, UNC and device paths are allowed to begin with two separators,
// and partial or mal-formed roots are completed.
//
// The POSIX standard does allow two leading separators to
// denote implementation-specific handling, but Darwin and Linux
// do not treat these differently.
//
internal mutating func _normalizeSeparators() {
guard !isEmpty else { return }
var (writeIdx, readIdx) = (startIndex, startIndex)
if _windowsPaths {
// Normalize forwards slashes to backslashes.
//
// NOTE: Ideally this would be done as part of separator coalescing
// below. However, prenormalizing roots such as UNC paths requires
// parsing and (potentially) fixing up semi-formed roots. This
// normalization reduces the complexity of the task by allowing us to
// use a read-only lexer.
self._replaceAll(genericSeparator, with: platformSeparator)
// Windows roots can have meaningful repeated backslashes or may
// need backslashes inserted for partially-formed roots. Delegate that to
// `_prenormalizeWindowsRoots` and resume.
readIdx = _prenormalizeWindowsRoots()
writeIdx = readIdx
// Skip redundant separators
while readIdx < endIndex && isSeparator(self[readIdx]) {
self.formIndex(after: &readIdx)
}
} else {
assert(genericSeparator == platformSeparator)
}
while readIdx < endIndex {
assert(writeIdx <= readIdx)
// Swap and advance our indices.
let wasSeparator = isSeparator(self[readIdx])
self.swapAt(writeIdx, readIdx)
self.formIndex(after: &writeIdx)
self.formIndex(after: &readIdx)
while wasSeparator, readIdx < endIndex, isSeparator(self[readIdx]) {
self.formIndex(after: &readIdx)
}
}
self.removeLast(self.distance(from: writeIdx, to: readIdx))
self._removeTrailingSeparator()
}
}
@available(System 0.0.1, *)
extension FilePath {
internal mutating func _removeTrailingSeparator() {
_storage._removeTrailingSeparator()
}
internal mutating func _normalizeSeparators() {
_storage._normalizeSeparators()
}
// Remove any `.` and `..` components
internal mutating func _normalizeSpecialDirectories() {
guard !isLexicallyNormal else { return }
defer { assert(isLexicallyNormal) }
let relStart = _relativeStart
let hasRoot = relStart != _storage.startIndex
// TODO: all this logic might be nicer if _parseComponent considered
// the null character index to be the next start...
var (writeIdx, readIdx) = (relStart, relStart)
while readIdx < _storage.endIndex {
let (compEnd, nextStart) = _parseComponent(startingAt: readIdx)
assert(readIdx < nextStart && compEnd <= nextStart)
let component = readIdx..<compEnd
// `.` is skipped over
if _isCurrentDirectory(component) {
readIdx = nextStart
continue
}
// `..`s are preserved at the very beginning of a relative path,
// otherwise parse-back a component to remove the parent (but stop at
// root).
if _isParentDirectory(component) {
// Skip over it if we're at the root
if hasRoot && writeIdx == relStart {
readIdx = nextStart
continue
}
// Drop the parent (unless we're preserving `..`s)
if writeIdx != relStart {
let priorComponent = _parseComponent(priorTo: writeIdx)
if !_isParentDirectory(priorComponent) {
writeIdx = priorComponent.lowerBound
readIdx = nextStart
continue
}
assert(self.root == nil && self.components.first!.kind == .parentDirectory)
}
}
if readIdx == writeIdx {
(readIdx, writeIdx) = (nextStart, nextStart)
continue
}
while readIdx != nextStart {
_storage.swapAt(readIdx, writeIdx)
readIdx = _storage.index(after: readIdx)
writeIdx = _storage.index(after: writeIdx)
}
}
assert(readIdx == _storage.endIndex && readIdx >= writeIdx)
if readIdx != writeIdx {
_storage.removeSubrange(writeIdx...)
_removeTrailingSeparator()
}
}
}
extension SystemString {
internal var _relativePathStart: Index {
_parseRoot().relativeBegin
}
}
@available(System 0.0.1, *)
extension FilePath {
internal var _relativeStart: SystemString.Index {
_storage._relativePathStart
}
internal var _hasRoot: Bool {
_relativeStart != _storage.startIndex
}
}
// Parse separators
@available(System 0.0.1, *)
extension FilePath {
internal typealias _Index = SystemString.Index
// Parse a component that starts at `i`. Returns the end
// of the component and the start of the next. Parsing terminates
// at the index of the null byte.
internal func _parseComponent(
startingAt i: _Index
) -> (componentEnd: _Index, nextStart: _Index) {
assert(i < _storage.endIndex)
// Parse the root
if i == _storage.startIndex {
let relativeStart = _relativeStart
if i != relativeStart {
return (relativeStart, relativeStart)
}
}
assert(!isSeparator(_storage[i]))
guard let nextSep = _storage[i...].firstIndex(where: isSeparator) else {
return (_storage.endIndex, _storage.endIndex)
}
return (nextSep, _storage.index(after: nextSep))
}
// Parse a component prior to the one that starts at `i`. Returns
// the start of the prior component. If `i` is the index of null,
// returns the last component.
internal func _parseComponent(
priorTo i: _Index
) -> Range<_Index> {
precondition(i > _storage.startIndex)
let relStart = _relativeStart
if i == relStart { return _storage.startIndex..<relStart }
assert(i > relStart)
var slice = _storage[..<i]
if i != _storage.endIndex {
assert(isSeparator(slice.last!))
slice.removeLast()
}
let end = slice.endIndex
while slice.endIndex != relStart, let c = slice.last, !isSeparator(c) {
slice.removeLast()
}
return slice.endIndex ..< end
}
internal func _isCurrentDirectory(_ component: Range<_Index>) -> Bool {
_storage[component].elementsEqual([.dot])
}
internal func _isParentDirectory(_ component: Range<_Index>) -> Bool {
_storage[component].elementsEqual([.dot, .dot])
}
internal func _isSpecialDirectory(_ component: Range<_Index>) -> Bool {
_isCurrentDirectory(component) || _isParentDirectory(component)
}
}
@available(System 0.0.2, *)
extension FilePath.ComponentView {
// TODO: Store this...
internal var _relativeStart: SystemString.Index {
_path._relativeStart
}
}
extension SystemString {
internal func _parseRoot() -> (
rootEnd: Index, relativeBegin: Index
) {
guard !isEmpty else { return (startIndex, startIndex) }
// Windows roots are more complex
if _windowsPaths { return _parseWindowsRoot() }
// A leading `/` is a root
guard isSeparator(self.first!) else { return (startIndex, startIndex) }
let next = self.index(after: startIndex)
return (next, next)
}
}
@available(System 0.0.2, *)
extension FilePath.Root {
// Asserting self is a root, returns whether this is an
// absolute root.
//
// On Unix, all roots are absolute. On Windows, `\` and `X:` are
// relative roots
//
// TODO: public
internal var isAbsolute: Bool {
assert(FilePath(SystemString(self._slice)).root == self, "not a root")
guard _windowsPaths else { return true }
// `\` or `C:` are the only form of relative roots, and all
// absolute roots are at least 3 chars long.
let slice = self._slice
guard slice.count < 3 else { return true }
assert(
(slice.count == 1 && slice.first == .backslash) ||
(slice.count == 2 && slice.last == .colon))
return false
}
}
@available(System 0.0.1, *)
extension FilePath {
internal var _portableDescription: String {
guard _windowsPaths else { return description }
let utf8 = description.utf8.map { $0 == UInt8(ascii: #"\"#) ? UInt8(ascii: "/") : $0 }
return String(decoding: utf8, as: UTF8.self)
}
}
// Whether we are providing Windows paths
@inline(__always)
internal var _windowsPaths: Bool {
if let forceWindowsPaths = forceWindowsPaths {
return forceWindowsPaths
}
#if os(Windows)
return true
#else
return false
#endif
}
@available(System 0.0.1, *)
extension FilePath {
// Whether we should add a separator when doing an append
internal var _needsSeparatorForAppend: Bool {
guard let last = _storage.last, !isSeparator(last) else { return false }
// On Windows, we can have a path of the form `C:` which is a root and
// does not need a separator after it
if _windowsPaths && _relativeStart == _storage.endIndex {
return false
}
return true
}
// Perform an append, inseting a separator if needed.
// Note that this will not check whether `content` is a root
internal mutating func _append(unchecked content: Slice<SystemString>) {
assert(FilePath(SystemString(content)).root == nil)
if content.isEmpty { return }
if _needsSeparatorForAppend {
_storage.append(platformSeparator)
}
_storage.append(contentsOf: content)
}
}
// MARK: - Invariants
@available(System 0.0.1, *)
extension FilePath {
internal func _invariantsSatisfied() -> Bool {
var normal = self
normal._normalizeSeparators()
guard self == normal else { return false }
guard !self._storage._hasTrailingSeparator() else { return false }
guard _hasRoot == (self.root != nil) else { return false }
return true
}
internal func _invariantCheck() {
#if DEBUG
precondition(_invariantsSatisfied())
#endif // DEBUG
}
}
@@ -0,0 +1,603 @@
/*
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
*/
// MARK: - Platform string
@available(System 0.0.2, *)
extension FilePath {
/// Creates a file path by copying bytes from a null-terminated platform
/// string.
///
/// - Parameter platformString: A pointer to a null-terminated platform
/// string.
public init(platformString: UnsafePointer<CInterop.PlatformChar>) {
self.init(_platformString: platformString)
}
/// Creates a file path by copying bytes from a null-terminated platform
/// string.
///
/// - Note It is a precondition that `platformString` must be null-terminated.
/// The absence of a null byte will trigger a runtime error.
///
/// - Parameter platformString: A null-terminated platform string.
@inlinable
@_alwaysEmitIntoClient
public init(platformString: [CInterop.PlatformChar]) {
guard let _ = platformString.firstIndex(of: 0) else {
fatalError(
"input of FilePath.init(platformString:) must be null-terminated"
)
}
self = platformString.withUnsafeBufferPointer {
FilePath(platformString: $0.baseAddress!)
}
}
@inlinable
@_alwaysEmitIntoClient
@available(*, deprecated, message: "Use FilePath.init(_ scalar: Unicode.Scalar)")
public init(platformString: inout CInterop.PlatformChar) {
guard platformString == 0 else {
fatalError(
"input of FilePath.init(platformString:) must be null-terminated"
)
}
self = FilePath()
}
@inlinable
@_alwaysEmitIntoClient
@available(*, deprecated, message: "Use FilePath(_: String) to create a path from a String")
public init(platformString: String) {
if let nullLoc = platformString.firstIndex(of: "\0") {
self = FilePath(String(platformString[..<nullLoc]))
} else {
self = FilePath(platformString)
}
}
#if !os(Windows)
// Note: This function should have been opaque, but it shipped as
// `@_alwaysEmitIntoClient` in macOS 12/iOS 15, and now it is stuck
// this way forever. (Or until the language provides a way for us
// to declare separate availability for a function's exported symbol
// and its inlinable body.)
/// Calls the given closure with a pointer to the contents of the file path,
/// represented as a null-terminated platform string.
///
/// - Parameter body: A closure with a pointer parameter
/// that points to a null-terminated platform string.
/// If `body` has a return value,
/// that value is also used as the return value for this method.
/// - Returns: The return value, if any, of the `body` closure parameter.
///
/// The pointer passed as an argument to `body` is valid
/// only during the execution of this method.
/// Don't try to store the pointer for later use.
@_alwaysEmitIntoClient
public func withPlatformString<Result>(
_ body: (UnsafePointer<CInterop.PlatformChar>) throws(SystemError) -> Result
) rethrows -> Result {
return try withCString(body)
}
#else
/// Calls the given closure with a pointer to the contents of the file path,
/// represented as a null-terminated platform string.
///
/// - Parameter body: A closure with a pointer parameter
/// that points to a null-terminated platform string.
/// If `body` has a return value,
/// that value is also used as the return value for this method.
/// - Returns: The return value, if any, of the `body` closure parameter.
///
/// The pointer passed as an argument to `body` is valid
/// only during the execution of this method.
/// Don't try to store the pointer for later use.
public func withPlatformString<Result>(
_ body: (UnsafePointer<CInterop.PlatformChar>) throws(SystemError) -> Result
) rethrows -> Result {
return try _withPlatformString(body)
}
#endif
}
@available(System 0.0.2, *)
extension FilePath.Component {
/// Creates a file path component by copying bytes from a null-terminated
/// platform string.
///
/// Returns `nil` if `platformString` is empty, is a root, or has more than
/// one component in it.
///
/// - Parameter platformString: A pointer to a null-terminated platform
/// string.
public init?(platformString: UnsafePointer<CInterop.PlatformChar>) {
self.init(_platformString: platformString)
}
/// Creates a file path component by copying bytes from a null-terminated
/// platform string. It is a precondition that a null byte indicates the end of
/// the string. The absence of a null byte will trigger a runtime error.
///
/// Returns `nil` if `platformString` is empty, is a root, or has more than
/// one component in it.
///
/// - Note It is a precondition that `platformString` must be null-terminated.
/// The absence of a null byte will trigger a runtime error.
///
/// - Parameter platformString: A null-terminated platform string.
@inlinable
@_alwaysEmitIntoClient
public init?(platformString: [CInterop.PlatformChar]) {
guard let _ = platformString.firstIndex(of: 0) else {
fatalError(
"input of FilePath.Component.init?(platformString:) must be null-terminated"
)
}
guard let component = platformString.withUnsafeBufferPointer({
FilePath.Component(platformString: $0.baseAddress!)
}) else {
return nil
}
self = component
}
@inlinable
@_alwaysEmitIntoClient
@available(*, deprecated, message: "Use FilePath.Component.init(_ scalar: Unicode.Scalar)")
public init?(platformString: inout CInterop.PlatformChar) {
guard platformString == 0 else {
fatalError(
"input of FilePath.Component.init?(platformString:) must be null-terminated"
)
}
return nil
}
@inlinable
@_alwaysEmitIntoClient
@available(*, deprecated, message: "Use FilePath.Component.init(_: String)")
public init?(platformString: String) {
let string: String
if let nullLoc = platformString.firstIndex(of: "\0") {
string = String(platformString[..<nullLoc])
} else {
string = platformString
}
guard let component = FilePath.Component(string) else { return nil }
self = component
}
/// Calls the given closure with a pointer to the contents of the file path
/// component, represented as a null-terminated platform string.
///
/// If this is not the last component of a path, an allocation will occur in
/// order to add the null terminator.
///
/// - Parameter body: A closure with a pointer parameter
/// that points to a null-terminated platform string.
/// If `body` has a return value,
/// that value is also used as the return value for this method.
/// - Returns: The return value, if any, of the `body` closure parameter.
///
/// The pointer passed as an argument to `body` is valid
/// only during the execution of this method.
/// Don't try to store the pointer for later use.
public func withPlatformString<Result>(
_ body: (UnsafePointer<CInterop.PlatformChar>) throws -> Result
) rethrows -> Result {
try _withPlatformString(body)
}
}
@available(System 0.0.2, *)
extension FilePath.Root {
/// Creates a file path root by copying bytes from a null-terminated platform
/// string.
///
/// Returns `nil` if `platformString` is empty or is not a root.
///
/// - Parameter platformString: A pointer to a null-terminated platform
/// string.
public init?(platformString: UnsafePointer<CInterop.PlatformChar>) {
self.init(_platformString: platformString)
}
/// Creates a file path root by copying bytes from a null-terminated platform
/// string. It is a precondition that a null byte indicates the end of
/// the string. The absence of a null byte will trigger a runtime error.
///
/// Returns `nil` if `platformString` is empty or is not a root.
///
/// - Note It is a precondition that `platformString` must be null-terminated.
/// The absence of a null byte will trigger a runtime error.
///
/// - Parameter platformString: A null-terminated platform string.
@inlinable
@_alwaysEmitIntoClient
public init?(platformString: [CInterop.PlatformChar]) {
guard let _ = platformString.firstIndex(of: 0) else {
fatalError(
"input of FilePath.Root.init?(platformString:) must be null-terminated"
)
}
guard let component = platformString.withUnsafeBufferPointer({
FilePath.Root(platformString: $0.baseAddress!)
}) else {
return nil
}
self = component
}
@inlinable
@_alwaysEmitIntoClient
@available(*, deprecated, message: "Use FilePath.Root.init(_ scalar: Unicode.Scalar)")
public init?(platformString: inout CInterop.PlatformChar) {
guard platformString == 0 else {
fatalError(
"input of FilePath.Root.init?(platformString:) must be null-terminated"
)
}
return nil
}
@inlinable
@_alwaysEmitIntoClient
@available(*, deprecated, message: "Use FilePath.Root.init(_: String)")
public init?(platformString: String) {
let string: String
if let nullLoc = platformString.firstIndex(of: "\0") {
string = String(platformString[..<nullLoc])
} else {
string = platformString
}
guard let root = FilePath.Root(string) else { return nil }
self = root
}
/// Calls the given closure with a pointer to the contents of the file path
/// root, represented as a null-terminated platform string.
///
/// If the path has a relative portion, an allocation will occur in order to
/// add the null terminator.
///
/// - Parameter body: A closure with a pointer parameter
/// that points to a null-terminated platform string.
/// If `body` has a return value,
/// that value is also used as the return value for this method.
/// - Returns: The return value, if any, of the `body` closure parameter.
///
/// The pointer passed as an argument to `body` is valid
/// only during the execution of this method.
/// Don't try to store the pointer for later use.
public func withPlatformString<Result>(
_ body: (UnsafePointer<CInterop.PlatformChar>) throws -> Result
) rethrows -> Result {
try _withPlatformString(body)
}
}
// MARK: - String literals
@available(System 0.0.1, *)
extension FilePath: ExpressibleByStringLiteral {
/// Creates a file path from a string literal.
///
/// - Parameter stringLiteral: A string literal
/// whose Unicode encoded contents to use as the contents of the path.
public init(stringLiteral: String) {
self.init(stringLiteral)
}
/// Creates a file path from a string.
///
/// - Parameter string: A string
/// whose Unicode encoded contents to use as the contents of the path.
public init(_ string: String) {
self.init(SystemString(string))
}
}
@available(System 0.0.2, *)
extension FilePath.Component: ExpressibleByStringLiteral {
/// Create a file path component from a string literal.
///
/// Precondition: `stringLiteral` is non-empty, is not a root,
/// and has only one component in it.
public init(stringLiteral: String) {
guard let s = FilePath.Component(stringLiteral) else {
// TODO: static assert
fatalError("""
FilePath.Component must be created from exactly one non-root component
""")
}
self = s
}
/// Create a file path component from a string.
///
/// Returns `nil` if `string` is empty, a root, or has more than one component
/// in it.
public init?(_ string: String) {
self.init(SystemString(string))
}
}
@available(System 0.0.2, *)
extension FilePath.Root: ExpressibleByStringLiteral {
/// Create a file path root from a string literal.
///
/// Precondition: `stringLiteral` is non-empty and is a root.
public init(stringLiteral: String) {
guard let s = FilePath.Root(stringLiteral) else {
// TODO: static assert
fatalError("""
FilePath.Root must be created from a root
""")
}
self = s
}
/// Create a file path root from a string.
///
/// Returns `nil` if `string` is empty or is not a root.
public init?(_ string: String) {
self.init(SystemString(string))
}
}
// MARK: - Printing and dumping
@available(System 0.0.1, *)
extension FilePath: CustomStringConvertible, CustomDebugStringConvertible {
/// A textual representation of the file path.
///
/// If the content of the path isn't a well-formed Unicode string,
/// this replaces invalid bytes with U+FFFD. See `String.init(decoding:)`
@inline(never)
public var description: String { String(decoding: self) }
/// A textual representation of the file path, suitable for debugging.
///
/// If the content of the path isn't a well-formed Unicode string,
/// this replaces invalid bytes with U+FFFD. See `String.init(decoding:)`
public var debugDescription: String { description.debugDescription }
}
@available(System 0.0.2, *)
extension FilePath.Component: CustomStringConvertible, CustomDebugStringConvertible {
/// A textual representation of the path component.
///
/// If the content of the path component isn't a well-formed Unicode string,
/// this replaces invalid bytes with U+FFFD. See `String.init(decoding:)`.
@inline(never)
public var description: String { String(decoding: self) }
/// A textual representation of the path component, suitable for debugging.
///
/// If the content of the path component isn't a well-formed Unicode string,
/// this replaces invalid bytes with U+FFFD. See `String.init(decoding:)`.
public var debugDescription: String { description.debugDescription }
}
@available(System 0.0.2, *)
extension FilePath.Root: CustomStringConvertible, CustomDebugStringConvertible {
/// A textual representation of the path root.
///
/// If the content of the path root isn't a well-formed Unicode string,
/// this replaces invalid bytes with U+FFFD. See `String.init(decoding:)`.
@inline(never)
public var description: String { String(decoding: self) }
/// A textual representation of the path root, suitable for debugging.
///
/// If the content of the path root isn't a well-formed Unicode string,
/// this replaces invalid bytes with U+FFFD. See `String.init(decoding:)`.
public var debugDescription: String { description.debugDescription }
}
// MARK: - Convenience helpers
// Convenience helpers
@available(System 0.0.2, *)
extension FilePath {
/// Creates a string by interpreting the path’s content as UTF-8 on Unix
/// and UTF-16 on Windows.
///
/// This property is equivalent to calling `String(decoding: path)`
public var string: String {
String(decoding: self)
}
}
@available(System 0.0.2, *)
extension FilePath.Component {
/// Creates a string by interpreting the component’s content as UTF-8 on Unix
/// and UTF-16 on Windows.
///
/// This property is equivalent to calling `String(decoding: component)`.
public var string: String {
String(decoding: self)
}
}
@available(System 0.0.2, *)
extension FilePath.Root {
/// On Unix, this returns `"/"`.
///
/// On Windows, interprets the root's content as UTF-16 on Windows.
///
/// This property is equivalent to calling `String(decoding: root)`.
public var string: String {
String(decoding: self)
}
}
// MARK: - Decoding and validating
@available(System 0.0.1, *)
extension String {
/// Creates a string by interpreting the file path's content as UTF-8 on Unix
/// and UTF-16 on Windows.
///
/// - Parameter path: The file path to be interpreted as
/// `CInterop.PlatformUnicodeEncoding`.
///
/// If the content of the file path isn't a well-formed Unicode string,
/// this initializer replaces invalid bytes with U+FFFD.
/// This means that, depending on the semantics of the specific file system,
/// conversion to a string and back to a path
/// might result in a value that's different from the original path.
public init(decoding path: FilePath) {
self.init(_decoding: path)
}
/// Creates a string from a file path, validating its contents as UTF-8 on
/// Unix and UTF-16 on Windows.
///
/// - Parameter path: The file path to be interpreted as
/// `CInterop.PlatformUnicodeEncoding`.
///
/// If the contents of the file path isn't a well-formed Unicode string,
/// this initializer returns `nil`.
public init?(validating path: FilePath) {
self.init(_validating: path)
}
}
@available(System 0.0.2, *)
extension String {
/// Creates a string by interpreting the path component's content as UTF-8 on
/// Unix and UTF-16 on Windows.
///
/// - Parameter component: The path component to be interpreted as
/// `CInterop.PlatformUnicodeEncoding`.
///
/// If the content of the path component isn't a well-formed Unicode string,
/// this initializer replaces invalid bytes with U+FFFD.
/// This means that, depending on the semantics of the specific file system,
/// conversion to a string and back to a path component
/// might result in a value that's different from the original path component.
public init(decoding component: FilePath.Component) {
self.init(_decoding: component)
}
/// Creates a string from a path component, validating its contents as UTF-8
/// on Unix and UTF-16 on Windows.
///
/// - Parameter component: The path component to be interpreted as
/// `CInterop.PlatformUnicodeEncoding`.
///
/// If the contents of the path component isn't a well-formed Unicode string,
/// this initializer returns `nil`.
public init?(validating component: FilePath.Component) {
self.init(_validating: component)
}
}
@available(System 0.0.2, *)
extension String {
/// On Unix, creates the string `"/"`
///
/// On Windows, creates a string by interpreting the path root's content as
/// UTF-16.
///
/// - Parameter root: The path root to be interpreted as
/// `CInterop.PlatformUnicodeEncoding`.
///
/// If the content of the path root isn't a well-formed Unicode string,
/// this initializer replaces invalid bytes with U+FFFD.
/// This means that on Windows,
/// conversion to a string and back to a path root
/// might result in a value that's different from the original path root.
public init(decoding root: FilePath.Root) {
self.init(_decoding: root)
}
/// On Unix, creates the string `"/"`
///
/// On Windows, creates a string from a path root, validating its contents as
/// UTF-16 on Windows.
///
/// - Parameter root: The path root to be interpreted as
/// `CInterop.PlatformUnicodeEncoding`.
///
/// On Windows, if the contents of the path root isn't a well-formed Unicode
/// string, this initializer returns `nil`.
public init?(validating root: FilePath.Root) {
self.init(_validating: root)
}
}
// MARK: - Internal helpers
extension String {
fileprivate init<PS: _PlatformStringable>(_decoding ps: PS) {
self = ps._withPlatformString { String(platformString: $0) }
}
fileprivate init?<PS: _PlatformStringable>(_validating ps: PS) {
guard let str = ps._withPlatformString(
String.init(validatingPlatformString:)
) else {
return nil
}
self = str
}
}
// MARK: - Deprecations
@available(System 0.0.1, *)
extension String {
@available(*, deprecated, renamed: "init(decoding:)")
public init(_ path: FilePath) { self.init(decoding: path) }
@available(*, deprecated, renamed: "init(validating:)")
public init?(validatingUTF8 path: FilePath) { self.init(validating: path) }
}
#if !os(Windows)
@available(System 0.0.1, *)
extension FilePath {
/// For backwards compatibility only. This initializer is equivalent to
/// the preferred `FilePath(platformString:)`.
@available(*, deprecated, renamed: "init(platformString:)")
public init(cString: UnsafePointer<CChar>) {
self.init(platformString: cString)
}
@available(*, deprecated, renamed: "init(platformString:)")
public init(cString: [CChar]) {
self.init(platformString: cString)
}
@available(*, deprecated, renamed: "init(platformString:)")
public init(cString: inout CChar) {
self.init(platformString: &cString)
}
@available(*, deprecated, renamed: "init(platformString:)")
public init(cString: String) {
self.init(platformString: cString)
}
/// For backwards compatibility only. This function is equivalent to
/// the preferred `withPlatformString`.
public func withCString<Result>(
_ body: (UnsafePointer<CChar>) throws(SystemError) -> Result
) throws(SystemError) -> Result {
return try _withPlatformString(body)
}
}
#endif
@@ -0,0 +1,593 @@
/*
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
*/
// MARK: - Query API
@available(System 0.0.2, *)
extension FilePath {
/// Returns true if this path uniquely identifies the location of
/// a file without reference to an additional starting location.
///
/// On Unix platforms, absolute paths begin with a `/`. `isAbsolute` is
/// equivalent to `root != nil`.
///
/// On Windows, absolute paths are fully qualified paths. `isAbsolute` is
/// _not_ equivalent to `root != nil` for traditional DOS paths
/// (e.g. `C:foo` and `\bar` have roots but are not absolute). UNC paths
/// and device paths are always absolute. Traditional DOS paths are
/// absolute only if they begin with a volume or drive followed by
/// a `:` and a separator.
///
/// NOTE: This does not perform shell expansion or substitute
/// environment variables; paths beginning with `~` are considered relative.
///
/// Examples:
/// * Unix:
/// * `/usr/local/bin`
/// * `/tmp/foo.txt`
/// * `/`
/// * Windows:
/// * `C:\Users\`
/// * `\\?\UNC\server\share\bar.exe`
/// * `\\server\share\bar.exe`
public var isAbsolute: Bool {
self.root?.isAbsolute ?? false
}
/// Returns true if this path is not absolute (see `isAbsolute`).
///
/// Examples:
/// * Unix:
/// * `~/bar`
/// * `tmp/foo.txt`
/// * Windows:
/// * `bar\baz`
/// * `C:Users\`
/// * `\Users`
public var isRelative: Bool { !isAbsolute }
// TODO(Windows docs): examples with roots, such as whether `\foo\bar`
// starts with `C:\foo`
/// Returns whether `other` is a prefix of `self`, only considering
/// whole path components.
///
/// Example:
///
/// let path: FilePath = "/usr/bin/ls"
/// path.starts(with: "/") // true
/// path.starts(with: "/usr/bin") // true
/// path.starts(with: "/usr/bin/ls") // true
/// path.starts(with: "/usr/bin/ls///") // true
/// path.starts(with: "/us") // false
public func starts(with other: FilePath) -> Bool {
guard !other.isEmpty else { return true }
return self.root == other.root && components.starts(
with: other.components)
}
// TODO(Windows docs): examples with roots, such as whether `C:\foo\bar`
// ends with `C:bar`
/// Returns whether `other` is a suffix of `self`, only considering
/// whole path components.
///
/// Example:
///
/// let path: FilePath = "/usr/bin/ls"
/// path.ends(with: "ls") // true
/// path.ends(with: "bin/ls") // true
/// path.ends(with: "usr/bin/ls") // true
/// path.ends(with: "/usr/bin/ls///") // true
/// path.ends(with: "/ls") // false
public func ends(with other: FilePath) -> Bool {
if other.root != nil {
// TODO: anything tricky here for Windows?
return self == other
}
return components.reversed().starts(
with: other.components.reversed())
}
/// Whether this path is empty
public var isEmpty: Bool { _storage.isEmpty }
}
// MARK: - Decompose a path
@available(System 0.0.2, *)
extension FilePath {
/// Returns the root of a path if there is one, otherwise `nil`.
///
/// On Unix, this will return the leading `/` if the path is absolute
/// and `nil` if the path is relative.
///
/// On Windows, for traditional DOS paths, this will return
/// the path prefix up to and including a root directory or
/// a supplied drive or volume. Otherwise, if the path is relative to
/// both the current directory and current drive, returns `nil`.
///
/// On Windows, for UNC or device paths, this will return the path prefix
/// up to and including the host and share for UNC paths or the volume for
/// device paths followed by any subsequent separator.
///
/// Examples:
/// * Unix:
/// * `/foo/bar => /`
/// * `foo/bar => nil`
/// * Windows:
/// * `C:\foo\bar => C:\`
/// * `C:foo\bar => C:`
/// * `\foo\bar => \ `
/// * `foo\bar => nil`
/// * `\\server\share\file => \\server\share\`
/// * `\\?\UNC\server\share\file => \\?\UNC\server\share\`
/// * `\\.\device\folder => \\.\device\`
///
/// Setting the root to `nil` will remove the root and setting a new
/// root will replace the root.
///
/// Example:
///
/// var path: FilePath = "/foo/bar"
/// path.root = nil // path is "foo/bar"
/// path.root = "/" // path is "/foo/bar"
///
/// Example (Windows):
///
/// var path: FilePath = #"\foo\bar"#
/// path.root = nil // path is #"foo\bar"#
/// path.root = "C:" // path is #"C:foo\bar"#
/// path.root = #"C:\"# // path is #"C:\foo\bar"#
public var root: FilePath.Root? {
get {
guard _hasRoot else { return nil }
return Root(self, rootEnd: _relativeStart)
}
set {
defer { _invariantCheck() }
guard let r = newValue else {
_storage.removeSubrange(..<_relativeStart)
return
}
_storage.replaceSubrange(..<_relativeStart, with: r._slice)
}
}
/// Creates a new path containing just the components, i.e. everything
/// after `root`.
///
/// Returns self if `root == nil`.
///
/// Examples:
/// * Unix:
/// * `/foo/bar => foo/bar`
/// * `foo/bar => foo/bar`
/// * `/ => ""`
/// * Windows:
/// * `C:\foo\bar => foo\bar`
/// * `foo\bar => foo\bar`
/// * `\\?\UNC\server\share\file => file`
/// * `\\?\device\folder\file.exe => folder\file.exe`
/// * `\\server\share\file => file`
/// * `\ => ""`
public __consuming func removingRoot() -> FilePath {
var copy = self
copy.root = nil
return copy
}
}
@available(System 0.0.2, *)
extension FilePath {
/// Returns the final component of the path.
/// Returns `nil` if the path is empty or only contains a root.
///
/// Note: Even if the final component is a special directory
/// (`.` or `..`), it will still be returned. See `lexicallyNormalize()`.
///
/// Examples:
/// * Unix:
/// * `/usr/local/bin/ => bin`
/// * `/tmp/foo.txt => foo.txt`
/// * `/tmp/foo.txt/.. => ..`
/// * `/tmp/foo.txt/. => .`
/// * `/ => nil`
/// * Windows:
/// * `C:\Users\ => Users`
/// * `C:Users\ => Users`
/// * `C:\ => nil`
/// * `\Users\ => Users`
/// * `\\?\UNC\server\share\bar.exe => bar.exe`
/// * `\\server\share => nil`
/// * `\\?\UNC\server\share\ => nil`
public var lastComponent: Component? { components.last }
/// Creates a new path with everything up to but not including
/// `lastComponent`.
///
/// If the path only contains a root, returns `self`.
/// If the path has no root and only includes a single component,
/// returns an empty FilePath.
///
/// Examples:
/// * Unix:
/// * `/usr/bin/ls => /usr/bin`
/// * `/foo => /`
/// * `/ => /`
/// * `foo => ""`
/// * Windows:
/// * `C:\foo\bar.exe => C:\foo`
/// * `C:\ => C:\`
/// * `\\server\share\folder\file.txt => \\server\share\folder`
/// * `\\server\share\ => \\server\share\`
public __consuming func removingLastComponent() -> FilePath {
var copy = self
copy.removeLastComponent()
return copy
}
/// In-place mutating variant of `removingLastComponent`.
///
/// If `self` only contains a root, does nothing and returns `false`.
/// Otherwise removes `lastComponent` and returns `true`.
///
/// Example:
///
/// var path = "/usr/bin"
/// path.removeLastComponent() == true // path is "/usr"
/// path.removeLastComponent() == true // path is "/"
/// path.removeLastComponent() == false // path is "/"
@discardableResult
public mutating func removeLastComponent() -> Bool {
defer { _invariantCheck() }
guard let lastRel = lastComponent else { return false }
_storage.removeSubrange(lastRel._slice.indices)
_removeTrailingSeparator()
return true
}
}
@available(System 0.0.2, *)
extension FilePath.Component {
/// The extension of this file or directory component.
///
/// If `self` does not contain a `.` anywhere, or only
/// at the start, returns `nil`. Otherwise, returns everything after the dot.
///
/// Examples:
/// * `foo.txt => txt`
/// * `foo.tar.gz => gz`
/// * `Foo.app => app`
/// * `.hidden => nil`
/// * `.. => nil`
public var `extension`: String? {
guard let range = _extensionRange() else { return nil }
return _slice[range].string
}
/// The non-extension portion of this file or directory component.
///
/// Examples:
/// * `foo.txt => foo`
/// * `foo.tar.gz => foo.tar`
/// * `Foo.app => Foo`
/// * `.hidden => .hidden`
/// * `.. => ..`
public var stem: String {
_slice[_stemRange()].string
}
}
@available(System 0.0.2, *)
extension FilePath {
/// The extension of the file or directory last component.
///
/// If `lastComponent` is `nil` or one of the special path components
/// `.` or `..`, `get` returns `nil` and `set` does nothing.
///
/// If `lastComponent` does not contain a `.` anywhere, or only
/// at the start, `get` returns `nil` and `set` will append a
/// `.` and `newValue` to `lastComponent`.
///
/// Otherwise `get` returns everything after the last `.` and `set` will
/// replace the extension.
///
/// Examples:
/// * `/tmp/foo.txt => txt`
/// * `/Applications/Foo.app/ => app`
/// * `/Applications/Foo.app/bar.txt => txt`
/// * `/tmp/foo.tar.gz => gz`
/// * `/tmp/.hidden => nil`
/// * `/tmp/.hidden. => ""`
/// * `/tmp/.. => nil`
///
/// Example:
///
/// var path = "/tmp/file"
/// path.extension = "txt" // path is "/tmp/file.txt"
/// path.extension = "o" // path is "/tmp/file.o"
/// path.extension = nil // path is "/tmp/file"
/// path.extension = "" // path is "/tmp/file."
public var `extension`: String? {
get { lastComponent?.extension }
set {
defer { _invariantCheck() }
guard let base = lastComponent, base.kind == .regular else { return }
let suffix: SystemString
if let ext = newValue {
suffix = _makeExtension(ext)
} else {
suffix = SystemString()
}
let extRange = (
base._extensionIndex() ?? base._slice.endIndex
) ..< base._slice.endIndex
_storage.replaceSubrange(extRange, with: suffix)
}
}
/// The non-extension portion of the file or directory last component.
///
/// Returns `nil` if `lastComponent` is `nil`
///
/// * `/tmp/foo.txt => foo`
/// * `/Applications/Foo.app/ => Foo`
/// * `/Applications/Foo.app/bar.txt => bar`
/// * `/tmp/.hidden => .hidden`
/// * `/tmp/.. => ..`
/// * `/ => nil`
public var stem: String? { lastComponent?.stem }
}
@available(System 0.0.2, *)
extension FilePath {
/// Whether the path is in lexical-normal form, that is `.` and `..`
/// components have been collapsed lexically (i.e. without following
/// symlinks).
///
/// Examples:
/// * `"/usr/local/bin".isLexicallyNormal == true`
/// * `"../local/bin".isLexicallyNormal == true`
/// * `"local/bin/..".isLexicallyNormal == false`
public var isLexicallyNormal: Bool {
// `..` components are permitted at the front of a
// relative path, otherwise there should be no special directories
//
// FIXME: Windows `C:..\foo\bar` should probably be lexically normal, but
// `\..\foo\bar` should not.
components.drop(
while: { root == nil && $0.kind == .parentDirectory }
).allSatisfy { $0.kind == .regular }
}
/// Collapse `.` and `..` components lexically (i.e. without following
/// symlinks).
///
/// Examples:
/// * `/usr/./local/bin/.. => /usr/local`
/// * `/../usr/local/bin => /usr/local/bin`
/// * `../usr/local/../bin => ../usr/bin`
public mutating func lexicallyNormalize() {
defer { _invariantCheck() }
_normalizeSpecialDirectories()
}
/// Returns a copy of `self` in lexical-normal form, that is `.` and `..`
/// components have been collapsed lexically (i.e. without following
/// symlinks). See `lexicallyNormalize`
public __consuming func lexicallyNormalized() -> FilePath {
var copy = self
copy.lexicallyNormalize()
return copy
}
/// Create a new `FilePath` by resolving `subpath` relative to `self`,
/// ensuring that the result is lexically contained within `self`.
///
/// `subpath` will be lexically normalized (see `lexicallyNormalize`) as
/// part of resolution, meaning any contained `.` and `..` components will
/// be collapsed without resolving symlinks. Any root in `subpath` will be
/// ignored.
///
/// Returns `nil` if the result would "escape" from `self` through use of
/// the special directory component `..`.
///
/// This is useful for protecting against arbitrary path traversal from an
/// untrusted subpath: the result is guaranteed to be lexically contained
/// within `self`. Since this operation does not consult the file system to
/// resolve symlinks, any escaping symlinks nested inside of `self` can still
/// be targeted by the result.
///
/// Example:
///
/// let staticContent: FilePath = "/var/www/my-website/static"
/// let links: [FilePath] =
/// ["index.html", "/assets/main.css", "../../../../etc/passwd"]
/// links.map { staticContent.lexicallyResolving($0) }
/// // ["/var/www/my-website/static/index.html",
/// // "/var/www/my-website/static/assets/main.css",
/// // nil]
public __consuming func lexicallyResolving(
_ subpath: __owned FilePath
) -> FilePath? {
let subpath = subpath.removingRoot().lexicallyNormalized()
guard !subpath.isEmpty else { return self }
guard subpath.components.first?.kind != .parentDirectory else {
return nil
}
return self.appending(subpath.components)
}
}
// Modification and concatenation API
@available(System 0.0.2, *)
extension FilePath {
// TODO(Windows docs): example with roots
/// If `prefix` is a prefix of `self`, removes it and returns `true`.
/// Otherwise returns `false`.
///
/// Example:
///
/// var path: FilePath = "/usr/local/bin"
/// path.removePrefix("/usr/bin") // false
/// path.removePrefix("/us") // false
/// path.removePrefix("/usr/local") // true, path is "bin"
public mutating func removePrefix(_ prefix: FilePath) -> Bool {
defer { _invariantCheck() }
// FIXME: Should Windows have more nuanced semantics?
guard root == prefix.root else { return false }
let (tail, remainder) = _dropCommonPrefix(components, prefix.components)
guard remainder.isEmpty else { return false }
self._storage.removeSubrange(..<tail.startIndex._storage)
return true
}
// TODO(Windows docs): example with roots
/// Append a `component` on to the end of this path.
///
/// Example:
///
/// var path: FilePath = "/tmp"
/// let sub: FilePath = "foo/./bar/../baz/."
/// for comp in sub.components.filter({ $0.kind != .currentDirectory }) {
/// path.append(comp)
/// }
/// // path is "/tmp/foo/bar/../baz"
public mutating func append(_ component: __owned FilePath.Component) {
defer { _invariantCheck() }
_append(unchecked: component._slice)
}
// TODO(Windows docs): example with roots
/// Append `components` on to the end of this path.
///
/// Example:
///
/// var path: FilePath = "/"
/// path.append(["usr", "local"]) // path is "/usr/local"
/// let otherPath: FilePath = "/bin/ls"
/// path.append(otherPath.components) // path is "/usr/local/bin/ls"
public mutating func append<C: Collection>(
_ components: __owned C
) where C.Element == FilePath.Component {
defer { _invariantCheck() }
for c in components {
_append(unchecked: c._slice)
}
}
// TODO(Windows docs): example with roots, should we rephrase this "spurious
// roots"?
/// Append the contents of `other`, ignoring any spurious leading separators.
///
/// A leading separator is spurious if `self` is non-empty.
///
/// Example:
///
/// var path: FilePath = ""
/// path.append("/var/www/website") // "/var/www/website"
/// path.append("static/assets") // "/var/www/website/static/assets"
/// path.append("/main.css") // "/var/www/website/static/assets/main.css"
public mutating func append(_ other: __owned String) {
defer { _invariantCheck() }
guard !other.utf8.isEmpty else { return }
guard !isEmpty else {
self = FilePath(other)
return
}
let otherPath = FilePath(other)
_append(unchecked: otherPath._storage[otherPath._relativeStart...])
}
// TODO(Windows docs): example with roots
/// Non-mutating version of `append(_:Component)`.
public __consuming func appending(_ other: __owned Component) -> FilePath {
var copy = self
copy.append(other)
return copy
}
// TODO(Windows docs): example with roots
/// Non-mutating version of `append(_:C)`.
public __consuming func appending<C: Collection>(
_ components: __owned C
) -> FilePath where C.Element == FilePath.Component {
var copy = self
copy.append(components)
return copy
}
// TODO(Windows docs): example with roots
/// Non-mutating version of `append(_:String)`.
public __consuming func appending(_ other: __owned String) -> FilePath {
var copy = self
copy.append(other)
return copy
}
// TODO(Windows docs): examples and docs with roots, update/generalize doc
// comment
/// If `other` does not have a root, append each component of `other`. If
/// `other` has a root, replaces `self` with other.
///
/// This operation mimics traversing a directory structure (similar to the
/// `cd` command), where pushing a relative path will append its components
/// and pushing an absolute path will first clear `self`'s existing
/// components.
///
/// Example:
///
/// var path: FilePath = "/tmp"
/// path.push("dir/file.txt") // path is "/tmp/dir/file.txt"
/// path.push("/bin") // path is "/bin"
public mutating func push(_ other: __owned FilePath) {
defer { _invariantCheck() }
guard other.root == nil else {
self = other
return
}
// FIXME: Windows drive-relative roots, etc?
_append(unchecked: other._storage[...])
}
// TODO(Windows docs): examples and docs with roots
/// Non-mutating version of `push()`.
public __consuming func pushing(_ other: __owned FilePath) -> FilePath {
var copy = self
copy.push(other)
return copy
}
/// Remove the contents of the path, keeping the null terminator.
public mutating func removeAll(keepingCapacity: Bool = false) {
defer { _invariantCheck() }
_storage.removeAll(keepingCapacity: keepingCapacity)
}
/// Reserve enough storage space to store `minimumCapacity` platform
/// characters.
public mutating func reserveCapacity(_ minimumCapacity: Int) {
defer { _invariantCheck() }
self._storage.reserveCapacity(minimumCapacity)
}
}
// MARK - Renamed
@available(System 0.0.2, *)
extension FilePath {
@available(*, unavailable, renamed: "removingLastComponent()")
public var dirname: FilePath { removingLastComponent() }
@available(*, unavailable, renamed: "lastComponent")
public var basename: Component? { lastComponent }
}
@@ -0,0 +1,97 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2024 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
*/
// MARK: - API
/// Create a temporary path for the duration of the closure.
///
/// - Parameters:
/// - basename: The base name for the temporary path.
/// - body: The closure to execute.
///
/// Creates a temporary directory with a name based on the given `basename`,
/// executes `body`, passing in the path of the created directory, then
/// deletes the directory and all of its contents before returning.
internal func withTemporaryFilePath<R>(
basename: FilePath.Component,
_ body: (FilePath) throws(SystemError) -> R
) throws(SystemError) -> R {
let temporaryDir = try createUniqueTemporaryDirectory(basename: basename)
defer {
try? _recursiveRemove(at: temporaryDir)
}
return try body(temporaryDir)
}
// MARK: - Internals
fileprivate let base64 = Array<UInt8>(
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_".utf8
)
/// Create a directory that is only accessible to the current user.
///
/// - Parameters:
/// - path: The path of the directory to create.
/// - Returns: `true` if a new directory was created.
///
/// This function will throw if there is an error, except if the error
/// is that the directory exists, in which case it returns `false`.
fileprivate func makeLockedDownDirectory(at path: FilePath) throws(SystemError) -> Bool {
return try path.withPlatformString { (platformString) throws(SystemError) in
if system_mkdir(platformString, 0o700) == 0 {
return true
}
let err = system_errno
if err == Errno.fileExists.rawValue {
return false
} else {
throw Errno(rawValue: err)
}
}
}
/// Generate a random string of base64 filename safe characters.
///
/// - Parameters:
/// - length: The number of characters in the returned string.
/// - Returns: A random string of length `length`.
fileprivate func createRandomString(length: Int) -> String {
return String(
decoding: (0..<length).map{
_ in base64[Int.random(in: 0..<64)]
},
as: UTF8.self
)
}
/// Given a base name, create a uniquely named temporary directory.
///
/// - Parameters:
/// - basename: The base name for the new directory.
/// - Returns: The path to the new directory.
///
/// Creates a directory in the system temporary directory whose name
/// starts with `basename`, followed by a `.` and then a random
/// string of characters.
fileprivate func createUniqueTemporaryDirectory(
basename: FilePath.Component
) throws(SystemError) -> FilePath {
var tempDir = try _getTemporaryDirectory()
tempDir.append(basename)
while true {
tempDir.extension = createRandomString(length: 16)
if try makeLockedDownDirectory(at: tempDir) {
return tempDir
}
}
}
@@ -0,0 +1,153 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2024 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
*/
#if !os(Windows)
/// Get the path to the system temporary directory.
internal func _getTemporaryDirectory() throws(SystemError) -> FilePath {
guard let tmp = system_getenv("TMPDIR") else {
return "/tmp"
}
return FilePath(SystemString(platformString: tmp))
}
/// Delete the entire contents of a directory, including its subdirectories.
///
/// - Parameters:
/// - path: The directory to be deleted.
///
/// Removes a directory completely, including all of its contents.
internal func _recursiveRemove(
at path: FilePath
) throws(SystemError) {
let dirfd = try FileDescriptor.open(path, .readOnly, options: .directory)
defer {
try? dirfd.close()
}
let dot: (CInterop.PlatformChar, CInterop.PlatformChar) = (46, 0)
try withUnsafeBytes(of: dot) { (bytes) throws(SystemError) in
try recursiveRemove(
in: dirfd.rawValue,
name: bytes.assumingMemoryBound(to: CInterop.PlatformChar.self).baseAddress!
)
}
try path.withPlatformString { (platformString) throws(SystemError) in
if system_rmdir(platformString) != 0 {
throw Errno.current
}
}
}
/// Open a directory by reference to its parent and name.
///
/// - Parameters:
/// - dirfd: An open file descriptor for the parent directory.
/// - name: The name of the directory to open.
/// - Returns: A pointer to a `DIR` structure.
///
/// This is like `opendir()`, but instead of taking a path, it uses a
/// file descriptor pointing at the parent, thus avoiding path length
/// limits.
fileprivate func impl_opendirat(
_ dirfd: CInt,
_ name: UnsafePointer<CInterop.PlatformChar>
) -> system_DIRPtr? {
let fd = system_openat(dirfd, name,
FileDescriptor.AccessMode.readOnly.rawValue
| FileDescriptor.OpenOptions.directory.rawValue)
if fd < 0 {
return nil
}
return system_fdopendir(fd)
}
/// Invoke a closure for each file within a particular directory.
///
/// - Parameters:
/// - dirfd: The parent of the directory to be enumerated.
/// - subdir: The subdirectory to be enumerated.
/// - body: The closure that will be invoked.
///
/// We skip the `.` and `..` pseudo-entries.
fileprivate func forEachFile(
in dirfd: CInt,
subdir: UnsafePointer<CInterop.PlatformChar>,
_ body: (system_dirent) throws(SystemError) -> ()
) throws(SystemError) {
guard let dir = impl_opendirat(dirfd, subdir) else {
throw Errno.current
}
defer {
_ = system_closedir(dir)
}
while let dirent = system_readdir(dir) {
// Skip . and ..
if dirent.pointee.d_name.0 == 46
&& (dirent.pointee.d_name.1 == 0
|| (dirent.pointee.d_name.1 == 46
&& dirent.pointee.d_name.2 == 0)) {
continue
}
try body(dirent.pointee)
}
}
/// Delete the entire contents of a directory, including its subdirectories.
///
/// - Parameters:
/// - dirfd: The parent of the directory to be removed.
/// - name: The name of the directory to be removed.
///
/// Removes a directory completely, including all of its contents.
fileprivate func recursiveRemove(
in dirfd: CInt,
name: UnsafePointer<CInterop.PlatformChar>
) throws(SystemError) {
// First, deal with subdirectories
try forEachFile(in: dirfd, subdir: name) { dirent in
if dirent.d_type == SYSTEM_DT_DIR {
try withUnsafeBytes(of: dirent.d_name) {
try recursiveRemove(
in: dirfd,
name: $0.assumingMemoryBound(to: CInterop.PlatformChar.self)
.baseAddress!
)
}
}
}
// Now delete the contents of this directory
try forEachFile(in: dirfd, subdir: name) { dirent in
let flag: CInt
if dirent.d_type == SYSTEM_DT_DIR {
flag = SYSTEM_AT_REMOVE_DIR
} else {
flag = 0
}
let result = withUnsafeBytes(of: dirent.d_name) {
system_unlinkat(dirfd,
$0.assumingMemoryBound(to: CInterop.PlatformChar.self)
.baseAddress!,
flag)
}
if result != 0 {
throw Errno.current
}
}
}
#endif // !os(Windows)
@@ -0,0 +1,114 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2024 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
*/
#if os(Windows)
import WinSDK
/// Get the path to the system temporary directory.
internal func _getTemporaryDirectory() throws -> FilePath {
return try withUnsafeTemporaryAllocation(of: CInterop.PlatformChar.self,
capacity: Int(MAX_PATH) + 1) {
buffer in
guard GetTempPathW(DWORD(buffer.count), buffer.baseAddress) != 0 else {
throw Errno(windowsError: GetLastError())
}
return FilePath(SystemString(platformString: buffer.baseAddress!))
}
}
/// Invoke a closure for each file within a particular directory.
///
/// - Parameters:
/// - path: The path at which we should enumerate items.
/// - body: The closure that will be invoked.
///
/// We skip the `.` and `..` pseudo-entries.
fileprivate func forEachFile(
at path: FilePath,
_ body: (WIN32_FIND_DATAW) throws -> ()
) rethrows {
let searchPath = path.appending("\\*")
try searchPath.withPlatformString { szPath in
var findData = WIN32_FIND_DATAW()
let hFind = try szPath.withCanonicalPathRepresentation({ szPath in FindFirstFileW(szPath, &findData) })
if hFind == INVALID_HANDLE_VALUE {
throw Errno(windowsError: GetLastError())
}
defer {
FindClose(hFind)
}
repeat {
// Skip . and ..
if findData.cFileName.0 == 46
&& (findData.cFileName.1 == 0
|| (findData.cFileName.1 == 46
&& findData.cFileName.2 == 0)) {
continue
}
try body(findData)
} while FindNextFileW(hFind, &findData)
}
}
/// Delete the entire contents of a directory, including its subdirectories.
///
/// - Parameters:
/// - path: The directory to be deleted.
///
/// Removes a directory completely, including all of its contents.
internal func _recursiveRemove(
at path: FilePath
) throws {
// First, deal with subdirectories
try forEachFile(at: path) { findData in
if (findData.dwFileAttributes & DWORD(FILE_ATTRIBUTE_DIRECTORY)) != 0 {
let name = withUnsafeBytes(of: findData.cFileName) {
return SystemString(platformString: $0.assumingMemoryBound(
to: CInterop.PlatformChar.self).baseAddress!)
}
let component = FilePath.Component(name)!
let subpath = path.appending(component)
try _recursiveRemove(at: subpath)
}
}
// Now delete everything else
try forEachFile(at: path) { findData in
let name = withUnsafeBytes(of: findData.cFileName) {
return SystemString(platformString: $0.assumingMemoryBound(
to: CInterop.PlatformChar.self).baseAddress!)
}
let component = FilePath.Component(name)!
let subpath = path.appending(component)
if (findData.dwFileAttributes & DWORD(FILE_ATTRIBUTE_DIRECTORY)) == 0 {
try subpath.withPlatformString { subpath in
if try !subpath.withCanonicalPathRepresentation({ DeleteFileW($0) }) {
throw Errno(windowsError: GetLastError())
}
}
}
}
// Finally, delete the parent
try path.withPlatformString {
if try !$0.withCanonicalPathRepresentation({ RemoveDirectoryW($0) }) {
throw Errno(windowsError: GetLastError())
}
}
}
#endif // os(Windows)
@@ -0,0 +1,538 @@
/*
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
*/
internal struct _ParsedWindowsRoot {
var rootEnd: SystemString.Index
// TODO: Remove when I normalize to always (except `C:`)
// have trailing separator
var relativeBegin: SystemString.Index
var drive: SystemChar?
var fullyQualified: Bool
var deviceSigil: SystemChar?
var host: Range<SystemString.Index>?
var volume: Range<SystemString.Index>?
}
extension _ParsedWindowsRoot {
static func traditional(
drive: SystemChar?, fullQualified: Bool, endingAt idx: SystemString.Index
) -> _ParsedWindowsRoot {
_ParsedWindowsRoot(
rootEnd: idx,
relativeBegin: idx,
drive: drive,
fullyQualified: fullQualified,
deviceSigil: nil,
host: nil,
volume: nil)
}
static func unc(
deviceSigil: SystemChar?,
server: Range<SystemString.Index>,
share: Range<SystemString.Index>,
endingAt end: SystemString.Index,
relativeBegin relBegin: SystemString.Index
) -> _ParsedWindowsRoot {
_ParsedWindowsRoot(
rootEnd: end,
relativeBegin: relBegin,
drive: nil,
fullyQualified: true,
deviceSigil: deviceSigil,
host: server,
volume: share)
}
static func device(
deviceSigil: SystemChar,
volume: Range<SystemString.Index>,
endingAt end: SystemString.Index,
relativeBegin relBegin: SystemString.Index
) -> _ParsedWindowsRoot {
_ParsedWindowsRoot(
rootEnd: end,
relativeBegin: relBegin,
drive: nil,
fullyQualified: true,
deviceSigil: deviceSigil,
host: nil,
volume: volume)
}
}
struct _Lexer {
var slice: Slice<SystemString>
init(_ str: SystemString) {
self.slice = str[...]
}
var backslash: SystemChar { .backslash }
// Try to eat a backslash, returns false if nothing happened
mutating func eatBackslash() -> Bool {
slice._eat(.backslash) != nil
}
// Try to consume a drive letter and subsequent `:`.
mutating func eatDrive() -> SystemChar? {
let copy = slice
if let d = slice._eat(if: { $0.isLetter }), slice._eat(.colon) != nil {
return d
}
// Restore slice
slice = copy
return nil
}
// Try to consume a device sigil (stand-alone . or ?)
mutating func eatSigil() -> SystemChar? {
let copy = slice
guard let sigil = slice._eat(.question) ?? slice._eat(.dot) else {
return nil
}
// Check for something like .hidden or ?question
guard isEmpty || slice.first == backslash else {
slice = copy
return nil
}
return sigil
}
// Try to consume an explicit "UNC" directory
mutating func eatUNC() -> Bool {
slice._eatSequence("UNC".unicodeScalars.lazy.map { SystemChar(ascii: $0) }) != nil
}
// Eat everything up to but not including a backslash or null
mutating func eatComponent() -> Range<SystemString.Index> {
let backslash = self.backslash
let component = slice._eatWhile({ $0 != backslash })
?? slice[slice.startIndex ..< slice.startIndex]
return component.indices
}
var isEmpty: Bool {
return slice.isEmpty
}
var current: SystemString.Index { slice.startIndex }
mutating func clear() {
// TODO: Intern empty system string
self = _Lexer(SystemString())
}
mutating func reset(to: SystemString, at: SystemString.Index) {
self.slice = to[at...]
}
}
internal struct WindowsRootInfo {
// The "volume" of a root. For UNC paths, this is also known as the "share".
internal enum Volume: Equatable {
/// No volume specified
///
/// * Traditional root relative to the current drive: `\`,
/// * Omitted volume from other forms: `\\.\`, `\\.\UNC\server\\`, `\\server\\`
case empty
// TODO: NT paths? Admin paths using `$`?
/// A specified drive.
///
/// * Traditional disk: `C:\`, `C:`
/// * Device disk: `\\.\C:\`, `\\?\C:\`
/// * UNC: `\\server\e:\`, `\\?\UNC\server\e:\`
case drive(Character)
// TODO: GUID type?
/// A volume with a GUID in a non-traditional path
///
/// * UNC: `\\host\Volume{0000-...}\`, `\\.\UNC\host\Volume{0000-...}\`
/// * Device roots: `\\.\Volume{0000-...}\`, `\\?\Volume{000-...}\`
case guid(String)
// TODO: Legacy DOS devices, such as COM1?
/// Device object or share name
///
/// * Device roots: `\\.\BootPartition\`
/// * UNC: `\\host\volume\`
case volume(String)
// TODO: Should legacy DOS devices be detected and/or converted at construction time?
// TODO: What about NT paths: `\??\`
}
/// Represents the syntactic form of the path
internal enum Form: Equatable {
/// Traditional DOS roots: `C:\`, `C:`, and `\`
case traditional(fullyQualified: Bool) // `C:\`, `C:`, `\`
/// UNC syntactic form: `\\server\share\`
case unc
/// DOS device syntactic form: `\\?\BootPartition`, `\\.\C:\`, `\\?\UNC\server\share`
case device(sigil: Character)
// TODO: NT?
}
/// The host for UNC paths, else `nil`.
internal var host: String?
/// The specified volume (or UNC share) for the root
internal var volume: Volume
/// The syntactic form the root is in
internal var form: Form
init(host: String?, volume: Volume, form: Form) {
self.host = host
self.volume = volume
self.form = form
checkInvariants()
}
}
extension _ParsedWindowsRoot {
fileprivate func volumeInfo(_ root: SystemString) -> WindowsRootInfo.Volume {
if let d = self.drive {
return .drive(Character(d.asciiScalar!))
}
guard let vol = self.volume, !vol.isEmpty else { return .empty }
// TODO: check for GUID
// TODO: check for drive
return .volume(root[vol].string)
}
}
extension WindowsRootInfo {
internal init(_ root: SystemString, _ parsed: _ParsedWindowsRoot) {
self.volume = parsed.volumeInfo(root)
if let host = parsed.host {
self.host = root[host].string
} else {
self.host = nil
}
if let sig = parsed.deviceSigil {
self.form = .device(sigil: Character(sig.asciiScalar!))
} else if parsed.host != nil {
assert(parsed.volume != nil)
self.form = .unc
} else {
self.form = .traditional(fullyQualified: parsed.fullyQualified)
}
}
}
extension WindowsRootInfo {
/// NOT `\foo\bar` nor `C:foo\bar`
internal var isFullyQualified: Bool {
return form != .traditional(fullyQualified: false)
}
///
/// `\\server\share\foo\bar.exe`, `\\.\UNC\server\share\foo\bar.exe`
internal var isUNC: Bool {
host != nil
}
///
/// `\foo\bar.exe`
internal var isTraditionalRooted: Bool {
form == .traditional(fullyQualified: false) && volume == .empty
}
///
/// `C:foo\bar.exe`
internal var isTraditionalDriveRelative: Bool {
switch (form, volume) {
case (.traditional(fullyQualified: false), .drive(_)): return true
default: return false
}
}
// TODO: Should this be component?
func formPath() -> FilePath {
fatalError("Unimplemented")
}
// static func traditional(
// drive: Character?, fullyQualified: Bool
// ) -> WindowsRootInfo {
// let vol: Volume
// if let d = Character {
// vol = .drive(d)
// } else {
// vol = .relative
// }
//
// return WindowsRootInfo(
// volume: .relative, form: .traditional(fullyQualified: false))
// }
internal func checkInvariants() {
switch form {
case .traditional(let qual):
precondition(host == nil)
switch volume {
case .empty:
precondition(!qual)
break
case .drive(_): break
default: preconditionFailure()
}
case .unc:
precondition(host != nil)
case .device(_): break
}
}
}
extension SystemString {
// TODO: Or, should I always inline this to remove some of the bookeeping?
private func _parseWindowsRootInternal() -> _ParsedWindowsRoot? {
assert(_windowsPaths)
/*
Windows root: device or UNC or DOS
device: (`\\.` or `\\?`) `\` (drive or guid or UNC-link)
drive: letter `:`
guid: `Volume{` (hex-digit or `-`)* `}`
UNC-link: `UNC\` UNC-volume
UNC: `\\` UNC-volume
UNC-volume: server `\` share
DOS: fully-qualified or legacy-device or drive or `\`
full-qualified: drive `\`
TODO: What is \\?\server1\e:\utilities\\filecomparer\ from the docs?
TODO: What about admin use of `$` instead of `:`? E.g. \\system07\C$\
NOTE: Legacy devices are not handled by System at a library level, but
are deferred to the relevant syscalls.
*/
var lexer = _Lexer(self)
// Helper to parse a UNC root
func parseUNC(deviceSigil: SystemChar?) -> _ParsedWindowsRoot {
let serverRange = lexer.eatComponent()
guard lexer.eatBackslash() else {
fatalError("expected normalized root to contain backslash")
}
let shareRange = lexer.eatComponent()
let rootEnd = lexer.current
_ = lexer.eatBackslash()
return .unc(
deviceSigil: deviceSigil,
server: serverRange, share: shareRange,
endingAt: rootEnd, relativeBegin: lexer.current)
}
// `C:` or `C:\`
if let d = lexer.eatDrive() {
// `C:\` - fully qualified
let fullyQualified = lexer.eatBackslash()
return .traditional(
drive: d, fullQualified: fullyQualified, endingAt: lexer.current)
}
// `\` or else it's just a rootless relative path
guard lexer.eatBackslash() else { return nil }
// `\\` or else it's just a current-drive rooted traditional path
guard lexer.eatBackslash() else {
return .traditional(
drive: nil, fullQualified: false, endingAt: lexer.current)
}
// `\\.` or `\\?` (device paths) or else it's just UNC
guard let sigil = lexer.eatSigil() else {
return parseUNC(deviceSigil: nil)
}
_ = sigil // suppress warnings
guard lexer.eatBackslash() else {
fatalError("expected normalized root to contain backslash")
}
if lexer.eatUNC() {
guard lexer.eatBackslash() else {
fatalError("expected normalized root to contain backslash")
}
return parseUNC(deviceSigil: sigil)
}
let device = lexer.eatComponent()
let rootEnd = lexer.current
_ = lexer.eatBackslash()
return .device(
deviceSigil: sigil, volume: device,
endingAt: rootEnd, relativeBegin: lexer.current)
}
@inline(never)
internal func _parseWindowsRoot() -> (
rootEnd: SystemString.Index, relativeBegin: SystemString.Index
) {
guard let parsed = _parseWindowsRootInternal() else {
return (startIndex, startIndex)
}
return (parsed.rootEnd, parsed.relativeBegin)
}
}
extension SystemString {
// UNC and device roots can have multiple repeated roots that are meaningful,
// and extra backslashes may need to be inserted for partial roots (e.g. empty
// volume).
//
// Returns the point where `_normalizeSeparators` should resume.
internal mutating func _prenormalizeWindowsRoots() -> Index {
assert(_windowsPaths)
assert(!self.contains(.slash), "only valid after separator conversion")
var lexer = _Lexer(self)
// Only relevant for UNC or device paths
guard lexer.eatBackslash(), lexer.eatBackslash() else {
return lexer.current
}
// Parse a backslash, inserting one if needed
func expectBackslash() {
if lexer.eatBackslash() { return }
// A little gross, but we reset the lexer because the lexer
// holds a strong reference to `self`.
//
// TODO: Intern the empty SystemString. Right now, this is
// along an uncommon/pathological case, but we want to in
// general make empty strings without allocation
let idx = lexer.current
lexer.clear()
self.insert(.backslash, at: idx)
lexer.reset(to: self, at: idx)
let p = lexer.eatBackslash()
assert(p)
}
// Parse a component and subsequent backslash, insering one if needed
func expectComponent() {
_ = lexer.eatComponent()
expectBackslash()
}
// Check for `\\.` style paths
if lexer.eatSigil() != nil {
expectBackslash()
if lexer.eatUNC() {
expectBackslash()
expectComponent()
expectComponent()
return lexer.current
}
expectComponent()
return lexer.current
}
expectComponent()
expectComponent()
return lexer.current
}
}
#if os(Windows)
import WinSDK
// FIXME: Rather than canonicalizing the path at every call site to a Win32 API,
// we should consider always storing absolute paths with the \\?\ prefix applied,
// for better performance.
extension UnsafePointer where Pointee == CInterop.PlatformChar {
/// Invokes `body` with a resolved and potentially `\\?\`-prefixed version of the pointee,
/// to ensure long paths greater than MAX_PATH (260) characters are handled correctly.
///
/// - seealso: https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation
internal func withCanonicalPathRepresentation<Result>(_ body: (Self) throws -> Result) throws -> Result {
// 1. Normalize the path first.
// Contrary to the documentation, this works on long paths independently
// of the registry or process setting to enable long paths (but it will also
// not add the \\?\ prefix required by other functions under these conditions).
let dwLength: DWORD = GetFullPathNameW(self, 0, nil, nil)
return try withUnsafeTemporaryAllocation(of: WCHAR.self, capacity: Int(dwLength)) { pwszFullPath in
guard (1..<dwLength).contains(GetFullPathNameW(self, DWORD(pwszFullPath.count), pwszFullPath.baseAddress, nil)) else {
throw Errno(rawValue: _mapWindowsErrorToErrno(GetLastError()))
}
// 1.5 Leave \\.\ prefixed paths alone since device paths are already an exact representation and PathCchCanonicalizeEx will mangle these.
if let base = pwszFullPath.baseAddress,
base[0] == UInt8(ascii: "\\"),
base[1] == UInt8(ascii: "\\"),
base[2] == UInt8(ascii: "."),
base[3] == UInt8(ascii: "\\") {
return try body(base)
}
// 2. Canonicalize the path.
// This will add the \\?\ prefix if needed based on the path's length.
var pwszCanonicalPath: LPWSTR?
let flags: ULONG = numericCast(PATHCCH_ALLOW_LONG_PATHS.rawValue)
let result = PathAllocCanonicalize(pwszFullPath.baseAddress, flags, &pwszCanonicalPath)
if let pwszCanonicalPath {
defer { LocalFree(pwszCanonicalPath) }
if result == S_OK {
// 3. Perform the operation on the normalized path.
return try body(pwszCanonicalPath)
}
}
throw Errno(rawValue: _mapWindowsErrorToErrno(WIN32_FROM_HRESULT(result)))
}
}
}
@inline(__always)
fileprivate func HRESULT_CODE(_ hr: HRESULT) -> DWORD {
DWORD(hr) & 0xffff
}
@inline(__always)
fileprivate func HRESULT_FACILITY(_ hr: HRESULT) -> DWORD {
DWORD(hr << 16) & 0x1fff
}
@inline(__always)
fileprivate func SUCCEEDED(_ hr: HRESULT) -> Bool {
hr >= 0
}
// This is a non-standard extension to the Windows SDK that allows us to convert
// an HRESULT to a Win32 error code.
@inline(__always)
fileprivate func WIN32_FROM_HRESULT(_ hr: HRESULT) -> DWORD {
if SUCCEEDED(hr) { return DWORD(ERROR_SUCCESS) }
if HRESULT_FACILITY(hr) == FACILITY_WIN32 {
return HRESULT_CODE(hr)
}
return DWORD(hr)
}
#endif
+32 -30
View File
@@ -17,8 +17,8 @@
/// let perms = FilePermissions(rawValue: 0o644)
/// perms == [.ownerReadWrite, .groupRead, .otherRead] // true
@frozen
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
public struct FilePermissions: OptionSet, Hashable, Codable {
@available(System 0.0.1, *)
public struct FilePermissions: OptionSet, Sendable, Hashable {
/// The raw C file permissions.
@_alwaysEmitIntoClient
public let rawValue: CModeT
@@ -27,104 +27,101 @@ public struct FilePermissions: OptionSet, Hashable, Codable {
@_alwaysEmitIntoClient
public init(rawValue: CModeT) { self.rawValue = rawValue }
@_alwaysEmitIntoClient
private init(_ raw: CModeT) { self.init(rawValue: raw) }
/// Indicates that other users have read-only permission.
@_alwaysEmitIntoClient
public static var otherRead: FilePermissions { FilePermissions(0o4) }
public static var otherRead: FilePermissions { .init(rawValue: 0o4) }
/// Indicates that other users have write-only permission.
@_alwaysEmitIntoClient
public static var otherWrite: FilePermissions { FilePermissions(0o2) }
public static var otherWrite: FilePermissions { .init(rawValue: 0o2) }
/// Indicates that other users have execute-only permission.
@_alwaysEmitIntoClient
public static var otherExecute: FilePermissions { FilePermissions(0o1) }
public static var otherExecute: FilePermissions { .init(rawValue: 0o1) }
/// Indicates that other users have read-write permission.
@_alwaysEmitIntoClient
public static var otherReadWrite: FilePermissions { FilePermissions(0o6) }
public static var otherReadWrite: FilePermissions { .init(rawValue: 0o6) }
/// Indicates that other users have read-execute permission.
@_alwaysEmitIntoClient
public static var otherReadExecute: FilePermissions { FilePermissions(0o5) }
public static var otherReadExecute: FilePermissions { .init(rawValue: 0o5) }
/// Indicates that other users have write-execute permission.
@_alwaysEmitIntoClient
public static var otherWriteExecute: FilePermissions { FilePermissions(0o3) }
public static var otherWriteExecute: FilePermissions { .init(rawValue: 0o3) }
/// Indicates that other users have read, write, and execute permission.
@_alwaysEmitIntoClient
public static var otherReadWriteExecute: FilePermissions { FilePermissions(0o7) }
public static var otherReadWriteExecute: FilePermissions { .init(rawValue: 0o7) }
/// Indicates that the group has read-only permission.
@_alwaysEmitIntoClient
public static var groupRead: FilePermissions { FilePermissions(0o40) }
public static var groupRead: FilePermissions { .init(rawValue: 0o40) }
/// Indicates that the group has write-only permission.
@_alwaysEmitIntoClient
public static var groupWrite: FilePermissions { FilePermissions(0o20) }
public static var groupWrite: FilePermissions { .init(rawValue: 0o20) }
/// Indicates that the group has execute-only permission.
@_alwaysEmitIntoClient
public static var groupExecute: FilePermissions { FilePermissions(0o10) }
public static var groupExecute: FilePermissions { .init(rawValue: 0o10) }
/// Indicates that the group has read-write permission.
@_alwaysEmitIntoClient
public static var groupReadWrite: FilePermissions { FilePermissions(0o60) }
public static var groupReadWrite: FilePermissions { .init(rawValue: 0o60) }
/// Indicates that the group has read-execute permission.
@_alwaysEmitIntoClient
public static var groupReadExecute: FilePermissions { FilePermissions(0o50) }
public static var groupReadExecute: FilePermissions { .init(rawValue: 0o50) }
/// Indicates that the group has write-execute permission.
@_alwaysEmitIntoClient
public static var groupWriteExecute: FilePermissions { FilePermissions(0o30) }
public static var groupWriteExecute: FilePermissions { .init(rawValue: 0o30) }
/// Indicates that the group has read, write, and execute permission.
@_alwaysEmitIntoClient
public static var groupReadWriteExecute: FilePermissions { FilePermissions(0o70) }
public static var groupReadWriteExecute: FilePermissions { .init(rawValue: 0o70) }
/// Indicates that the owner has read-only permission.
@_alwaysEmitIntoClient
public static var ownerRead: FilePermissions { FilePermissions(0o400) }
public static var ownerRead: FilePermissions { .init(rawValue: 0o400) }
/// Indicates that the owner has write-only permission.
@_alwaysEmitIntoClient
public static var ownerWrite: FilePermissions { FilePermissions(0o200) }
public static var ownerWrite: FilePermissions { .init(rawValue: 0o200) }
/// Indicates that the owner has execute-only permission.
@_alwaysEmitIntoClient
public static var ownerExecute: FilePermissions { FilePermissions(0o100) }
public static var ownerExecute: FilePermissions { .init(rawValue: 0o100) }
/// Indicates that the owner has read-write permission.
@_alwaysEmitIntoClient
public static var ownerReadWrite: FilePermissions { FilePermissions(0o600) }
public static var ownerReadWrite: FilePermissions { .init(rawValue: 0o600) }
/// Indicates that the owner has read-execute permission.
@_alwaysEmitIntoClient
public static var ownerReadExecute: FilePermissions { FilePermissions(0o500) }
public static var ownerReadExecute: FilePermissions { .init(rawValue: 0o500) }
/// Indicates that the owner has write-execute permission.
@_alwaysEmitIntoClient
public static var ownerWriteExecute: FilePermissions { FilePermissions(0o300) }
public static var ownerWriteExecute: FilePermissions { .init(rawValue: 0o300) }
/// Indicates that the owner has read, write, and execute permission.
@_alwaysEmitIntoClient
public static var ownerReadWriteExecute: FilePermissions { FilePermissions(0o700) }
public static var ownerReadWriteExecute: FilePermissions { .init(rawValue: 0o700) }
/// Indicates that the file is executed as the owner.
///
/// For more information, see the `setuid(2)` man page.
@_alwaysEmitIntoClient
public static var setUserID: FilePermissions { FilePermissions(0o4000) }
public static var setUserID: FilePermissions { .init(rawValue: 0o4000) }
/// Indicates that the file is executed as the group.
///
/// For more information, see the `setgid(2)` man page.
@_alwaysEmitIntoClient
public static var setGroupID: FilePermissions { FilePermissions(0o2000) }
public static var setGroupID: FilePermissions { .init(rawValue: 0o2000) }
/// Indicates that executable's text segment
/// should be kept in swap space even after it exits.
@@ -132,10 +129,10 @@ public struct FilePermissions: OptionSet, Hashable, Codable {
/// For more information, see the `chmod(2)` man page's
/// discussion of `S_ISVTX` (the sticky bit).
@_alwaysEmitIntoClient
public static var saveText: FilePermissions { FilePermissions(0o1000) }
public static var saveText: FilePermissions { .init(rawValue: 0o1000) }
}
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
@available(System 0.0.1, *)
extension FilePermissions
: CustomStringConvertible, CustomDebugStringConvertible
{
@@ -175,3 +172,8 @@ extension FilePermissions
/// A textual representation of the file permissions, suitable for debugging.
public var debugDescription: String { self.description }
}
#if !$Embedded
@available(System 0.0.1, *)
extension FilePermissions: Codable {}
#endif
+71
View File
@@ -0,0 +1,71 @@
#if compiler(>=6.2) && $Lifetimes
#if os(Linux)
import CSystem
public extension IORing {
struct Completion: ~Copyable {
@inlinable init(rawValue inRawValue: io_uring_cqe) {
rawValue = inRawValue
}
@usableFromInline let rawValue: io_uring_cqe
}
}
public extension IORing.Completion {
struct Flags: OptionSet, Hashable, Codable {
public let rawValue: UInt32
@inlinable public init(rawValue: UInt32) {
self.rawValue = rawValue
}
///`IORING_CQE_F_BUFFER` Indicates the buffer ID is stored in the upper 16 bits
@inlinable public static var allocatedBuffer: Flags { Flags(rawValue: 1 << 0) }
///`IORING_CQE_F_MORE` Indicates more completions will be generated from the request that generated this
@inlinable public static var moreCompletions: Flags { Flags(rawValue: 1 << 1) }
//`IORING_CQE_F_SOCK_NONEMPTY`, but currently unused
//@inlinable public static var socketNotEmpty: Flags { Flags(rawValue: 1 << 2) }
//`IORING_CQE_F_NOTIF`, but currently unused
//@inlinable public static var isNotificationEvent: Flags { Flags(rawValue: 1 << 3) }
//IORING_CQE_F_BUF_MORE will eventually be (1U << 4) if we add IOU_PBUF_RING_INC support
}
}
public extension IORing.Completion {
@inlinable var context: UInt64 {
get {
rawValue.user_data
}
}
@inlinable var userPointer: UnsafeRawPointer? {
get {
UnsafeRawPointer(bitPattern: UInt(rawValue.user_data))
}
}
@inlinable var result: Int32 {
get {
rawValue.res
}
}
@inlinable var flags: IORing.Completion.Flags {
get {
Flags(rawValue: rawValue.flags & 0x0000FFFF)
}
}
@inlinable var bufferIndex: UInt16? {
get {
if self.flags.contains(.allocatedBuffer) {
return UInt16(rawValue.flags >> 16)
} else {
return nil
}
}
}
}
#endif // os(Linux)
#endif // compiler(>=6.2) && $Lifetimes
+497
View File
@@ -0,0 +1,497 @@
#if compiler(>=6.2) && $Lifetimes
#if os(Linux)
import CSystem
@usableFromInline
internal enum IORequestCore {
case nop // nothing here
case openat(
atDirectory: FileDescriptor,
path: FilePath,
FileDescriptor.AccessMode,
options: FileDescriptor.OpenOptions = FileDescriptor.OpenOptions(),
permissions: FilePermissions? = nil,
context: UInt64 = 0
)
case openatSlot(
atDirectory: FileDescriptor,
path: FilePath,
FileDescriptor.AccessMode,
options: FileDescriptor.OpenOptions = FileDescriptor.OpenOptions(),
permissions: FilePermissions? = nil,
intoSlot: IORing.RegisteredFile,
context: UInt64 = 0
)
case read(
file: FileDescriptor,
buffer: IORing.RegisteredBuffer,
offset: UInt64 = 0,
context: UInt64 = 0
)
case readUnregistered(
file: FileDescriptor,
buffer: UnsafeMutableRawBufferPointer,
offset: UInt64 = 0,
context: UInt64 = 0
)
case readSlot(
file: IORing.RegisteredFile,
buffer: IORing.RegisteredBuffer,
offset: UInt64 = 0,
context: UInt64 = 0
)
case readUnregisteredSlot(
file: IORing.RegisteredFile,
buffer: UnsafeMutableRawBufferPointer,
offset: UInt64 = 0,
context: UInt64 = 0
)
case write(
file: FileDescriptor,
buffer: IORing.RegisteredBuffer,
offset: UInt64 = 0,
context: UInt64 = 0
)
case writeUnregistered(
file: FileDescriptor,
buffer: UnsafeMutableRawBufferPointer,
offset: UInt64 = 0,
context: UInt64 = 0
)
case writeSlot(
file: IORing.RegisteredFile,
buffer: IORing.RegisteredBuffer,
offset: UInt64 = 0,
context: UInt64 = 0
)
case writeUnregisteredSlot(
file: IORing.RegisteredFile,
buffer: UnsafeMutableRawBufferPointer,
offset: UInt64 = 0,
context: UInt64 = 0
)
case close(
FileDescriptor,
context: UInt64 = 0
)
case closeSlot(
IORing.RegisteredFile,
context: UInt64 = 0
)
case unlinkAt(
atDirectory: FileDescriptor,
path: FilePath,
context: UInt64 = 0
)
case cancel(
flags:UInt32
)
case cancelContext(
flags: UInt32,
targetContext: UInt64
)
case cancelFD(
flags: UInt32,
targetFD: FileDescriptor
)
case cancelFDSlot(
flags: UInt32,
target: IORing.RegisteredFile
)
}
@inline(__always) @inlinable
internal func makeRawRequest_readWrite_registered(
file: FileDescriptor,
buffer: IORing.RegisteredBuffer,
offset: UInt64,
context: UInt64 = 0,
request: consuming RawIORequest
) -> RawIORequest {
request.fileDescriptor = file
request.buffer = buffer.unsafeBuffer
request.rawValue.buf_index = UInt16(exactly: buffer.index)!
request.offset = offset
request.rawValue.user_data = context
return request
}
@inline(__always) @inlinable
internal func makeRawRequest_readWrite_registered_slot(
file: IORing.RegisteredFile,
buffer: IORing.RegisteredBuffer,
offset: UInt64,
context: UInt64 = 0,
request: consuming RawIORequest
) -> RawIORequest {
request.rawValue.fd = Int32(exactly: file.index)!
request.flags = .fixedFile
request.buffer = buffer.unsafeBuffer
request.rawValue.buf_index = UInt16(exactly: buffer.index)!
request.offset = offset
request.rawValue.user_data = context
return request
}
@inline(__always) @inlinable
internal func makeRawRequest_readWrite_unregistered(
file: FileDescriptor,
buffer: UnsafeMutableRawBufferPointer,
offset: UInt64,
context: UInt64 = 0,
request: consuming RawIORequest
) -> RawIORequest {
request.fileDescriptor = file
request.buffer = buffer
request.offset = offset
request.rawValue.user_data = context
return request
}
@inline(__always) @inlinable
internal func makeRawRequest_readWrite_unregistered_slot(
file: IORing.RegisteredFile,
buffer: UnsafeMutableRawBufferPointer,
offset: UInt64,
context: UInt64 = 0,
request: consuming RawIORequest
) -> RawIORequest {
request.rawValue.fd = Int32(exactly: file.index)!
request.flags = .fixedFile
request.buffer = buffer
request.offset = offset
request.rawValue.user_data = context
return request
}
extension IORing {
public struct Request {
@usableFromInline var core: IORequestCore
@inlinable internal init(core inCore: IORequestCore) {
core = inCore
}
@inlinable internal consuming func extractCore() -> IORequestCore {
return core
}
}
}
extension IORing.Request {
@inlinable public static func nop(context: UInt64 = 0) -> IORing.Request {
.init(core: .nop)
}
@inlinable public static func read(
_ file: IORing.RegisteredFile,
into buffer: IORing.RegisteredBuffer,
at offset: UInt64 = 0,
context: UInt64 = 0
) -> IORing.Request {
.init(core: .readSlot(file: file, buffer: buffer, offset: offset, context: context))
}
@inlinable public static func read(
_ file: FileDescriptor,
into buffer: IORing.RegisteredBuffer,
at offset: UInt64 = 0,
context: UInt64 = 0
) -> IORing.Request {
.init(core: .read(file: file, buffer: buffer, offset: offset, context: context))
}
@inlinable public static func read(
_ file: IORing.RegisteredFile,
into buffer: UnsafeMutableRawBufferPointer,
at offset: UInt64 = 0,
context: UInt64 = 0
) -> IORing.Request {
.init(core: .readUnregisteredSlot(file: file, buffer: buffer, offset: offset, context: context))
}
@inlinable public static func read(
_ file: FileDescriptor,
into buffer: UnsafeMutableRawBufferPointer,
at offset: UInt64 = 0,
context: UInt64 = 0
) -> IORing.Request {
.init(core: .readUnregistered(file: file, buffer: buffer, offset: offset, context: context))
}
@inlinable public static func write(
_ buffer: IORing.RegisteredBuffer,
into file: IORing.RegisteredFile,
at offset: UInt64 = 0,
context: UInt64 = 0
) -> IORing.Request {
.init(core: .writeSlot(file: file, buffer: buffer, offset: offset, context: context))
}
@inlinable public static func write(
_ buffer: IORing.RegisteredBuffer,
into file: FileDescriptor,
at offset: UInt64 = 0,
context: UInt64 = 0
) -> IORing.Request {
.init(core: .write(file: file, buffer: buffer, offset: offset, context: context))
}
@inlinable public static func write(
_ buffer: UnsafeMutableRawBufferPointer,
into file: IORing.RegisteredFile,
at offset: UInt64 = 0,
context: UInt64 = 0
) -> IORing.Request {
.init(core: .writeUnregisteredSlot(
file: file, buffer: buffer, offset: offset, context: context))
}
@inlinable public static func write(
_ buffer: UnsafeMutableRawBufferPointer,
into file: FileDescriptor,
at offset: UInt64 = 0,
context: UInt64 = 0
) -> IORing.Request {
.init(
core: .writeUnregistered(file: file, buffer: buffer, offset: offset, context: context)
)
}
@inlinable public static func close(
_ file: FileDescriptor,
context: UInt64 = 0
) -> IORing.Request {
.init(core: .close(file, context: context))
}
@inlinable public static func close(
_ file: IORing.RegisteredFile,
context: UInt64 = 0
) -> IORing.Request {
.init(core: .closeSlot(file, context: context))
}
@inlinable public static func open(
_ path: FilePath,
in directory: FileDescriptor,
into slot: IORing.RegisteredFile,
mode: FileDescriptor.AccessMode,
options: FileDescriptor.OpenOptions = FileDescriptor.OpenOptions(),
permissions: FilePermissions? = nil,
context: UInt64 = 0
) -> IORing.Request {
.init(
core: .openatSlot(
atDirectory: directory, path: path, mode, options: options,
permissions: permissions, intoSlot: slot, context: context))
}
@inlinable public static func open(
_ path: FilePath,
in directory: FileDescriptor,
mode: FileDescriptor.AccessMode,
options: FileDescriptor.OpenOptions = FileDescriptor.OpenOptions(),
permissions: FilePermissions? = nil,
context: UInt64 = 0
) -> IORing.Request {
.init(
core: .openat(
atDirectory: directory, path: path, mode, options: options,
permissions: permissions, context: context
))
}
@inlinable public static func unlink(
_ path: FilePath,
in directory: FileDescriptor,
context: UInt64 = 0
) -> IORing.Request {
.init(core: .unlinkAt(atDirectory: directory, path: path, context: context))
}
// Cancel
/*
* ASYNC_CANCEL flags.
*
* IORING_ASYNC_CANCEL_ALL Cancel all requests that match the given key
* IORING_ASYNC_CANCEL_FD Key off 'fd' for cancellation rather than the
* request 'user_data'
* IORING_ASYNC_CANCEL_ANY Match any request
* IORING_ASYNC_CANCEL_FD_FIXED 'fd' passed in is a fixed descriptor
* IORING_ASYNC_CANCEL_USERDATA Match on user_data, default for no other key
* IORING_ASYNC_CANCEL_OP Match request based on opcode
*/
@inlinable internal static var SWIFT_IORING_ASYNC_CANCEL_ALL: UInt32 { 1 << 0 }
@inlinable internal static var SWIFT_IORING_ASYNC_CANCEL_FD: UInt32 { 1 << 1 }
@inlinable internal static var SWIFT_IORING_ASYNC_CANCEL_ANY: UInt32 { 1 << 2 }
@inlinable internal static var SWIFT_IORING_ASYNC_CANCEL_FD_FIXED: UInt32 { 1 << 3 }
@inlinable internal static var SWIFT_IORING_ASYNC_CANCEL_USERDATA: UInt32 { 1 << 4 }
@inlinable internal static var SWIFT_IORING_ASYNC_CANCEL_OP: UInt32 { 1 << 5 }
public enum CancellationMatch {
case all
case first
}
@inlinable public static func cancel(
_ matchAll: CancellationMatch,
matchingContext: UInt64
) -> IORing.Request {
switch matchAll {
case .all:
.init(core: .cancelContext(flags: SWIFT_IORING_ASYNC_CANCEL_ALL | SWIFT_IORING_ASYNC_CANCEL_USERDATA, targetContext: matchingContext))
case .first:
.init(core: .cancelContext(flags: SWIFT_IORING_ASYNC_CANCEL_USERDATA, targetContext: matchingContext))
}
}
@inlinable public static func cancel(
_ matchAll: CancellationMatch,
matching: FileDescriptor
) -> IORing.Request {
switch matchAll {
case .all:
.init(core: .cancelFD(flags: SWIFT_IORING_ASYNC_CANCEL_ALL | SWIFT_IORING_ASYNC_CANCEL_FD, targetFD: matching))
case .first:
.init(core: .cancelFD(flags: SWIFT_IORING_ASYNC_CANCEL_FD, targetFD: matching))
}
}
@inlinable public static func cancel(
_ matchAll: CancellationMatch,
matching: IORing.RegisteredFile
) -> IORing.Request {
switch matchAll {
case .all:
.init(core: .cancelFDSlot(flags: SWIFT_IORING_ASYNC_CANCEL_ALL | SWIFT_IORING_ASYNC_CANCEL_FD_FIXED, target: matching))
case .first:
.init(core: .cancelFDSlot(flags: SWIFT_IORING_ASYNC_CANCEL_FD_FIXED, target: matching))
}
}
@inlinable public static func cancel(
_ matchAll: CancellationMatch,
) -> IORing.Request {
switch matchAll {
case .all:
.init(core: .cancel(flags: SWIFT_IORING_ASYNC_CANCEL_ALL))
case .first:
.init(core: .cancel(flags: SWIFT_IORING_ASYNC_CANCEL_ANY))
}
}
@inline(__always) @inlinable
internal consuming func makeRawRequest() -> RawIORequest {
var request = RawIORequest()
switch extractCore() {
case .nop:
request.operation = .nop
case .openatSlot(
let atDirectory, let path, let mode, let options, let permissions, let fileSlot,
let context):
// TODO: use rawValue less
request.operation = .openAt
request.fileDescriptor = atDirectory
request.rawValue.addr = UInt64(
UInt(
bitPattern: path.withPlatformString { ptr in
ptr //this is unsavory, but we keep it alive by storing path alongside it in the request
}))
request.rawValue.open_flags = UInt32(bitPattern: options.rawValue | mode.rawValue)
request.rawValue.len = permissions?.rawValue ?? 0
request.rawValue.file_index = UInt32(fileSlot.index + 1)
request.path = path
request.rawValue.user_data = context
case .openat(
let atDirectory, let path, let mode, let options, let permissions, let context):
request.operation = .openAt
request.fileDescriptor = atDirectory
request.rawValue.addr = UInt64(
UInt(
bitPattern: path.withPlatformString { ptr in
ptr //this is unsavory, but we keep it alive by storing path alongside it in the request
}))
request.rawValue.open_flags = UInt32(bitPattern: options.rawValue | mode.rawValue)
request.rawValue.len = permissions?.rawValue ?? 0
request.path = path
request.rawValue.user_data = context
case .write(let file, let buffer, let offset, let context):
request.operation = .writeFixed
return makeRawRequest_readWrite_registered(
file: file, buffer: buffer, offset: offset, context: context, request: request)
case .writeSlot(let file, let buffer, let offset, let context):
request.operation = .writeFixed
return makeRawRequest_readWrite_registered_slot(
file: file, buffer: buffer, offset: offset, context: context, request: request)
case .writeUnregistered(let file, let buffer, let offset, let context):
request.operation = .write
return makeRawRequest_readWrite_unregistered(
file: file, buffer: buffer, offset: offset, context: context, request: request)
case .writeUnregisteredSlot(let file, let buffer, let offset, let context):
request.operation = .write
return makeRawRequest_readWrite_unregistered_slot(
file: file, buffer: buffer, offset: offset, context: context, request: request)
case .read(let file, let buffer, let offset, let context):
request.operation = .readFixed
return makeRawRequest_readWrite_registered(
file: file, buffer: buffer, offset: offset, context: context, request: request)
case .readSlot(let file, let buffer, let offset, let context):
request.operation = .readFixed
return makeRawRequest_readWrite_registered_slot(
file: file, buffer: buffer, offset: offset, context: context, request: request)
case .readUnregistered(let file, let buffer, let offset, let context):
request.operation = .read
return makeRawRequest_readWrite_unregistered(
file: file, buffer: buffer, offset: offset, context: context, request: request)
case .readUnregisteredSlot(let file, let buffer, let offset, let context):
request.operation = .read
return makeRawRequest_readWrite_unregistered_slot(
file: file, buffer: buffer, offset: offset, context: context, request: request)
case .close(let file, let context):
request.operation = .close
request.fileDescriptor = file
request.rawValue.user_data = context
case .closeSlot(let file, let context):
request.operation = .close
request.rawValue.file_index = UInt32(file.index + 1)
request.rawValue.user_data = context
case .unlinkAt(let atDirectory, let path, let context):
request.operation = .unlinkAt
request.fileDescriptor = atDirectory
request.rawValue.addr = UInt64(
UInt(
bitPattern: path.withPlatformString { ptr in
ptr //this is unsavory, but we keep it alive by storing path alongside it in the request
})
)
request.path = path
request.rawValue.user_data = context
case .cancelContext(let flags, let targetContext):
request.operation = .asyncCancel
request.cancel_flags = flags
request.addr = targetContext
case .cancelFD(let flags, let targetFD):
request.operation = .asyncCancel
request.cancel_flags = flags
request.fileDescriptor = targetFD
case .cancelFDSlot(let flags, let target):
request.operation = .asyncCancel
request.cancel_flags = flags
request.rawValue.fd = Int32(target.index)
case .cancel(let flags):
request.operation = .asyncCancel
request.cancel_flags = flags
}
return request
}
}
#endif // os(Linux)
#endif // compiler(>=6.2) && $Lifetimes
+904
View File
@@ -0,0 +1,904 @@
#if compiler(>=6.2) && $Lifetimes
#if os(Linux)
import CSystem
// needed for mmap
#if canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import Musl
#endif
import Synchronization
private var ioringSupported: Bool {
__SWIFT_IORING_SUPPORTED != 0
}
//This was #defines in older headers, so we redeclare it to get a consistent import
internal enum RegistrationOps: UInt32 {
case registerBuffers = 0
case unregisterBuffers = 1
case registerFiles = 2
case unregisterFiles = 3
case registerEventFD = 4
case unregisterEventFD = 5
case registerFilesUpdate = 6
case registerEventFDAsync = 7
case registerProbe = 8
case registerPersonality = 9
case unregisterPersonality = 10
}
extension UnsafeMutableRawPointer {
func advanced(by offset: UInt32) -> UnsafeMutableRawPointer {
return advanced(by: Int(offset))
}
}
extension UnsafeMutableRawBufferPointer {
func to_iovec() -> iovec {
iovec(iov_base: baseAddress, iov_len: count)
}
}
// all pointers in this struct reference kernel-visible memory
@usableFromInline struct SQRing: ~Copyable {
@usableFromInline let kernelHead: UnsafePointer<Atomic<UInt32>>
@usableFromInline let kernelTail: UnsafePointer<Atomic<UInt32>>
@usableFromInline var userTail: UInt32
// from liburing: the kernel should never change these
// might change in the future with resizable rings?
@usableFromInline let ringMask: UInt32
// let ringEntries: UInt32 - absorbed into array.count
// ring flags bitfield
// currently used by the kernel only in SQPOLL mode to indicate
// when the polling thread needs to be woken up
@usableFromInline let flags: UnsafePointer<Atomic<UInt32>>
// ring array
// maps indexes between the actual ring and the submissionQueueEntries list,
// allowing the latter to be used as a kind of freelist with enough work?
// currently, just 1:1 mapping (0..<n)
@usableFromInline let array: UnsafeMutableBufferPointer<UInt32>
}
@usableFromInline struct CQRing: ~Copyable {
@usableFromInline let kernelHead: UnsafePointer<Atomic<UInt32>>
@usableFromInline let kernelTail: UnsafePointer<Atomic<UInt32>>
@usableFromInline let ringMask: UInt32
@usableFromInline let cqes: UnsafeBufferPointer<io_uring_cqe>
}
@inline(__always) @inlinable
internal func _tryWriteRequest(
_ request: __owned RawIORequest, ring: inout SQRing,
submissionQueueEntries: UnsafeMutableBufferPointer<swift_io_uring_sqe>
)
-> Bool
{
if let entry = _getSubmissionEntry(
ring: &ring, submissionQueueEntries: submissionQueueEntries) {
entry.pointee = request.rawValue
return true
}
return false
}
//TODO: omitting signal mask for now
//Tell the kernel that we've submitted requests and/or are waiting for completions
@inlinable
internal func _enter(
ring: borrowing SQRing,
ringDescriptor: Int32,
numEvents: UInt32,
minCompletions: UInt32,
flags: UInt32
) throws(Errno) -> Int32 {
// Ring always needs enter right now;
// TODO: support SQPOLL here
while true {
let ret = io_uring_enter(ringDescriptor, numEvents, minCompletions, flags, nil)
// error handling:
// EAGAIN / EINTR (try again),
// EBADF / EBADFD / EOPNOTSUPP / ENXIO
// (failure in ring lifetime management, fatal),
// EINVAL (bad constant flag?, fatal),
// EFAULT (bad address for argument from library, fatal)
if ret == -EAGAIN || ret == -EINTR {
//TODO: should we wait a bit on AGAIN?
continue
} else if ret < 0 {
throw(Errno(rawValue: -ret))
} else if _getSubmissionQueueCount(ring: ring) > 0 {
// See https://github.com/axboe/liburing/issues/309, in some cases not all pending requests are submitted
continue
} else {
return ret
}
}
}
@inlinable
internal func _submitRequests(ring: borrowing SQRing, ringDescriptor: Int32) throws(Errno) {
let flushedEvents = _flushQueue(ring: ring)
_ = try _enter(
ring: ring, ringDescriptor: ringDescriptor, numEvents: flushedEvents, minCompletions: 0, flags: 0)
}
@inlinable
internal func _getSubmissionQueueCount(ring: borrowing SQRing) -> UInt32 {
return ring.userTail - ring.kernelHead.pointee.load(ordering: .acquiring)
}
@inlinable
internal func _getRemainingSubmissionQueueCapacity(ring: borrowing SQRing) -> UInt32 {
return UInt32(truncatingIfNeeded: ring.array.count) - _getSubmissionQueueCount(ring: ring)
}
@inlinable
internal func _getUnconsumedCompletionCount(ring: borrowing CQRing) -> UInt32 {
return ring.kernelTail.pointee.load(ordering: .acquiring)
- ring.kernelHead.pointee.load(ordering: .acquiring)
}
@inlinable
internal func _flushQueue(ring: borrowing SQRing) -> UInt32 {
ring.kernelTail.pointee.store(
ring.userTail, ordering: .releasing
)
return _getSubmissionQueueCount(ring: ring)
}
@inlinable
internal func _getSubmissionEntry(
ring: inout SQRing, submissionQueueEntries: UnsafeMutableBufferPointer<swift_io_uring_sqe>
) -> UnsafeMutablePointer<
swift_io_uring_sqe
>? {
let next = ring.userTail &+ 1 //this is expected to wrap
let kernelHead: UInt32 = ring.kernelHead.pointee.load(ordering: .acquiring)
// FEAT: 128-bit event support (not in MVP)
if next - kernelHead <= ring.array.count {
// let sqe = &sq->sqes[(sq->sqe_tail & sq->ring_mask) << shift];
let sqeIndex = Int(
ring.userTail & ring.ringMask
)
let sqe = submissionQueueEntries
.baseAddress.unsafelyUnwrapped
.advanced(by: sqeIndex)
ring.userTail = next
return sqe
}
return nil
}
private func setUpRing(
queueDepth: UInt32, flags: IORing.SetupFlags
) throws(Errno) ->
(params: io_uring_params, ringDescriptor: Int32, ringPtr: UnsafeMutableRawPointer?, ringSize: Int, submissionRingPtr: UnsafeMutableRawPointer?, submissionRingSize: Int, completionRingPtr: UnsafeMutableRawPointer?, completionRingSize: Int, sqes: UnsafeMutableRawPointer) {
var params = io_uring_params()
params.flags = flags.rawValue
var err: Errno? = nil
let ringDescriptor = withUnsafeMutablePointer(to: &params) {
let result = io_uring_setup(queueDepth, $0)
if result < 0 {
err = Errno.current
}
return result
}
if let err {
throw err
}
if params.features & IORing.Features.nonDroppingCompletions.rawValue == 0
{
close(ringDescriptor)
throw Errno.invalidArgument
}
let submitRingSize =
params.sq_off.array
+ params.sq_entries * UInt32(MemoryLayout<UInt32>.size)
let completionRingSize =
params.cq_off.cqes
+ params.cq_entries * UInt32(MemoryLayout<io_uring_cqe>.size)
let ringSize = Int(max(submitRingSize, completionRingSize))
var ringPtr: UnsafeMutableRawPointer!
var sqPtr: UnsafeMutableRawPointer!
var cqPtr: UnsafeMutableRawPointer!
if params.features & IORING_FEAT_SINGLE_MMAP != 0{
ringPtr = mmap(
/* addr: */ nil,
/* len: */ ringSize,
/* prot: */ PROT_READ | PROT_WRITE,
/* flags: */ MAP_SHARED | MAP_POPULATE,
/* fd: */ ringDescriptor,
/* offset: */ off_t(IORING_OFF_SQ_RING)
)
if ringPtr == MAP_FAILED {
let errno = Errno.current
close(ringDescriptor)
throw errno
}
} else {
sqPtr = mmap(
/* addr: */ nil,
/* len: */ Int(submitRingSize),
/* prot: */ PROT_READ | PROT_WRITE,
/* flags: */ MAP_SHARED | MAP_POPULATE,
/* fd: */ ringDescriptor,
/* offset: */ off_t(IORING_OFF_SQ_RING)
)
if sqPtr == MAP_FAILED {
let errno = Errno.current
close(ringDescriptor)
throw errno
}
cqPtr = mmap(
/* addr: */ nil,
/* len: */ Int(completionRingSize),
/* prot: */ PROT_READ | PROT_WRITE,
/* flags: */ MAP_SHARED | MAP_POPULATE,
/* fd: */ ringDescriptor,
/* offset: */ off_t(IORING_OFF_CQ_RING)
)
if cqPtr == MAP_FAILED {
let errno: Errno = Errno.current
close(ringDescriptor)
throw errno
}
}
// map the submission queue
let sqes = mmap(
/* addr: */ nil,
/* len: */ Int(params.sq_entries) * MemoryLayout<swift_io_uring_sqe>.size,
/* prot: */ PROT_READ | PROT_WRITE,
/* flags: */ MAP_SHARED | MAP_POPULATE,
/* fd: */ ringDescriptor,
/* offset: */ off_t(IORING_OFF_SQES)
)
if sqes == MAP_FAILED {
let errno = Errno.current
if ringPtr != nil {
munmap(ringPtr, ringSize)
} else {
if sqPtr != nil {
munmap(sqPtr, Int(submitRingSize))
}
if cqPtr != nil {
munmap(cqPtr, Int(completionRingSize))
}
}
close(ringDescriptor)
throw errno
}
return (params: params, ringDescriptor: ringDescriptor, ringPtr: ringPtr, ringSize: ringSize, submissionRingPtr: sqPtr, submissionRingSize: Int(submitRingSize), completionRingPtr: cqPtr, completionRingSize: Int(completionRingSize), sqes: sqes!)
}
///IORing provides facilities for
/// * Registering and unregistering resources (files and buffers), an `io_uring` specific variation on Unix file IOdescriptors that improves their efficiency
/// * Registering and unregistering eventfds, which allow asynchronous waiting for completions
/// * Enqueueing IO requests
/// * Dequeueing IO completions
public struct IORing: ~Copyable {
let ringFlags: UInt32
@usableFromInline let ringDescriptor: Int32
@usableFromInline var submissionRing: SQRing
// FEAT: set this eventually
let submissionPolling: Bool = false
@usableFromInline let completionRing: CQRing
@usableFromInline let submissionQueueEntries: UnsafeMutableBufferPointer<swift_io_uring_sqe>
// kept around for unmap / cleanup. TODO: we can save a few words of memory by figuring out how to handle cleanup for non-IORING_FEAT_SINGLE_MMAP better
let ringSize: Int
let ringPtr: UnsafeMutableRawPointer?
let submissionRingSize: Int
let submissionRingPtr: UnsafeMutableRawPointer?
let completionRingSize: Int
let completionRingPtr: UnsafeMutableRawPointer?
@usableFromInline var _registeredFiles: [UInt32]
@usableFromInline var _registeredBuffers: [iovec]
var features = Features(rawValue: 0)
/// RegisteredResource is used via its typealiases, RegisteredFile and RegisteredBuffer. Registering file descriptors and buffers with the IORing allows for more efficient access to them.
public struct RegisteredResource<T> {
public typealias Resource = T
@usableFromInline let resource: T
public let index: Int
@inlinable internal init(
resource: T,
index: Int
) {
self.resource = resource
self.index = index
}
}
public typealias RegisteredFile = RegisteredResource<UInt32>
public typealias RegisteredBuffer = RegisteredResource<iovec>
/// SetupFlags represents configuration options to an IORing as it's being created
public struct SetupFlags: OptionSet, RawRepresentable, Hashable {
public var rawValue: UInt32
@inlinable public init(rawValue: UInt32) {
self.rawValue = rawValue
}
@inlinable public static var pollCompletions: SetupFlags { .init(rawValue: UInt32(1) << 0) } //IORING_SETUP_IOPOLL
@inlinable public static var pollSubmissions: SetupFlags { .init(rawValue: UInt32(1) << 1) } //IORING_SETUP_SQPOLL
//TODO: figure out how to expose IORING_SETUP_SQ_AFF, IORING_SETUP_CQSIZE, IORING_SETUP_ATTACH_WQ
@inlinable public static var clampMaxEntries: SetupFlags { .init(rawValue: UInt32(1) << 4) } //IORING_SETUP_CLAMP
@inlinable public static var startDisabled: SetupFlags { .init(rawValue: UInt32(1) << 6) } //IORING_SETUP_R_DISABLED
@inlinable public static var continueSubmittingOnError: SetupFlags { .init(rawValue: UInt32(1) << 7) } //IORING_SETUP_SUBMIT_ALL
//TODO: do we want to expose IORING_SETUP_COOP_TASKRUN and IORING_SETUP_TASKRUN_FLAG?
//public static var runTasksCooperatively: SetupFlags { .init(rawValue: UInt32(1) << 8) } //IORING_SETUP_COOP_TASKRUN
//TODO: can we even do different size sqe/cqe? It requires a kernel feature, but how do we convince swift to let the types be different sizes?
//internal static var use128ByteSQEs: SetupFlags { .init(rawValue: UInt32(1) << 10) } //IORING_SETUP_SQE128
//internal static var use32ByteCQEs: SetupFlags { .init(rawValue: UInt32(1) << 11) } //IORING_SETUP_CQE32
@inlinable public static var singleSubmissionThread: SetupFlags { .init(rawValue: UInt32(1) << 12) } //IORING_SETUP_SINGLE_ISSUER
@inlinable public static var deferRunningTasks: SetupFlags { .init(rawValue: UInt32(1) << 13) } //IORING_SETUP_DEFER_TASKRUN
//pretty sure we don't want to expose IORING_SETUP_NO_MMAP or IORING_SETUP_REGISTERED_FD_ONLY currently
//TODO: should IORING_SETUP_NO_SQARRAY be the default? do we need to adapt anything to it?
}
/// Initializes an IORing with enough space for `queueDepth` prepared requests and completed operations
public init(queueDepth: UInt32, flags: SetupFlags = []) throws(Errno) {
guard ioringSupported else {
throw Errno.notSupported
}
let (params, tmpRingDescriptor, tmpRingPtr, tmpRingSize, tmpSQPtr, tmpSQSize, tmpCQPtr, tmpCQSize, sqes) = try setUpRing(queueDepth: queueDepth, flags: flags)
// All throws need to be before initializing ivars here to avoid
// "error: conditional initialization or destruction of noncopyable types is not supported;
// this variable must be consistently in an initialized or uninitialized state through every code path"
// Pre-compute values to avoid accessing partially initialized state
let ringBasePtr = tmpRingPtr ?? tmpSQPtr!
let completionBasePtr = tmpRingPtr ?? tmpCQPtr!
let submissionRing = SQRing(
kernelHead: UnsafePointer<Atomic<UInt32>>(
ringBasePtr.advanced(by: params.sq_off.head)
.assumingMemoryBound(to: Atomic<UInt32>.self)
),
kernelTail: UnsafePointer<Atomic<UInt32>>(
ringBasePtr.advanced(by: params.sq_off.tail)
.assumingMemoryBound(to: Atomic<UInt32>.self)
),
userTail: 0, // no requests yet
ringMask: ringBasePtr.advanced(by: params.sq_off.ring_mask)
.assumingMemoryBound(to: UInt32.self).pointee,
flags: UnsafePointer<Atomic<UInt32>>(
ringBasePtr.advanced(by: params.sq_off.flags)
.assumingMemoryBound(to: Atomic<UInt32>.self)
),
array: UnsafeMutableBufferPointer(
start: ringBasePtr.advanced(by: params.sq_off.array)
.assumingMemoryBound(to: UInt32.self),
count: Int(
ringBasePtr.advanced(by: params.sq_off.ring_entries)
.assumingMemoryBound(to: UInt32.self).pointee)
)
)
let completionRing = CQRing(
kernelHead: UnsafePointer<Atomic<UInt32>>(
completionBasePtr.advanced(by: params.cq_off.head)
.assumingMemoryBound(to: Atomic<UInt32>.self)
),
kernelTail: UnsafePointer<Atomic<UInt32>>(
completionBasePtr.advanced(by: params.cq_off.tail)
.assumingMemoryBound(to: Atomic<UInt32>.self)
),
ringMask: completionBasePtr.advanced(by: params.cq_off.ring_mask)
.assumingMemoryBound(to: UInt32.self).pointee,
cqes: UnsafeBufferPointer(
start: completionBasePtr.advanced(by: params.cq_off.cqes)
.assumingMemoryBound(to: io_uring_cqe.self),
count: Int(
completionBasePtr.advanced(by: params.cq_off.ring_entries)
.assumingMemoryBound(to: UInt32.self).pointee)
)
)
let submissionQueueEntries = UnsafeMutableBufferPointer(
start: sqes.assumingMemoryBound(to: swift_io_uring_sqe.self),
count: Int(params.sq_entries)
)
// Now initialize all stored properties
self.features = Features(rawValue: params.features)
self.ringDescriptor = tmpRingDescriptor
self.ringPtr = tmpRingPtr
self.ringSize = tmpRingSize
self.submissionRingPtr = tmpSQPtr
self.submissionRingSize = tmpSQSize
self.completionRingPtr = tmpCQPtr
self.completionRingSize = tmpCQSize
self._registeredFiles = []
self._registeredBuffers = []
self.submissionRing = submissionRing
self.completionRing = completionRing
self.submissionQueueEntries = submissionQueueEntries
self.ringFlags = params.flags
// fill submission ring array with 1:1 map to underlying SQEs
// (happens after all properties are initialized)
for i in 0 ..< self.submissionRing.array.count {
self.submissionRing.array[i] = UInt32(i)
}
}
@inlinable
internal func _blockingConsumeCompletionGuts<Err: Error>(
minimumCount: UInt32,
maximumCount: UInt32,
extraArgs: UnsafeMutablePointer<swift_io_uring_getevents_arg>? = nil,
consumer: (consuming IORing.Completion?, Errno?, Bool) throws(Err) -> Void
) throws(Err) {
var count = 0
while let completion = _tryConsumeCompletion(ring: completionRing) {
count += 1
if completion.result < 0 {
try consumer(nil, Errno(rawValue: -completion.result), false)
} else {
try consumer(completion, nil, false)
}
if count == maximumCount {
try consumer(nil, nil, true)
return
}
}
if count < minimumCount {
while count < minimumCount {
var sz = 0
if extraArgs != nil {
sz = MemoryLayout<swift_io_uring_getevents_arg>.size
}
let res = io_uring_enter2(
ringDescriptor,
0,
minimumCount,
IORING_ENTER_GETEVENTS,
extraArgs,
sz
)
// error handling:
// EAGAIN / EINTR (try again),
// EBADF / EBADFD / EOPNOTSUPP / ENXIO
// (failure in ring lifetime management, fatal),
// EINVAL (bad constant flag?, fatal),
// EFAULT (bad address for argument from library, fatal)
// EBUSY (not enough space for events; implies events filled
// by kernel between kernelTail load and now)
if res >= 0 || res == -EBUSY {
break
} else if res == -EAGAIN || res == -EINTR {
continue
}
fatalError(
"fatal error in receiving requests: "
+ Errno(rawValue: -res).debugDescription
)
}
var count = 0
while let completion = _tryConsumeCompletion(ring: completionRing) {
count += 1
if completion.result < 0 {
try consumer(nil, Errno(rawValue: -completion.result), false)
} else {
try consumer(completion, nil, false)
}
if count == maximumCount {
break
}
}
try consumer(nil, nil, true)
}
}
@inlinable
internal func _blockingConsumeOneCompletion(
extraArgs: UnsafeMutablePointer<swift_io_uring_getevents_arg>? = nil
) throws(Errno) -> Completion {
var result: Completion? = nil
try _blockingConsumeCompletionGuts(minimumCount: 1, maximumCount: 1, extraArgs: extraArgs) {
(completion: consuming Completion?, error, done) throws(Errno) in
if let error {
throw error
}
if let completion {
result = consume completion
}
}
return result.take()!
}
/// Synchronously waits for an operation to complete for up to `timeout` (or forever if not specified)
@inlinable
public func blockingConsumeCompletion(
timeout: Duration? = nil
) throws(Errno) -> Completion {
if let timeout {
var ts = timespec(
tv_sec: Int(timeout.components.seconds),
tv_nsec: Int(timeout.components.attoseconds / 1_000_000_000)
)
return try withUnsafePointer(to: &ts) { (tsPtr) throws(Errno) -> Completion in
var args = swift_io_uring_getevents_arg(
sigmask: 0,
sigmask_sz: 0,
min_wait_usec: 0,
ts: UInt64(UInt(bitPattern: tsPtr))
)
return try _blockingConsumeOneCompletion(extraArgs: &args)
}
} else {
return try _blockingConsumeOneCompletion()
}
}
/// Synchronously waits for `minimumCount` or more operations to complete for up to `timeout` (or forever if not specified). For each completed operation found, `consumer` is called to handle processing it
@inlinable
public func blockingConsumeCompletions<Err: Error>(
minimumCount: UInt32 = 1,
timeout: Duration? = nil,
consumer: (consuming Completion?, Errno?, Bool) throws(Err) -> Void
) throws(Err) {
if let timeout {
var ts = timespec(
tv_sec: Int(timeout.components.seconds),
tv_nsec: Int(timeout.components.attoseconds / 1_000_000_000)
)
try withUnsafePointer(to: &ts) { (tsPtr) throws(Err) in
var args = swift_io_uring_getevents_arg(
sigmask: 0,
sigmask_sz: 0,
min_wait_usec: 0,
ts: UInt64(UInt(bitPattern: tsPtr))
)
try _blockingConsumeCompletionGuts(
minimumCount: minimumCount, maximumCount: UInt32.max, extraArgs: &args,
consumer: consumer)
}
} else {
try _blockingConsumeCompletionGuts(
minimumCount: minimumCount, maximumCount: UInt32.max, consumer: consumer)
}
}
// public func peekNextCompletion() -> IOCompletion {
// }
/// Takes a completed operation from the ring and returns it, if one is ready. Otherwise, returns nil.
@inlinable
public func tryConsumeCompletion() -> Completion? {
return _tryConsumeCompletion(ring: completionRing)
}
@inlinable
func _tryConsumeCompletion(ring: borrowing CQRing) -> Completion? {
let tail = ring.kernelTail.pointee.load(ordering: .acquiring)
let head = ring.kernelHead.pointee.load(ordering: .acquiring)
if tail != head {
// 32 byte copy - oh well
let res = ring.cqes[Int(head & ring.ringMask)]
ring.kernelHead.pointee.store(head &+ 1, ordering: .releasing)
return Completion(rawValue: res)
}
return nil
}
/// Registers an event monitoring file descriptor with the ring. The file descriptor becomes readable whenever completions are ready to be dequeued. See `man eventfd(2)` for additional information.
public mutating func registerEventFD(_ descriptor: FileDescriptor) throws(Errno) {
var rawfd = descriptor.rawValue
let result = withUnsafePointer(to: &rawfd) { fdptr in
let result = io_uring_register(
ringDescriptor,
RegistrationOps.registerEventFD.rawValue,
UnsafeMutableRawPointer(mutating: fdptr),
1
)
return result >= 0 ? nil : Errno(rawValue: -result)
}
if let result {
throw result
}
}
/// Removes a registered event file descriptor from the ring
public mutating func unregisterEventFD() throws(Errno) {
let result = io_uring_register(
ringDescriptor,
RegistrationOps.unregisterEventFD.rawValue,
nil,
0
)
if result < 0 {
throw Errno(rawValue: -result)
}
}
/// Registers `count` files with the ring for later use in IO operations
public mutating func registerFileSlots(count: Int) throws(Errno) -> RegisteredResources<RegisteredFile.Resource> {
precondition(_registeredFiles.isEmpty)
precondition(count < UInt32.max)
let files = [UInt32](repeating: UInt32.max, count: count)
let regResult = files.withUnsafeBufferPointer { bPtr in
let result = io_uring_register(
self.ringDescriptor,
RegistrationOps.registerFiles.rawValue,
UnsafeMutableRawPointer(mutating: bPtr.baseAddress!),
UInt32(truncatingIfNeeded: count)
)
return result >= 0 ? nil : Errno(rawValue: -result)
}
if let regResult {
throw regResult
}
_registeredFiles = files
return registeredFileSlots
}
/// Removes registered files from the ring
public func unregisterFiles() throws {
let result = io_uring_register(
ringDescriptor,
RegistrationOps.unregisterFiles.rawValue,
nil,
0
)
if result < 0 {
throw Errno(rawValue: -result)
}
}
/// Allows access to registered files by index
@inlinable
public var registeredFileSlots: RegisteredResources<RegisteredFile.Resource> {
RegisteredResources(resources: _registeredFiles)
}
/// Registers buffers with the ring for later use in IO operations
public mutating func registerBuffers(_ buffers: some Collection<UnsafeMutableRawBufferPointer>) throws(Errno)
-> RegisteredResources<RegisteredBuffer.Resource>
{
precondition(buffers.count < UInt32.max)
precondition(_registeredBuffers.isEmpty)
let iovecs = buffers.map { $0.to_iovec() }
let regResult = iovecs.withUnsafeBufferPointer { bPtr in
let result = io_uring_register(
self.ringDescriptor,
RegistrationOps.registerBuffers.rawValue,
UnsafeMutableRawPointer(mutating: bPtr.baseAddress!),
UInt32(truncatingIfNeeded: buffers.count)
)
return result >= 0 ? nil : Errno(rawValue: -result)
}
if let regResult {
throw regResult
}
_registeredBuffers = iovecs
return registeredBuffers
}
/// Registers buffers with the ring for later use in IO operations
@inlinable
public mutating func registerBuffers(_ buffers: UnsafeMutableRawBufferPointer...) throws(Errno)
-> RegisteredResources<RegisteredBuffer.Resource>
{
try registerBuffers(buffers)
}
/// A view of the registered files or buffers in a ring
public struct RegisteredResources<T>: RandomAccessCollection {
@usableFromInline let resources: [T]
@inlinable public var startIndex: Int { 0 }
@inlinable public var endIndex: Int { resources.endIndex }
@inlinable init(resources: [T]) {
self.resources = resources
}
@inlinable public subscript(position: Int) -> RegisteredResource<T> {
RegisteredResource(resource: resources[position], index: position)
}
@inlinable public subscript(position: UInt16) -> RegisteredResource<T> {
RegisteredResource(resource: resources[Int(position)], index: Int(position))
}
}
/// Allows access to registered files by index
@inlinable
public var registeredBuffers: RegisteredResources<RegisteredBuffer.Resource> {
RegisteredResources(resources: _registeredBuffers)
}
public func unregisterBuffers() throws {
let result = io_uring_register(
self.ringDescriptor,
RegistrationOps.unregisterBuffers.rawValue,
nil,
0
)
guard result >= 0 else {
throw Errno(rawValue: -result)
}
}
/// Sends all prepared requests to the kernel for processing. Results will be delivered as completions, which can be dequeued from the ring.
@inlinable
public func submitPreparedRequests() throws(Errno) {
try _submitRequests(ring: submissionRing, ringDescriptor: ringDescriptor)
}
/// Sends all prepared requests to the kernel for processing, and then dequeues at least `minimumCount` completions, waiting up to `timeout` for them to become available. `consumer` is called to process each completed IO operation as it becomes available.
@inlinable
public func submitPreparedRequestsAndConsumeCompletions<Err: Error>(
minimumCount: UInt32 = 1,
timeout: Duration? = nil,
consumer: (consuming Completion?, Errno?, Bool) throws(Err) -> Void
) throws(Err) {
//TODO: optimize this to one uring_enter
do {
try submitPreparedRequests()
} catch (let e) {
try consumer(nil, e, true)
}
try blockingConsumeCompletions(
minimumCount: minimumCount,
timeout: timeout,
consumer: consumer
)
}
/// Attempts to prepare an IO request for submission to the kernel. Returns false if no space is available to enqueue the request
@inlinable
public mutating func prepare(request: __owned Request) -> Bool {
var raw: RawIORequest? = request.makeRawRequest()
return _tryWriteRequest(
raw.take()!, ring: &submissionRing, submissionQueueEntries: submissionQueueEntries)
}
/// Attempts to prepare a chain of linked IO requests for submission to the kernel. Returns false if not enough space is available to enqueue the request. If any linked operation fails, subsequent operations will be canceled. Linked operations always execute in order.
@inlinable
mutating func prepare(linkedRequests: some BidirectionalCollection<Request>) -> Bool {
guard linkedRequests.count > 0 else {
return true
}
let freeSQECount = _getRemainingSubmissionQueueCapacity(ring: submissionRing)
guard freeSQECount >= linkedRequests.count else {
return false
}
let last = linkedRequests.last!
for req in linkedRequests.dropLast() {
var raw = req.makeRawRequest()
raw.linkToNextRequest()
let successfullyAdded = _tryWriteRequest(
raw, ring: &submissionRing, submissionQueueEntries: submissionQueueEntries)
assert(successfullyAdded)
}
let successfullyAdded = _tryWriteRequest(
last.makeRawRequest(), ring: &submissionRing,
submissionQueueEntries: submissionQueueEntries)
assert(successfullyAdded)
return true
}
/// Prepares a sequence of requests for submission to the ring. Returns false if the submission queue doesn't have enough available space.
@inlinable
public mutating func prepare(linkedRequests: Request...) -> Bool {
prepare(linkedRequests: linkedRequests)
}
/// Prepares and submits a sequence of requests to the ring. Returns false if the submission queue doesn't have enough available space.
@inlinable
public mutating func submit(linkedRequests: Request...) throws(Errno) -> Bool {
if !prepare(linkedRequests: linkedRequests) {
return false
}
try submitPreparedRequests()
return true
}
/// Describes which io_uring features are supported by the kernel this program is running on
public struct Features: OptionSet, RawRepresentable, Hashable {
public let rawValue: UInt32
@inlinable public init(rawValue: UInt32) {
self.rawValue = rawValue
}
//IORING_FEAT_SINGLE_MMAP is handled internally
@inlinable public static var nonDroppingCompletions: Features { .init(rawValue: UInt32(1) << 1) } //IORING_FEAT_NODROP
@inlinable public static var stableSubmissions: Features { .init(rawValue: UInt32(1) << 2) } //IORING_FEAT_SUBMIT_STABLE
@inlinable public static var currentFilePosition: Features { .init(rawValue: UInt32(1) << 3) } //IORING_FEAT_RW_CUR_POS
@inlinable public static var assumingTaskCredentials: Features { .init(rawValue: UInt32(1) << 4) } //IORING_FEAT_CUR_PERSONALITY
@inlinable public static var fastPolling: Features { .init(rawValue: UInt32(1) << 5) } //IORING_FEAT_FAST_POLL
@inlinable public static var epoll32BitFlags: Features { .init(rawValue: UInt32(1) << 6) } //IORING_FEAT_POLL_32BITS
@inlinable public static var pollNonFixedFiles: Features { .init(rawValue: UInt32(1) << 7) } //IORING_FEAT_SQPOLL_NONFIXED
@inlinable public static var extendedArguments: Features { .init(rawValue: UInt32(1) << 8) } //IORING_FEAT_EXT_ARG
@inlinable public static var nativeWorkers: Features { .init(rawValue: UInt32(1) << 9) } //IORING_FEAT_NATIVE_WORKERS
@inlinable public static var resourceTags: Features { .init(rawValue: UInt32(1) << 10) } //IORING_FEAT_RSRC_TAGS
@inlinable public static var allowsSkippingSuccessfulCompletions: Features { .init(rawValue: UInt32(1) << 11) } //IORING_FEAT_CQE_SKIP
@inlinable public static var improvedLinkedFiles: Features { .init(rawValue: UInt32(1) << 12) } //IORING_FEAT_LINKED_FILE
@inlinable public static var registerRegisteredRings: Features { .init(rawValue: UInt32(1) << 13) } //IORING_FEAT_REG_REG_RING
@inlinable public static var minimumTimeout: Features { .init(rawValue: UInt32(1) << 15) } //IORING_FEAT_MIN_TIMEOUT
@inlinable public static var bundledSendReceive: Features { .init(rawValue: UInt32(1) << 14) } //IORING_FEAT_RECVSEND_BUNDLE
}
/// Describes which io_uring features are supported by the kernel this program is running on
public var supportedFeatures: Features {
return features
}
deinit {
if let ringPtr {
munmap(ringPtr, ringSize)
} else if let submissionRingPtr, let completionRingPtr {
munmap(submissionRingPtr, submissionRingSize)
munmap(completionRingPtr, completionRingSize)
}
munmap(
UnsafeMutableRawPointer(submissionQueueEntries.baseAddress!),
submissionQueueEntries.count * MemoryLayout<swift_io_uring_sqe>.size
)
close(ringDescriptor)
}
}
extension IORing.RegisteredBuffer {
@unsafe @inlinable public var unsafeBuffer: UnsafeMutableRawBufferPointer {
return .init(start: resource.iov_base, count: resource.iov_len)
}
@inlinable public var mutableBytes: MutableRawSpan {
@_lifetime(&self)
mutating get {
let span = MutableRawSpan(_unsafeBytes: unsafeBuffer)
return unsafe _overrideLifetime(span, mutating: &self)
}
}
@inlinable public var bytes: RawSpan {
let span = RawSpan(_unsafeBytes: UnsafeRawBufferPointer(unsafeBuffer))
return unsafe _overrideLifetime(span, borrowing: self)
}
}
#endif // os(Linux)
#endif // compiler(>=6.2) && $Lifetimes
+205
View File
@@ -0,0 +1,205 @@
#if compiler(>=6.2) && $Lifetimes
#if os(Linux)
import CSystem
@usableFromInline
internal struct RawIORequest: ~Copyable {
// swift_io_uring_sqe is a typedef of io_uring_sqe on platforms where
// IORing is supported (currently requires kernel version >= 5.15).
@usableFromInline var rawValue: swift_io_uring_sqe
@usableFromInline var path: FilePath? //buffer owner for the path pointer that the sqe may have
@inlinable public init() {
self.rawValue = swift_io_uring_sqe()
}
}
extension RawIORequest {
@usableFromInline
enum Operation: UInt8 {
case nop = 0
case readv = 1
case writev = 2
case fsync = 3
case readFixed = 4
case writeFixed = 5
case pollAdd = 6
case pollRemove = 7
case syncFileRange = 8
case sendMessage = 9
case receiveMessage = 10
// ...
case asyncCancel = 14
case link_timeout = 15
// ...
case openAt = 18
case close = 19
case filesUpdate = 20
case statx = 21
case read = 22
case write = 23
// ...
case openAt2 = 28
// ...
case unlinkAt = 36
}
public struct Flags: OptionSet, Hashable, Codable {
public let rawValue: UInt8
@inlinable public init(rawValue: UInt8) {
self.rawValue = rawValue
}
@inlinable public static var fixedFile: RawIORequest.Flags { Flags(rawValue: 1 << 0) }
@inlinable public static var drainQueue: RawIORequest.Flags { Flags(rawValue: 1 << 1) }
@inlinable public static var linkRequest: RawIORequest.Flags { Flags(rawValue: 1 << 2) }
@inlinable public static var hardlinkRequest: RawIORequest.Flags { Flags(rawValue: 1 << 3) }
@inlinable public static var asynchronous: RawIORequest.Flags { Flags(rawValue: 1 << 4) }
@inlinable public static var selectBuffer: RawIORequest.Flags { Flags(rawValue: 1 << 5) }
@inlinable public static var skipSuccess: RawIORequest.Flags { Flags(rawValue: 1 << 6) }
}
@inlinable var operation: Operation {
get { Operation(rawValue: rawValue.opcode)! }
set { rawValue.opcode = newValue.rawValue }
}
@inlinable var cancel_flags: UInt32 {
get { rawValue.cancel_flags }
set { rawValue.cancel_flags = newValue }
}
@inlinable var addr: UInt64 {
get { rawValue.addr }
set { rawValue.addr = newValue }
}
@inlinable public var flags: Flags {
get { Flags(rawValue: rawValue.flags) }
set { rawValue.flags = newValue.rawValue }
}
@inlinable public mutating func linkToNextRequest() {
flags = Flags(rawValue: flags.rawValue | Flags.linkRequest.rawValue)
}
@inlinable public var fileDescriptor: FileDescriptor {
get { FileDescriptor(rawValue: rawValue.fd) }
set { rawValue.fd = newValue.rawValue }
}
@inlinable public var offset: UInt64? {
get {
if (rawValue.off == UInt64.max) {
return nil
} else {
return rawValue.off
}
}
set {
if let val = newValue {
rawValue.off = val
} else {
rawValue.off = UInt64.max
}
}
}
@inlinable public var buffer: UnsafeMutableRawBufferPointer {
get {
let ptr = UnsafeMutableRawPointer(bitPattern: UInt(exactly: rawValue.addr)!)
return UnsafeMutableRawBufferPointer(start: ptr, count: Int(rawValue.len))
}
set {
rawValue.addr = UInt64(Int(bitPattern: newValue.baseAddress!))
rawValue.len = UInt32(exactly: newValue.count)!
}
}
public enum RequestFlags {
case readWriteFlags(ReadWriteFlags)
// case fsyncFlags(FsyncFlags?)
// poll_events
// poll32_events
// sync_range_flags
// msg_flags
case timeoutFlags(TimeOutFlags)
// accept_flags
// cancel_flags
case openFlags(FileDescriptor.OpenOptions)
// statx_flags
// fadvise_advice
// splice_flags
}
public struct ReadWriteFlags: OptionSet, Hashable, Codable {
public var rawValue: UInt32
@inlinable public init(rawValue: UInt32) {
self.rawValue = rawValue
}
@inlinable public static var highPriority: RawIORequest.ReadWriteFlags { ReadWriteFlags(rawValue: 1 << 0) }
// sync with only data integrity
@inlinable public static var dataSync: RawIORequest.ReadWriteFlags { ReadWriteFlags(rawValue: 1 << 1) }
// sync with full data + file integrity
@inlinable public static var fileSync: RawIORequest.ReadWriteFlags { ReadWriteFlags(rawValue: 1 << 2) }
// return -EAGAIN if operation blocks
@inlinable public static var noWait: RawIORequest.ReadWriteFlags { ReadWriteFlags(rawValue: 1 << 3) }
// append to end of the file
@inlinable public static var append: RawIORequest.ReadWriteFlags { ReadWriteFlags(rawValue: 1 << 4) }
}
public struct TimeOutFlags: OptionSet, Hashable, Codable {
public var rawValue: UInt32
@inlinable public init(rawValue: UInt32) {
self.rawValue = rawValue
}
@inlinable public static var relativeTime: RawIORequest.TimeOutFlags { TimeOutFlags(rawValue: 0) }
@inlinable public static var absoluteTime: RawIORequest.TimeOutFlags { TimeOutFlags(rawValue: 1 << 0) }
}
}
extension RawIORequest {
@inlinable
static func nop() -> RawIORequest {
var req: RawIORequest = RawIORequest()
req.operation = .nop
return req
}
@inlinable
static func withTimeoutRequest<R>(
linkedTo opEntry: UnsafeMutablePointer<swift_io_uring_sqe>,
in timeoutEntry: UnsafeMutablePointer<swift_io_uring_sqe>,
duration: Duration,
flags: TimeOutFlags,
work: () throws -> R) rethrows -> R {
opEntry.pointee.flags |= Flags.linkRequest.rawValue
opEntry.pointee.off = 1
var ts = timespec(
tv_sec: Int(duration.components.seconds),
tv_nsec: Int(duration.components.attoseconds / 1_000_000_000)
)
return try withUnsafePointer(to: &ts) { tsPtr in
var req: RawIORequest = RawIORequest()
req.operation = .link_timeout
req.rawValue.timeout_flags = flags.rawValue
req.rawValue.len = 1
req.rawValue.addr = UInt64(UInt(bitPattern: tsPtr))
timeoutEntry.pointee = req.rawValue
return try work()
}
}
}
#endif // os(Linux)
#endif // compiler(>=6.2) && $Lifetimes
+29
View File
@@ -0,0 +1,29 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 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
*/
extension String {
internal init(
_unsafeUninitializedCapacity capacity: Int,
initializingUTF8With body: (UnsafeMutableBufferPointer<UInt8>) throws -> Int
) rethrows {
if #available(macOS 11, iOS 14.0, watchOS 7.0, tvOS 14.0, *) {
self = try String(
unsafeUninitializedCapacity: capacity,
initializingUTF8With: body)
return
}
let array = try Array<UInt8>(
unsafeUninitializedCapacity: capacity
) { buffer, count in
count = try body(buffer)
}
self = String(decoding: array, as: UTF8.self)
}
}
+81
View File
@@ -0,0 +1,81 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 - 2024 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
*/
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif os(Windows)
import CSystem
import ucrt
#elseif canImport(Glibc)
@_implementationOnly import CSystem
import Glibc
#elseif canImport(Musl)
@_implementationOnly import CSystem
import Musl
#elseif canImport(WASILibc)
import WASILibc
#elseif canImport(Bionic)
@_implementationOnly import CSystem
import Bionic
#else
#error("Unsupported Platform")
#endif
// MARK: - Public typealiases
// FIXME: `CModeT` ought to be deprecated and replaced with `CInterop.Mode`
// if/when the compiler becomes less strict about availability checking
// of "namespaced" typealiases. (rdar://81722893)
#if os(Windows)
/// The C `mode_t` type.
public typealias CModeT = CInt
#else
/// The C `mode_t` type.
@available(System 0.0.1, *)
public typealias CModeT = mode_t
#endif
/// A namespace for C and platform types
@available(System 0.0.2, *)
public enum CInterop {
#if os(Windows)
public typealias Mode = CInt
#else
public typealias Mode = mode_t
#endif
/// The C `char` type
public typealias Char = CChar
#if os(Windows)
/// The platform's preferred character type. On Unix, this is an 8-bit C
/// `char` (which may be signed or unsigned, depending on platform). On
/// Windows, this is `UInt16` (a "wide" character).
public typealias PlatformChar = UInt16
#else
/// The platform's preferred character type. On Unix, this is an 8-bit C
/// `char` (which may be signed or unsigned, depending on platform). On
/// Windows, this is `UInt16` (a "wide" character).
public typealias PlatformChar = CInterop.Char
#endif
#if os(Windows)
/// The platform's preferred Unicode encoding. On Unix this is UTF-8 and on
/// Windows it is UTF-16. Native strings may contain invalid Unicode,
/// which will be handled by either error-correction or failing, depending
/// on API.
public typealias PlatformUnicodeEncoding = UTF16
#else
/// The platform's preferred Unicode encoding. On Unix this is UTF-8 and on
/// Windows it is UTF-16. Native strings may contain invalid Unicode,
/// which will be handled by either error-correction or failing, depending
/// on API.
public typealias PlatformUnicodeEncoding = UTF8
#endif
}
+641
View File
@@ -0,0 +1,641 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 - 2024 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
*/
// For platform constants redefined in Swift. We define them here so that
// they can be used anywhere without imports and without confusion to
// unavailable local decls.
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif os(Windows)
import CSystem
import ucrt
#elseif canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import CSystem
import Musl
#elseif canImport(WASILibc)
import CSystem
import WASILibc
#elseif canImport(Android)
import Android
#else
#error("Unsupported Platform")
#endif
// MARK: errno
#if SYSTEM_PACKAGE_DARWIN
@_alwaysEmitIntoClient
internal var _ERRNO_NOT_USED: CInt { 0 }
#endif
@_alwaysEmitIntoClient
internal var _EPERM: CInt { EPERM }
@_alwaysEmitIntoClient
internal var _ENOENT: CInt { ENOENT }
@_alwaysEmitIntoClient
internal var _ESRCH: CInt { ESRCH }
@_alwaysEmitIntoClient
internal var _EINTR: CInt { EINTR }
@_alwaysEmitIntoClient
internal var _EIO: CInt { EIO }
@_alwaysEmitIntoClient
internal var _ENXIO: CInt { ENXIO }
@_alwaysEmitIntoClient
internal var _E2BIG: CInt { E2BIG }
@_alwaysEmitIntoClient
internal var _ENOEXEC: CInt { ENOEXEC }
@_alwaysEmitIntoClient
internal var _EBADF: CInt { EBADF }
@_alwaysEmitIntoClient
internal var _ECHILD: CInt { ECHILD }
@_alwaysEmitIntoClient
internal var _EDEADLK: CInt { EDEADLK }
@_alwaysEmitIntoClient
internal var _ENOMEM: CInt { ENOMEM }
@_alwaysEmitIntoClient
internal var _EACCES: CInt { EACCES }
@_alwaysEmitIntoClient
internal var _EFAULT: CInt { EFAULT }
#if !os(Windows) && !os(WASI)
@_alwaysEmitIntoClient
internal var _ENOTBLK: CInt { ENOTBLK }
#endif
@_alwaysEmitIntoClient
internal var _EBUSY: CInt { EBUSY }
@_alwaysEmitIntoClient
internal var _EEXIST: CInt { EEXIST }
@_alwaysEmitIntoClient
internal var _EXDEV: CInt { EXDEV }
@_alwaysEmitIntoClient
internal var _ENODEV: CInt { ENODEV }
@_alwaysEmitIntoClient
internal var _ENOTDIR: CInt { ENOTDIR }
@_alwaysEmitIntoClient
internal var _EISDIR: CInt { EISDIR }
@_alwaysEmitIntoClient
internal var _EINVAL: CInt { EINVAL }
@_alwaysEmitIntoClient
internal var _ENFILE: CInt { ENFILE }
@_alwaysEmitIntoClient
internal var _EMFILE: CInt { EMFILE }
#if !os(Windows)
@_alwaysEmitIntoClient
internal var _ENOTTY: CInt { ENOTTY }
@_alwaysEmitIntoClient
internal var _ETXTBSY: CInt { ETXTBSY }
#endif
@_alwaysEmitIntoClient
internal var _EFBIG: CInt { EFBIG }
@_alwaysEmitIntoClient
internal var _ENOSPC: CInt { ENOSPC }
@_alwaysEmitIntoClient
internal var _ESPIPE: CInt { ESPIPE }
@_alwaysEmitIntoClient
internal var _EROFS: CInt { EROFS }
@_alwaysEmitIntoClient
internal var _EMLINK: CInt { EMLINK }
@_alwaysEmitIntoClient
internal var _EPIPE: CInt { EPIPE }
@_alwaysEmitIntoClient
internal var _EDOM: CInt { EDOM }
@_alwaysEmitIntoClient
internal var _ERANGE: CInt { ERANGE }
@_alwaysEmitIntoClient
internal var _EAGAIN: CInt { EAGAIN }
@_alwaysEmitIntoClient
internal var _EWOULDBLOCK: CInt {
#if os(WASI)
_getConst_EWOULDBLOCK()
#else
EWOULDBLOCK
#endif
}
@_alwaysEmitIntoClient
internal var _EINPROGRESS: CInt { EINPROGRESS }
@_alwaysEmitIntoClient
internal var _EALREADY: CInt { EALREADY }
@_alwaysEmitIntoClient
internal var _ENOTSOCK: CInt { ENOTSOCK }
@_alwaysEmitIntoClient
internal var _EDESTADDRREQ: CInt { EDESTADDRREQ }
@_alwaysEmitIntoClient
internal var _EMSGSIZE: CInt { EMSGSIZE }
@_alwaysEmitIntoClient
internal var _EPROTOTYPE: CInt { EPROTOTYPE }
@_alwaysEmitIntoClient
internal var _ENOPROTOOPT: CInt { ENOPROTOOPT }
@_alwaysEmitIntoClient
internal var _EPROTONOSUPPORT: CInt { EPROTONOSUPPORT }
#if !os(WASI)
@_alwaysEmitIntoClient
internal var _ESOCKTNOSUPPORT: CInt {
#if os(Windows)
return WSAESOCKTNOSUPPORT
#else
return ESOCKTNOSUPPORT
#endif
}
#endif
@_alwaysEmitIntoClient
internal var _ENOTSUP: CInt {
#if os(Windows)
return WSAEOPNOTSUPP
#else
return ENOTSUP
#endif
}
#if !os(WASI)
@_alwaysEmitIntoClient
internal var _EPFNOSUPPORT: CInt {
#if os(Windows)
return WSAEPFNOSUPPORT
#else
return EPFNOSUPPORT
#endif
}
#endif
@_alwaysEmitIntoClient
internal var _EAFNOSUPPORT: CInt { EAFNOSUPPORT }
@_alwaysEmitIntoClient
internal var _EADDRINUSE: CInt { EADDRINUSE }
@_alwaysEmitIntoClient
internal var _EADDRNOTAVAIL: CInt { EADDRNOTAVAIL }
@_alwaysEmitIntoClient
internal var _ENETDOWN: CInt { ENETDOWN }
@_alwaysEmitIntoClient
internal var _ENETUNREACH: CInt { ENETUNREACH }
@_alwaysEmitIntoClient
internal var _ENETRESET: CInt { ENETRESET }
@_alwaysEmitIntoClient
internal var _ECONNABORTED: CInt { ECONNABORTED }
@_alwaysEmitIntoClient
internal var _ECONNRESET: CInt { ECONNRESET }
@_alwaysEmitIntoClient
internal var _ENOBUFS: CInt { ENOBUFS }
@_alwaysEmitIntoClient
internal var _EISCONN: CInt { EISCONN }
@_alwaysEmitIntoClient
internal var _ENOTCONN: CInt { ENOTCONN }
#if !os(WASI)
@_alwaysEmitIntoClient
internal var _ESHUTDOWN: CInt {
#if os(Windows)
return WSAESHUTDOWN
#else
return ESHUTDOWN
#endif
}
@_alwaysEmitIntoClient
internal var _ETOOMANYREFS: CInt {
#if os(Windows)
return WSAETOOMANYREFS
#else
return ETOOMANYREFS
#endif
}
#endif
@_alwaysEmitIntoClient
internal var _ETIMEDOUT: CInt { ETIMEDOUT }
@_alwaysEmitIntoClient
internal var _ECONNREFUSED: CInt { ECONNREFUSED }
@_alwaysEmitIntoClient
internal var _ELOOP: CInt { ELOOP }
@_alwaysEmitIntoClient
internal var _ENAMETOOLONG: CInt { ENAMETOOLONG }
#if !os(WASI)
@_alwaysEmitIntoClient
internal var _EHOSTDOWN: CInt {
#if os(Windows)
return WSAEHOSTDOWN
#else
return EHOSTDOWN
#endif
}
#endif
@_alwaysEmitIntoClient
internal var _EHOSTUNREACH: CInt { EHOSTUNREACH }
@_alwaysEmitIntoClient
internal var _ENOTEMPTY: CInt { ENOTEMPTY }
#if SYSTEM_PACKAGE_DARWIN
@_alwaysEmitIntoClient
internal var _EPROCLIM: CInt { EPROCLIM }
#endif
#if !os(WASI)
@_alwaysEmitIntoClient
internal var _EUSERS: CInt {
#if os(Windows)
return WSAEUSERS
#else
return EUSERS
#endif
}
#endif
@_alwaysEmitIntoClient
internal var _EDQUOT: CInt {
#if os(Windows)
return WSAEDQUOT
#else
return EDQUOT
#endif
}
@_alwaysEmitIntoClient
internal var _ESTALE: CInt {
#if os(Windows)
return WSAESTALE
#else
return ESTALE
#endif
}
#if !os(WASI)
@_alwaysEmitIntoClient
internal var _EREMOTE: CInt {
#if os(Windows)
return WSAEREMOTE
#else
return EREMOTE
#endif
}
#endif
#if SYSTEM_PACKAGE_DARWIN
@_alwaysEmitIntoClient
internal var _EBADRPC: CInt { EBADRPC }
@_alwaysEmitIntoClient
internal var _ERPCMISMATCH: CInt { ERPCMISMATCH }
@_alwaysEmitIntoClient
internal var _EPROGUNAVAIL: CInt { EPROGUNAVAIL }
@_alwaysEmitIntoClient
internal var _EPROGMISMATCH: CInt { EPROGMISMATCH }
@_alwaysEmitIntoClient
internal var _EPROCUNAVAIL: CInt { EPROCUNAVAIL }
#endif
@_alwaysEmitIntoClient
internal var _ENOLCK: CInt { ENOLCK }
@_alwaysEmitIntoClient
internal var _ENOSYS: CInt { ENOSYS }
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
@_alwaysEmitIntoClient
internal var _EFTYPE: CInt { EFTYPE }
@_alwaysEmitIntoClient
internal var _EAUTH: CInt { EAUTH }
@_alwaysEmitIntoClient
internal var _ENEEDAUTH: CInt { ENEEDAUTH }
#endif
#if SYSTEM_PACKAGE_DARWIN
@_alwaysEmitIntoClient
internal var _EPWROFF: CInt { EPWROFF }
@_alwaysEmitIntoClient
internal var _EDEVERR: CInt { EDEVERR }
#endif
#if !os(Windows)
@_alwaysEmitIntoClient
internal var _EOVERFLOW: CInt { EOVERFLOW }
#endif
#if SYSTEM_PACKAGE_DARWIN
@_alwaysEmitIntoClient
internal var _EBADEXEC: CInt { EBADEXEC }
@_alwaysEmitIntoClient
internal var _EBADARCH: CInt { EBADARCH }
@_alwaysEmitIntoClient
internal var _ESHLIBVERS: CInt { ESHLIBVERS }
@_alwaysEmitIntoClient
internal var _EBADMACHO: CInt { EBADMACHO }
#endif
@_alwaysEmitIntoClient
internal var _ECANCELED: CInt { ECANCELED }
#if !os(Windows)
@_alwaysEmitIntoClient
internal var _EIDRM: CInt { EIDRM }
@_alwaysEmitIntoClient
internal var _ENOMSG: CInt { ENOMSG }
#endif
@_alwaysEmitIntoClient
internal var _EILSEQ: CInt { EILSEQ }
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
@_alwaysEmitIntoClient
internal var _ENOATTR: CInt { ENOATTR }
#endif
#if !os(Windows)
@_alwaysEmitIntoClient
internal var _EBADMSG: CInt { EBADMSG }
#if !os(OpenBSD)
@_alwaysEmitIntoClient
internal var _EMULTIHOP: CInt { EMULTIHOP }
#if !os(WASI) && !os(FreeBSD)
@_alwaysEmitIntoClient
internal var _ENODATA: CInt { ENODATA }
#endif
@_alwaysEmitIntoClient
internal var _ENOLINK: CInt { ENOLINK }
#if !os(WASI) && !os(FreeBSD)
@_alwaysEmitIntoClient
internal var _ENOSR: CInt { ENOSR }
@_alwaysEmitIntoClient
internal var _ENOSTR: CInt { ENOSTR }
#endif
#endif
@_alwaysEmitIntoClient
internal var _EPROTO: CInt { EPROTO }
#if !os(OpenBSD) && !os(WASI) && !os(FreeBSD)
@_alwaysEmitIntoClient
internal var _ETIME: CInt { ETIME }
#endif
#endif
@_alwaysEmitIntoClient
internal var _EOPNOTSUPP: CInt {
#if os(WASI)
_getConst_EOPNOTSUPP()
#else
EOPNOTSUPP
#endif
}
#if SYSTEM_PACKAGE_DARWIN
@_alwaysEmitIntoClient
internal var _ENOPOLICY: CInt { ENOPOLICY }
#endif
#if !os(Windows)
@_alwaysEmitIntoClient
internal var _ENOTRECOVERABLE: CInt { ENOTRECOVERABLE }
@_alwaysEmitIntoClient
internal var _EOWNERDEAD: CInt { EOWNERDEAD }
#endif
#if os(FreeBSD)
@_alwaysEmitIntoClient
internal var _ENOTCAPABLE: CInt { ENOTCAPABLE }
@_alwaysEmitIntoClient
internal var _ECAPMODE: CInt { ECAPMODE }
@_alwaysEmitIntoClient
internal var _EINTEGRITY: CInt { EINTEGRITY }
#endif
#if SYSTEM_PACKAGE_DARWIN
@_alwaysEmitIntoClient
internal var _EQFULL: CInt { EQFULL }
#endif
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
@_alwaysEmitIntoClient
internal var _ELAST: CInt { ELAST }
#endif
// MARK: File Operations
@_alwaysEmitIntoClient
internal var _O_RDONLY: CInt { O_RDONLY }
@_alwaysEmitIntoClient
internal var _O_WRONLY: CInt { O_WRONLY }
@_alwaysEmitIntoClient
internal var _O_RDWR: CInt { O_RDWR }
#if !os(Windows)
#if canImport(Musl)
internal var _O_ACCMODE: CInt { 0x03|O_SEARCH }
#else
// TODO: API?
@_alwaysEmitIntoClient
internal var _O_ACCMODE: CInt {
#if os(WASI)
_getConst_O_ACCMODE()
#else
O_ACCMODE
#endif
}
#endif
@_alwaysEmitIntoClient
internal var _O_NONBLOCK: CInt {
#if os(WASI)
_getConst_O_NONBLOCK()
#else
O_NONBLOCK
#endif
}
#endif
@_alwaysEmitIntoClient
internal var _O_APPEND: CInt {
#if os(WASI)
_getConst_O_APPEND()
#else
O_APPEND
#endif
}
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
@_alwaysEmitIntoClient
internal var _O_SHLOCK: CInt { O_SHLOCK }
@_alwaysEmitIntoClient
internal var _O_EXLOCK: CInt { O_EXLOCK }
#endif
#if !os(Windows)
#if !os(WASI)
// TODO: API?
@_alwaysEmitIntoClient
internal var _O_ASYNC: CInt { O_ASYNC }
#endif
@_alwaysEmitIntoClient
internal var _O_NOFOLLOW: CInt { O_NOFOLLOW }
#endif
#if os(FreeBSD)
@_alwaysEmitIntoClient
internal var _O_FSYNC: CInt { O_FSYNC }
@_alwaysEmitIntoClient
internal var _O_SYNC: CInt { O_SYNC }
#endif
@_alwaysEmitIntoClient
internal var _O_CREAT: CInt {
#if os(WASI)
_getConst_O_CREAT()
#else
O_CREAT
#endif
}
@_alwaysEmitIntoClient
internal var _O_TRUNC: CInt {
#if os(WASI)
_getConst_O_TRUNC()
#else
O_TRUNC
#endif
}
@_alwaysEmitIntoClient
internal var _O_EXCL: CInt {
#if os(WASI)
_getConst_O_EXCL()
#else
O_EXCL
#endif
}
#if SYSTEM_PACKAGE_DARWIN
@_alwaysEmitIntoClient
internal var _O_EVTONLY: CInt { O_EVTONLY }
#endif
#if !os(Windows)
// TODO: API?
@_alwaysEmitIntoClient
internal var _O_NOCTTY: CInt { O_NOCTTY }
@_alwaysEmitIntoClient
internal var _O_DIRECTORY: CInt {
#if os(WASI)
_getConst_O_DIRECTORY()
#else
O_DIRECTORY
#endif
}
#endif
#if SYSTEM_PACKAGE_DARWIN
@_alwaysEmitIntoClient
internal var _O_SYMLINK: CInt { O_SYMLINK }
#endif
#if !os(Windows)
@_alwaysEmitIntoClient
internal var _O_CLOEXEC: CInt { O_CLOEXEC }
#endif
@_alwaysEmitIntoClient
internal var _SEEK_SET: CInt { SEEK_SET }
@_alwaysEmitIntoClient
internal var _SEEK_CUR: CInt { SEEK_CUR }
@_alwaysEmitIntoClient
internal var _SEEK_END: CInt { SEEK_END }
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
@_alwaysEmitIntoClient
internal var _SEEK_HOLE: CInt { SEEK_HOLE }
@_alwaysEmitIntoClient
internal var _SEEK_DATA: CInt { SEEK_DATA }
#endif
+223
View File
@@ -0,0 +1,223 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 - 2024 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
*/
// Internal wrappers and typedefs which help reduce #if littering in System's
// code base.
// TODO: Should CSystem just include all the header files we need?
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif os(Windows)
import CSystem
import ucrt
#elseif canImport(Glibc)
@_implementationOnly import CSystem
import Glibc
#elseif canImport(Musl)
@_implementationOnly import CSystem
import Musl
#elseif canImport(WASILibc)
import WASILibc
#elseif canImport(Android)
@_implementationOnly import CSystem
import Android
#else
#error("Unsupported Platform")
#endif
internal typealias _COffT = off_t
// MARK: syscalls and variables
#if SYSTEM_PACKAGE_DARWIN
internal var system_errno: CInt {
get { Darwin.errno }
set { Darwin.errno = newValue }
}
#elseif os(Windows)
internal var system_errno: CInt {
get {
var value: CInt = 0
// TODO(compnerd) handle the error?
_ = ucrt._get_errno(&value)
return value
}
set {
_ = ucrt._set_errno(newValue)
}
}
#elseif canImport(Glibc)
internal var system_errno: CInt {
get { Glibc.errno }
set { Glibc.errno = newValue }
}
#elseif canImport(Musl)
internal var system_errno: CInt {
get { Musl.errno }
set { Musl.errno = newValue }
}
#elseif canImport(WASILibc)
internal var system_errno: CInt {
get { WASILibc.errno }
set { WASILibc.errno = newValue }
}
#elseif canImport(Android)
internal var system_errno: CInt {
get { Android.errno }
set { Android.errno = newValue }
}
#endif
// MARK: C stdlib decls
// Convention: `system_foo` is system's wrapper for `foo`.
internal func system_strerror(_ __errnum: Int32) -> UnsafeMutablePointer<Int8>! {
strerror(__errnum)
}
internal func system_strlen(_ s: UnsafePointer<CChar>) -> Int {
strlen(s)
}
internal func system_strlen(_ s: UnsafeMutablePointer<CChar>) -> Int {
strlen(s)
}
// Convention: `system_platform_foo` is a
// platform-representation-abstracted wrapper around `foo`-like functionality.
// Type and layout differences such as the `char` vs `wchar` are abstracted.
//
// strlen for the platform string
internal func system_platform_strlen(_ s: UnsafePointer<CInterop.PlatformChar>) -> Int {
#if os(Windows)
return wcslen(s)
#else
return strlen(s)
#endif
}
// memset for raw buffers
// FIXME: Do we really not have something like this in the stdlib already?
internal func system_memset(
_ buffer: UnsafeMutableRawBufferPointer,
to byte: UInt8
) {
guard buffer.count > 0 else { return }
memset(buffer.baseAddress!, CInt(byte), buffer.count)
}
// Interop between String and platfrom string
extension String {
internal func _withPlatformString<Success, Failure: Error>(
_ body: (UnsafePointer<CInterop.PlatformChar>) throws(Failure) -> Success
) throws(Failure) -> Success {
// Need to #if because CChar may be signed
#if os(Windows)
return try withCString(encodedAs: CInterop.PlatformUnicodeEncoding.self, body)
#else
return try withCString(body)
#endif
}
internal init?(_platformString platformString: UnsafePointer<CInterop.PlatformChar>) {
// Need to #if because CChar may be signed
#if os(Windows)
guard let strRes = String.decodeCString(
platformString,
as: CInterop.PlatformUnicodeEncoding.self,
repairingInvalidCodeUnits: false
) else { return nil }
assert(strRes.repairsMade == false)
self = strRes.result
return
#else
self.init(validatingUTF8: platformString)
#endif
}
internal init(
_errorCorrectingPlatformString platformString: UnsafePointer<CInterop.PlatformChar>
) {
// Need to #if because CChar may be signed
#if os(Windows)
let strRes = String.decodeCString(
platformString,
as: CInterop.PlatformUnicodeEncoding.self,
repairingInvalidCodeUnits: true)
self = strRes!.result
return
#else
self.init(cString: platformString)
#endif
}
}
// TLS
#if os(Windows)
internal typealias _PlatformTLSKey = DWORD
#elseif os(WASI) && (swift(<6.1) || !_runtime(_multithreaded))
// Mock TLS storage for single-threaded WASI
internal final class _PlatformTLSKey {
fileprivate init() {}
}
private final class TLSStorage: @unchecked Sendable {
var storage = [ObjectIdentifier: UnsafeMutableRawPointer]()
}
private let sharedTLSStorage = TLSStorage()
func pthread_setspecific(_ key: _PlatformTLSKey, _ p: UnsafeMutableRawPointer?) -> Int {
sharedTLSStorage.storage[ObjectIdentifier(key)] = p
return 0
}
func pthread_getspecific(_ key: _PlatformTLSKey) -> UnsafeMutableRawPointer? {
sharedTLSStorage.storage[ObjectIdentifier(key)]
}
#else
internal typealias _PlatformTLSKey = pthread_key_t
#endif
internal func makeTLSKey() -> _PlatformTLSKey {
#if os(Windows)
let raw: DWORD = FlsAlloc(nil)
if raw == FLS_OUT_OF_INDEXES {
fatalError("Unable to create key")
}
return raw
#elseif os(WASI) && (swift(<6.1) || !_runtime(_multithreaded))
return _PlatformTLSKey()
#else
var raw = pthread_key_t()
guard 0 == pthread_key_create(&raw, nil) else {
fatalError("Unable to create key")
}
return raw
#endif
}
internal func setTLS(_ key: _PlatformTLSKey, _ p: UnsafeMutableRawPointer?) {
#if os(Windows)
guard FlsSetValue(key, p) else {
fatalError("Unable to set TLS")
}
#else
guard 0 == pthread_setspecific(key, p) else {
fatalError("Unable to set TLS")
}
#endif
}
internal func getTLS(_ key: _PlatformTLSKey) -> UnsafeMutableRawPointer? {
#if os(Windows)
return FlsGetValue(key)
#else
return pthread_getspecific(key)
#endif
}
+209
View File
@@ -0,0 +1,209 @@
/*
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
*/
// Syscall mocking support.
//
// NOTE: This is currently the bare minimum needed for System's testing purposes, though we do
// eventually want to expose some solution to users.
//
// Mocking is contextual, accessible through MockingDriver.withMockingEnabled. Mocking
// state, including whether it is enabled, is stored in thread-local storage. Mocking is only
// enabled in testing builds of System currently, to minimize runtime overhead of release builds.
//
#if ENABLE_MOCKING && !$Embedded
internal struct Trace {
internal struct Entry {
internal var name: String
internal var arguments: [AnyHashable]
internal init(name: String, _ arguments: [AnyHashable]) {
self.name = name
self.arguments = arguments
}
}
private var entries: [Entry] = []
private var firstEntry: Int = 0
internal var isEmpty: Bool { firstEntry >= entries.count }
internal mutating func dequeue() -> Entry? {
guard !self.isEmpty else { return nil }
defer { firstEntry += 1 }
return entries[firstEntry]
}
fileprivate mutating func add(_ e: Entry) {
entries.append(e)
}
}
internal enum ForceErrno: Equatable {
case none
case always(errno: CInt)
case counted(errno: CInt, count: Int)
}
// Provide access to the driver, context, and trace stack of mocking
internal class MockingDriver {
// Record syscalls and their arguments
internal var trace = Trace()
// Mock errors inside syscalls
internal var forceErrno = ForceErrno.none
// Whether we should pretend to be Windows for syntactic operations
// inside FilePath
fileprivate var forceWindowsSyntaxForPaths: Bool? = nil
}
private let driverKey: _PlatformTLSKey = { makeTLSKey() }()
internal var currentMockingDriver: MockingDriver? {
#if !ENABLE_MOCKING
fatalError("Contextual mocking in non-mocking build")
#endif
guard let rawPtr = getTLS(driverKey) else { return nil }
return Unmanaged<MockingDriver>.fromOpaque(rawPtr).takeUnretainedValue()
}
extension MockingDriver {
/// Enables mocking for the duration of `f` with a clean trace queue
/// Restores prior mocking status and trace queue after execution
internal static func withMockingEnabled(
_ f: (MockingDriver) throws -> ()
) rethrows {
let priorMocking = currentMockingDriver
let driver = MockingDriver()
defer {
if let object = priorMocking {
setTLS(driverKey, Unmanaged.passUnretained(object).toOpaque())
} else {
setTLS(driverKey, nil)
}
_fixLifetime(driver)
}
setTLS(driverKey, Unmanaged.passUnretained(driver).toOpaque())
return try f(driver)
}
}
// Check TLS for mocking
@inline(never)
private var contextualMockingEnabled: Bool {
return currentMockingDriver != nil
}
extension MockingDriver {
internal static var enabled: Bool { mockingEnabled }
internal static var forceWindowsPaths: Bool? {
currentMockingDriver?.forceWindowsSyntaxForPaths
}
}
#endif // ENABLE_MOCKING && !$Embedded
@inline(__always)
internal var mockingEnabled: Bool {
// Fast constant-foldable check for release builds
#if ENABLE_MOCKING && !$Embedded
return contextualMockingEnabled
#else
return false
#endif
}
@inline(__always)
internal var forceWindowsPaths: Bool? {
#if ENABLE_MOCKING && !$Embedded
return MockingDriver.forceWindowsPaths
#else
return nil
#endif
}
#if ENABLE_MOCKING && !$Embedded
// Strip the mock_system prefix and the arg list suffix
private func originalSyscallName(_ function: String) -> String {
// `function` must be of format `system_<name>(<parameters>)`
precondition(function.starts(with: "system_"))
return String(function.dropFirst("system_".count).prefix { $0 != "(" })
}
private func mockImpl(
name: String,
path: UnsafePointer<CInterop.PlatformChar>?,
_ args: [AnyHashable]
) -> CInt {
precondition(mockingEnabled)
let origName = originalSyscallName(name)
guard let driver = currentMockingDriver else {
fatalError("Mocking requested from non-mocking context")
}
var mockArgs: Array<AnyHashable> = []
if let p = path {
mockArgs.append(String(_errorCorrectingPlatformString: p))
}
mockArgs.append(contentsOf: args)
driver.trace.add(Trace.Entry(name: origName, mockArgs))
switch driver.forceErrno {
case .none: break
case .always(let e):
system_errno = e
return -1
case .counted(let e, let count):
assert(count >= 1)
system_errno = e
driver.forceErrno = count > 1 ? .counted(errno: e, count: count-1) : .none
return -1
}
return 0
}
internal func _mock(
name: String = #function, path: UnsafePointer<CInterop.PlatformChar>? = nil, _ args: AnyHashable...
) -> CInt {
return mockImpl(name: name, path: path, args)
}
internal func _mockInt(
name: String = #function, path: UnsafePointer<CInterop.PlatformChar>? = nil, _ args: AnyHashable...
) -> Int {
Int(mockImpl(name: name, path: path, args))
}
internal func _mockOffT(
name: String = #function, path: UnsafePointer<CInterop.PlatformChar>? = nil, _ args: AnyHashable...
) -> _COffT {
_COffT(mockImpl(name: name, path: path, args))
}
#endif // ENABLE_MOCKING && !$Embedded
// Force paths to be treated as Windows syntactically if `enabled` is
// true, and as POSIX syntactically if not.
internal func _withWindowsPaths(enabled: Bool, _ body: () -> ()) {
#if ENABLE_MOCKING && !$Embedded
MockingDriver.withMockingEnabled { driver in
driver.forceWindowsSyntaxForPaths = enabled
body()
}
#else
body()
#endif
}
+108
View File
@@ -0,0 +1,108 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 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
*/
// A copy-on-write fixed-size buffer of raw memory.
internal struct _RawBuffer {
internal var _storage: Storage?
internal init() {
self._storage = nil
}
internal init(minimumCapacity: Int) {
if minimumCapacity > 0 {
self._storage = Storage.create(minimumCapacity: minimumCapacity)
} else {
self._storage = nil
}
}
}
extension _RawBuffer {
internal var capacity: Int {
_storage?.header ?? 0 // Note: not capacity!
}
internal mutating func ensureUnique() {
guard _storage != nil else { return }
let unique = isKnownUniquelyReferenced(&_storage)
if !unique {
_storage = _copy(capacity: capacity)
}
}
internal func _grow(desired: Int) -> Int {
let next = Int(1.75 * Double(self.capacity))
return Swift.max(next, desired)
}
internal mutating func ensureUnique(capacity: Int) {
let unique = isKnownUniquelyReferenced(&_storage)
if !unique || self.capacity < capacity {
_storage = _copy(capacity: _grow(desired: capacity))
}
}
internal func withUnsafeBytes<R>(
_ body: (UnsafeRawBufferPointer) throws -> R
) rethrows -> R {
guard let storage = _storage else {
return try body(UnsafeRawBufferPointer(start: nil, count: 0))
}
return try storage.withUnsafeMutablePointers { count, bytes in
let buffer = UnsafeRawBufferPointer(start: bytes, count: count.pointee)
return try body(buffer)
}
}
internal mutating func withUnsafeMutableBytes<R>(
_ body: (UnsafeMutableRawBufferPointer) throws -> R
) rethrows -> R {
guard _storage != nil else {
return try body(UnsafeMutableRawBufferPointer(start: nil, count: 0))
}
ensureUnique()
return try _storage!.withUnsafeMutablePointers { count, bytes in
let buffer = UnsafeMutableRawBufferPointer(start: bytes, count: count.pointee)
return try body(buffer)
}
}
}
extension _RawBuffer {
internal class Storage: ManagedBuffer<Int, UInt8> {
internal static func create(minimumCapacity: Int) -> Storage {
Storage.create(
minimumCapacity: minimumCapacity,
makingHeaderWith: {
#if os(OpenBSD)
minimumCapacity
#else
$0.capacity
#endif
}
) as! Storage
}
}
internal func _copy(capacity: Int) -> Storage {
let copy = Storage.create(minimumCapacity: capacity)
copy.withUnsafeMutablePointers { dstlen, dst in
self.withUnsafeBytes { src in
guard src.count > 0 else { return }
assert(src.count <= dstlen.pointee)
UnsafeMutableRawPointer(dst)
.copyMemory(
from: src.baseAddress!,
byteCount: Swift.min(src.count, dstlen.pointee))
}
}
return copy
}
}
+271
View File
@@ -0,0 +1,271 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 - 2025 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
*/
#if SYSTEM_PACKAGE_DARWIN
import Darwin
#elseif canImport(Glibc)
import Glibc
#elseif canImport(Musl)
import Musl
#elseif canImport(WASILibc)
import CSystem
import WASILibc
#elseif os(Windows)
import ucrt
#elseif canImport(Android)
import Android
#else
#error("Unsupported Platform")
#endif
// Interacting with the mocking system, tracing, etc., is a potentially significant
// amount of code size, so we hand outline that code for every syscall
// open
internal func system_open(
_ path: UnsafePointer<CInterop.PlatformChar>, _ oflag: Int32
) -> CInt {
#if ENABLE_MOCKING && !$Embedded
if mockingEnabled {
return _mock(path: path, oflag)
}
#endif
return open(path, oflag)
}
internal func system_open(
_ path: UnsafePointer<CInterop.PlatformChar>,
_ oflag: Int32, _ mode: CInterop.Mode
) -> CInt {
#if ENABLE_MOCKING && !$Embedded
if mockingEnabled {
return _mock(path: path, oflag, mode)
}
#endif
return open(path, oflag, mode)
}
// close
internal func system_close(_ fd: Int32) -> Int32 {
#if ENABLE_MOCKING && !$Embedded
if mockingEnabled { return _mock(fd) }
#endif
return close(fd)
}
// read
internal func system_read(
_ fd: Int32, _ buf: UnsafeMutableRawPointer?, _ nbyte: Int
) -> Int {
#if ENABLE_MOCKING && !$Embedded
if mockingEnabled { return _mockInt(fd, buf, nbyte) }
#endif
return read(fd, buf, nbyte)
}
// pread
internal func system_pread(
_ fd: Int32, _ buf: UnsafeMutableRawPointer?, _ nbyte: Int, _ offset: off_t
) -> Int {
#if ENABLE_MOCKING && !$Embedded
if mockingEnabled { return _mockInt(fd, buf, nbyte, offset) }
#endif
#if os(Android)
var zero = UInt8.zero
return withUnsafeMutablePointer(to: &zero) {
// this pread has a non-nullable `buf` pointer
pread(fd, buf ?? UnsafeMutableRawPointer($0), nbyte, offset)
}
#else
return pread(fd, buf, nbyte, offset)
#endif
}
// lseek
internal func system_lseek(
_ fd: Int32, _ off: off_t, _ whence: Int32
) -> off_t {
#if ENABLE_MOCKING && !$Embedded
if mockingEnabled { return _mockOffT(fd, off, whence) }
#endif
return lseek(fd, off, whence)
}
// write
internal func system_write(
_ fd: Int32, _ buf: UnsafeRawPointer?, _ nbyte: Int
) -> Int {
#if ENABLE_MOCKING && !$Embedded
if mockingEnabled { return _mockInt(fd, buf, nbyte) }
#endif
return write(fd, buf, nbyte)
}
// pwrite
internal func system_pwrite(
_ fd: Int32, _ buf: UnsafeRawPointer?, _ nbyte: Int, _ offset: off_t
) -> Int {
#if ENABLE_MOCKING && !$Embedded
if mockingEnabled { return _mockInt(fd, buf, nbyte, offset) }
#endif
#if os(Android)
var zero = UInt8.zero
return withUnsafeMutablePointer(to: &zero) {
// this pwrite has a non-nullable `buf` pointer
pwrite(fd, buf ?? UnsafeRawPointer($0), nbyte, offset)
}
#else
return pwrite(fd, buf, nbyte, offset)
#endif
}
#if !os(WASI)
internal func system_dup(_ fd: Int32) -> Int32 {
#if ENABLE_MOCKING && !$Embedded
if mockingEnabled { return _mock(fd) }
#endif
return dup(fd)
}
internal func system_dup2(_ fd: Int32, _ fd2: Int32) -> Int32 {
#if ENABLE_MOCKING && !$Embedded
if mockingEnabled { return _mock(fd, fd2) }
#endif
return dup2(fd, fd2)
}
#endif
#if !os(WASI)
internal func system_pipe(_ fds: UnsafeMutablePointer<Int32>) -> CInt {
#if ENABLE_MOCKING && !$Embedded
if mockingEnabled { return _mock(fds) }
#endif
return pipe(fds)
}
#endif
internal func system_ftruncate(_ fd: Int32, _ length: off_t) -> Int32 {
#if ENABLE_MOCKING && !$Embedded
if mockingEnabled { return _mock(fd, length) }
#endif
return ftruncate(fd, length)
}
internal func system_mkdir(
_ path: UnsafePointer<CInterop.PlatformChar>,
_ mode: CInterop.Mode
) -> CInt {
#if ENABLE_MOCKING && !$Embedded
if mockingEnabled { return _mock(path: path, mode) }
#endif
return mkdir(path, mode)
}
internal func system_rmdir(
_ path: UnsafePointer<CInterop.PlatformChar>
) -> CInt {
#if ENABLE_MOCKING && !$Embedded
if mockingEnabled { return _mock(path: path) }
#endif
return rmdir(path)
}
#if SYSTEM_PACKAGE_DARWIN
internal let SYSTEM_CS_DARWIN_USER_TEMP_DIR = _CS_DARWIN_USER_TEMP_DIR
internal func system_confstr(
_ name: CInt,
_ buf: UnsafeMutablePointer<CInterop.PlatformChar>,
_ len: Int
) -> Int {
return confstr(name, buf, len)
}
#endif
#if !os(Windows)
internal let SYSTEM_AT_REMOVE_DIR = AT_REMOVEDIR
#if os(WASI)
internal let SYSTEM_DT_DIR = _getConst_DT_DIR()
internal typealias system_dirent = _system_dirent
#else
internal let SYSTEM_DT_DIR = DT_DIR
internal typealias system_dirent = dirent
#endif
#if os(Linux) || os(Android) || os(FreeBSD) || os(OpenBSD) || os(WASI)
internal typealias system_DIRPtr = OpaquePointer
#else
internal typealias system_DIRPtr = UnsafeMutablePointer<DIR>
#endif
internal func system_unlinkat(
_ fd: CInt,
_ path: UnsafePointer<CInterop.PlatformChar>,
_ flag: CInt
) -> CInt {
#if ENABLE_MOCKING && !$Embedded
if mockingEnabled { return _mock(fd, path, flag) }
#endif
return unlinkat(fd, path, flag)
}
internal func system_fdopendir(
_ fd: CInt
) -> system_DIRPtr? {
return fdopendir(fd)
}
internal func system_readdir(
_ dir: system_DIRPtr
) -> UnsafeMutablePointer<system_dirent>? {
#if os(WASI)
return _system_dirent_from_wasi_dirent(readdir(dir))
#else
return readdir(dir)
#endif
}
internal func system_rewinddir(
_ dir: system_DIRPtr
) {
return rewinddir(dir)
}
internal func system_closedir(
_ dir: system_DIRPtr
) -> CInt {
return closedir(dir)
}
internal func system_openat(
_ fd: CInt,
_ path: UnsafePointer<CInterop.PlatformChar>,
_ oflag: Int32
) -> CInt {
#if ENABLE_MOCKING && !$Embedded
if mockingEnabled {
return _mock(fd, path, oflag)
}
#endif
return openat(fd, path, oflag)
}
#endif
#if !os(WASI) // WASI has no umask
internal func system_umask(
_ mode: CInterop.Mode
) -> CInterop.Mode {
return umask(mode)
}
#endif
internal func system_getenv(
_ name: UnsafePointer<CChar>
) -> UnsafeMutablePointer<CChar>? {
return getenv(name)
}
@@ -0,0 +1,658 @@
/*
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
*/
#if os(Windows)
import ucrt
import WinSDK
fileprivate var _umask: CInterop.Mode = 0o22
@inline(__always)
func umask(
_ mode: CInterop.Mode
) -> CInterop.Mode {
let oldMask = _umask
_umask = mode
return oldMask
}
@inline(__always)
internal func open(
_ path: UnsafePointer<CInterop.PlatformChar>, _ oflag: Int32
) -> CInt {
let decodedFlags = DecodedOpenFlags(oflag)
var saAttrs = SECURITY_ATTRIBUTES(
nLength: DWORD(MemoryLayout<SECURITY_ATTRIBUTES>.size),
lpSecurityDescriptor: nil,
bInheritHandle: decodedFlags.bInheritHandle
)
guard let hFile = try? path.withCanonicalPathRepresentation({ path in
CreateFileW(path,
decodedFlags.dwDesiredAccess,
DWORD(FILE_SHARE_DELETE
| FILE_SHARE_READ
| FILE_SHARE_WRITE),
&saAttrs,
decodedFlags.dwCreationDisposition,
decodedFlags.dwFlagsAndAttributes,
nil)
}), hFile != INVALID_HANDLE_VALUE else {
ucrt._set_errno(_mapWindowsErrorToErrno(GetLastError()))
return -1
}
return _open_osfhandle(intptr_t(bitPattern: hFile), oflag);
}
@inline(__always)
internal func open(
_ path: UnsafePointer<CInterop.PlatformChar>, _ oflag: Int32,
_ mode: CInterop.Mode
) -> CInt {
let actualMode = mode & ~_umask
guard let pSD = _createSecurityDescriptor(from: actualMode, for: .file) else {
ucrt._set_errno(_mapWindowsErrorToErrno(GetLastError()))
return -1
}
defer {
pSD.deallocate()
}
let decodedFlags = DecodedOpenFlags(oflag)
var saAttrs = SECURITY_ATTRIBUTES(
nLength: DWORD(MemoryLayout<SECURITY_ATTRIBUTES>.size),
lpSecurityDescriptor: pSD,
bInheritHandle: decodedFlags.bInheritHandle
)
guard let hFile = try? path.withCanonicalPathRepresentation({ path in
CreateFileW(path,
decodedFlags.dwDesiredAccess,
DWORD(FILE_SHARE_DELETE
| FILE_SHARE_READ
| FILE_SHARE_WRITE),
&saAttrs,
decodedFlags.dwCreationDisposition,
decodedFlags.dwFlagsAndAttributes,
nil)
}), hFile != INVALID_HANDLE_VALUE else {
ucrt._set_errno(_mapWindowsErrorToErrno(GetLastError()))
return -1
}
return _open_osfhandle(intptr_t(bitPattern: hFile), oflag);
}
@inline(__always)
internal func close(_ fd: Int32) -> Int32 {
_close(fd)
}
@inline(__always)
internal func lseek(
_ fd: Int32, _ off: Int64, _ whence: Int32
) -> Int64 {
_lseeki64(fd, off, whence)
}
@inline(__always)
internal func read(
_ fd: Int32, _ buf: UnsafeMutableRawPointer!, _ nbyte: Int
) -> Int {
Int(_read(fd, buf, numericCast(nbyte)))
}
@inline(__always)
internal func write(
_ fd: Int32, _ buf: UnsafeRawPointer!, _ nbyte: Int
) -> Int {
Int(_write(fd, buf, numericCast(nbyte)))
}
@inline(__always)
internal func lseek(
_ fd: Int32, _ off: off_t, _ whence: Int32
) -> off_t {
_lseek(fd, off, whence)
}
@inline(__always)
internal func dup(_ fd: Int32) -> Int32 {
_dup(fd)
}
@inline(__always)
internal func dup2(_ fd: Int32, _ fd2: Int32) -> Int32 {
_dup2(fd, fd2)
}
@inline(__always)
internal func pread(
_ fd: Int32, _ buf: UnsafeMutableRawPointer!, _ nbyte: Int, _ offset: off_t
) -> Int {
let handle: intptr_t = _get_osfhandle(fd)
if handle == /* INVALID_HANDLE_VALUE */ -1 { ucrt._set_errno(EBADF); return -1 }
// NOTE: this is a non-owning handle, do *not* call CloseHandle on it
let hFile: HANDLE = HANDLE(bitPattern: handle)!
var ovlOverlapped: OVERLAPPED = OVERLAPPED()
ovlOverlapped.OffsetHigh = DWORD(UInt32(offset >> 32) & 0xffffffff)
ovlOverlapped.Offset = DWORD(UInt32(offset >> 0) & 0xffffffff)
var nNumberOfBytesRead: DWORD = 0
if !ReadFile(hFile, buf, DWORD(nbyte), &nNumberOfBytesRead, &ovlOverlapped) {
ucrt._set_errno(_mapWindowsErrorToErrno(GetLastError()))
return Int(-1)
}
return Int(nNumberOfBytesRead)
}
@inline(__always)
internal func pwrite(
_ fd: Int32, _ buf: UnsafeRawPointer!, _ nbyte: Int, _ offset: off_t
) -> Int {
let handle: intptr_t = _get_osfhandle(fd)
if handle == /* INVALID_HANDLE_VALUE */ -1 { ucrt._set_errno(EBADF); return -1 }
// NOTE: this is a non-owning handle, do *not* call CloseHandle on it
let hFile: HANDLE = HANDLE(bitPattern: handle)!
var ovlOverlapped: OVERLAPPED = OVERLAPPED()
ovlOverlapped.OffsetHigh = DWORD(UInt32(offset >> 32) & 0xffffffff)
ovlOverlapped.Offset = DWORD(UInt32(offset >> 0) & 0xffffffff)
var nNumberOfBytesWritten: DWORD = 0
if !WriteFile(hFile, buf, DWORD(nbyte), &nNumberOfBytesWritten,
&ovlOverlapped) {
ucrt._set_errno(_mapWindowsErrorToErrno(GetLastError()))
return Int(-1)
}
return Int(nNumberOfBytesWritten)
}
@inline(__always)
internal func pipe(
_ fds: UnsafeMutablePointer<Int32>, bytesReserved: UInt32 = 4096
) -> CInt {
return _pipe(fds, bytesReserved, _O_BINARY | _O_NOINHERIT);
}
@inline(__always)
internal func ftruncate(_ fd: Int32, _ length: off_t) -> Int32 {
let handle: intptr_t = _get_osfhandle(fd)
if handle == /* INVALID_HANDLE_VALUE */ -1 { ucrt._set_errno(EBADF); return -1 }
// NOTE: this is a non-owning handle, do *not* call CloseHandle on it
let hFile: HANDLE = HANDLE(bitPattern: handle)!
let liDesiredLength = LARGE_INTEGER(QuadPart: LONGLONG(length))
var liCurrentOffset = LARGE_INTEGER(QuadPart: 0)
// Save the current position and restore it when we're done
if !SetFilePointerEx(hFile, liCurrentOffset, &liCurrentOffset,
DWORD(FILE_CURRENT)) {
ucrt._set_errno(_mapWindowsErrorToErrno(GetLastError()))
return -1
}
defer {
_ = SetFilePointerEx(hFile, liCurrentOffset, nil, DWORD(FILE_BEGIN));
}
// Truncate (or extend) the file
if !SetFilePointerEx(hFile, liDesiredLength, nil, DWORD(FILE_BEGIN))
|| !SetEndOfFile(hFile) {
ucrt._set_errno(_mapWindowsErrorToErrno(GetLastError()))
return -1
}
return 0;
}
@inline(__always)
internal func mkdir(
_ path: UnsafePointer<CInterop.PlatformChar>,
_ mode: CInterop.Mode
) -> CInt {
let actualMode = mode & ~_umask
guard let pSD = _createSecurityDescriptor(from: actualMode,
for: .directory) else {
ucrt._set_errno(_mapWindowsErrorToErrno(GetLastError()))
return -1
}
defer {
pSD.deallocate()
}
var saAttrs = SECURITY_ATTRIBUTES(
nLength: DWORD(MemoryLayout<SECURITY_ATTRIBUTES>.size),
lpSecurityDescriptor: pSD,
bInheritHandle: false
)
guard (try? path.withCanonicalPathRepresentation({ path in CreateDirectoryW(path, &saAttrs) })) == true else {
ucrt._set_errno(_mapWindowsErrorToErrno(GetLastError()))
return -1
}
return 0;
}
@inline(__always)
internal func rmdir(
_ path: UnsafePointer<CInterop.PlatformChar>
) -> CInt {
guard (try? path.withCanonicalPathRepresentation({ path in RemoveDirectoryW(path) })) == true else {
ucrt._set_errno(_mapWindowsErrorToErrno(GetLastError()))
return -1
}
return 0;
}
internal func _mapWindowsErrorToErrno(_ errorCode: DWORD) -> CInt {
switch Int32(errorCode) {
case ERROR_SUCCESS:
return 0
case ERROR_INVALID_FUNCTION,
ERROR_INVALID_ACCESS,
ERROR_INVALID_DATA,
ERROR_INVALID_PARAMETER,
ERROR_NEGATIVE_SEEK:
return EINVAL
case ERROR_FILE_NOT_FOUND,
ERROR_PATH_NOT_FOUND,
ERROR_INVALID_DRIVE,
ERROR_NO_MORE_FILES,
ERROR_BAD_NETPATH,
ERROR_BAD_NET_NAME,
ERROR_BAD_PATHNAME,
ERROR_FILENAME_EXCED_RANGE:
return ENOENT
case ERROR_TOO_MANY_OPEN_FILES:
return EMFILE
case ERROR_ACCESS_DENIED,
ERROR_CURRENT_DIRECTORY,
ERROR_LOCK_VIOLATION,
ERROR_NETWORK_ACCESS_DENIED,
ERROR_CANNOT_MAKE,
ERROR_FAIL_I24,
ERROR_DRIVE_LOCKED,
ERROR_SEEK_ON_DEVICE,
ERROR_NOT_LOCKED,
ERROR_LOCK_FAILED,
ERROR_WRITE_PROTECT...ERROR_SHARING_BUFFER_EXCEEDED:
return EACCES
case ERROR_INVALID_HANDLE,
ERROR_INVALID_TARGET_HANDLE,
ERROR_DIRECT_ACCESS_HANDLE:
return EBADF
case ERROR_ARENA_TRASHED,
ERROR_NOT_ENOUGH_MEMORY,
ERROR_INVALID_BLOCK,
ERROR_NOT_ENOUGH_QUOTA:
return ENOMEM
case ERROR_BAD_ENVIRONMENT:
return E2BIG
case ERROR_BAD_FORMAT,
ERROR_INVALID_STARTING_CODESEG...ERROR_INFLOOP_IN_RELOC_CHAIN:
return ENOEXEC
case ERROR_NOT_SAME_DEVICE:
return EXDEV
case ERROR_FILE_EXISTS,
ERROR_ALREADY_EXISTS:
return EEXIST
case ERROR_NO_PROC_SLOTS,
ERROR_MAX_THRDS_REACHED,
ERROR_NESTING_NOT_ALLOWED:
return EAGAIN
case ERROR_BROKEN_PIPE:
return EPIPE
case ERROR_DISK_FULL:
return ENOSPC
case ERROR_WAIT_NO_CHILDREN,
ERROR_CHILD_NOT_COMPLETE:
return ECHILD
case ERROR_DIR_NOT_EMPTY:
return ENOTEMPTY
case ERROR_NO_UNICODE_TRANSLATION:
return EILSEQ
default:
return EINVAL
}
}
fileprivate func rightsFromModeBits(
_ bits: Int,
sticky: Bool = false,
for fileOrDirectory: _FileOrDirectory
) -> DWORD {
var rights: DWORD = 0
if (bits & 0o4) != 0 {
rights |= DWORD(FILE_READ_ATTRIBUTES
| FILE_READ_DATA
| FILE_READ_EA
| STANDARD_RIGHTS_READ
| SYNCHRONIZE)
}
if (bits & 0o2) != 0 {
rights |= DWORD(FILE_APPEND_DATA
| FILE_WRITE_ATTRIBUTES
| FILE_WRITE_DATA
| FILE_WRITE_EA
| STANDARD_RIGHTS_WRITE
| SYNCHRONIZE)
if fileOrDirectory == .directory && !sticky {
rights |= DWORD(FILE_DELETE_CHILD)
}
}
if (bits & 0o1) != 0 {
rights |= DWORD(FILE_EXECUTE
| FILE_READ_ATTRIBUTES
| STANDARD_RIGHTS_EXECUTE
| SYNCHRONIZE)
}
return rights
}
fileprivate func getTokenInformation<T>(
of: T.Type,
hToken: HANDLE,
ticTokenClass: TOKEN_INFORMATION_CLASS
) -> UnsafePointer<T>? {
var capacity = 1024
for _ in 0..<2 {
let buffer = UnsafeMutableRawPointer.allocate(
byteCount: capacity,
alignment: MemoryLayout<T>.alignment
)
var dwLength = DWORD(0)
if GetTokenInformation(hToken,
ticTokenClass,
buffer,
DWORD(capacity),
&dwLength) {
return UnsafePointer(buffer.assumingMemoryBound(to: T.self))
}
buffer.deallocate()
capacity = Int(dwLength)
}
return nil
}
internal enum _FileOrDirectory {
case file
case directory
}
/// Build a SECURITY_DESCRIPTOR from UNIX-style "mode" bits. This only
/// takes account of the rwx and sticky bits; there's really nothing that
/// we can do about setuid/setgid.
internal func _createSecurityDescriptor(from mode: CInterop.Mode,
for fileOrDirectory: _FileOrDirectory)
-> PSECURITY_DESCRIPTOR? {
let ownerPerm = (Int(mode) >> 6) & 0o7
let groupPerm = (Int(mode) >> 3) & 0o7
let otherPerm = Int(mode) & 0o7
let ownerRights = rightsFromModeBits(ownerPerm, for: fileOrDirectory)
let groupRights = rightsFromModeBits(groupPerm,
sticky: (mode & 0o1000) != 0,
for: fileOrDirectory)
let otherRights = rightsFromModeBits(otherPerm,
sticky: (mode & 0o1000) != 0,
for: fileOrDirectory)
// If group or other permissions are *more* permissive, then we need
// some DENY ACEs as well to implement the expected semantics
let ownerDenyRights = ((ownerRights ^ groupRights) & groupRights) |
((ownerRights ^ otherRights) & otherRights)
let groupDenyRights = (groupRights ^ otherRights) & otherRights
var SIDAuthWorld = SID_IDENTIFIER_AUTHORITY(Value: (0, 0, 0, 0, 0, 1))
var everyone: PSID? = nil
guard AllocateAndInitializeSid(&SIDAuthWorld, 1,
DWORD(SECURITY_WORLD_RID),
0, 0, 0, 0, 0, 0, 0,
&everyone) else {
return nil
}
guard let everyone = everyone else {
return nil
}
defer {
FreeSid(everyone)
}
let hToken = GetCurrentThreadEffectiveToken()!
guard let pTokenUser = getTokenInformation(of: TOKEN_USER.self,
hToken: hToken,
ticTokenClass: TokenUser) else {
return nil
}
defer {
pTokenUser.deallocate()
}
guard let pTokenPrimaryGroup = getTokenInformation(
of: TOKEN_PRIMARY_GROUP.self,
hToken: hToken,
ticTokenClass: TokenPrimaryGroup
) else {
return nil
}
defer {
pTokenPrimaryGroup.deallocate()
}
let user = pTokenUser.pointee.User.Sid!
let group = pTokenPrimaryGroup.pointee.PrimaryGroup!
var eas = [
EXPLICIT_ACCESS_W(
grfAccessPermissions: ownerRights,
grfAccessMode: GRANT_ACCESS,
grfInheritance: DWORD(NO_INHERITANCE),
Trustee: TRUSTEE_W(
pMultipleTrustee: nil,
MultipleTrusteeOperation: NO_MULTIPLE_TRUSTEE,
TrusteeForm: TRUSTEE_IS_SID,
TrusteeType: TRUSTEE_IS_USER,
ptstrName:
user.assumingMemoryBound(to: CInterop.PlatformChar.self)
)
),
EXPLICIT_ACCESS_W(
grfAccessPermissions: groupRights,
grfAccessMode: GRANT_ACCESS,
grfInheritance: DWORD(NO_INHERITANCE),
Trustee: TRUSTEE_W(
pMultipleTrustee: nil,
MultipleTrusteeOperation: NO_MULTIPLE_TRUSTEE,
TrusteeForm: TRUSTEE_IS_SID,
TrusteeType: TRUSTEE_IS_GROUP,
ptstrName:
group.assumingMemoryBound(to: CInterop.PlatformChar.self)
)
),
EXPLICIT_ACCESS_W(
grfAccessPermissions: otherRights,
grfAccessMode: GRANT_ACCESS,
grfInheritance: DWORD(NO_INHERITANCE),
Trustee: TRUSTEE_W(
pMultipleTrustee: nil,
MultipleTrusteeOperation: NO_MULTIPLE_TRUSTEE,
TrusteeForm: TRUSTEE_IS_SID,
TrusteeType: TRUSTEE_IS_GROUP,
ptstrName:
everyone.assumingMemoryBound(to: CInterop.PlatformChar.self)
)
)
]
if ownerDenyRights != 0 {
eas.append(
EXPLICIT_ACCESS_W(
grfAccessPermissions: ownerDenyRights,
grfAccessMode: DENY_ACCESS,
grfInheritance: DWORD(NO_INHERITANCE),
Trustee: TRUSTEE_W(
pMultipleTrustee: nil,
MultipleTrusteeOperation: NO_MULTIPLE_TRUSTEE,
TrusteeForm: TRUSTEE_IS_SID,
TrusteeType: TRUSTEE_IS_USER,
ptstrName:
user.assumingMemoryBound(to: CInterop.PlatformChar.self)
)
)
)
}
if groupDenyRights != 0 {
eas.append(
EXPLICIT_ACCESS_W(
grfAccessPermissions: groupDenyRights,
grfAccessMode: DENY_ACCESS,
grfInheritance: DWORD(NO_INHERITANCE),
Trustee: TRUSTEE_W(
pMultipleTrustee: nil,
MultipleTrusteeOperation: NO_MULTIPLE_TRUSTEE,
TrusteeForm: TRUSTEE_IS_SID,
TrusteeType: TRUSTEE_IS_GROUP,
ptstrName:
group.assumingMemoryBound(to: CInterop.PlatformChar.self)
)
)
)
}
var pACL: PACL? = nil
guard SetEntriesInAclW(ULONG(eas.count),
&eas,
nil,
&pACL) == ERROR_SUCCESS else {
return nil
}
defer {
LocalFree(pACL)
}
// Create the security descriptor, making sure that inherited ACEs don't
// take effect, since that wouldn't match the behaviour of mode bits.
var descriptor = SECURITY_DESCRIPTOR()
guard InitializeSecurityDescriptor(&descriptor,
DWORD(SECURITY_DESCRIPTOR_REVISION)) else {
return nil
}
guard SetSecurityDescriptorControl(&descriptor,
SECURITY_DESCRIPTOR_CONTROL(SE_DACL_PROTECTED),
SECURITY_DESCRIPTOR_CONTROL(SE_DACL_PROTECTED))
&& SetSecurityDescriptorOwner(&descriptor, user, false)
&& SetSecurityDescriptorGroup(&descriptor, group, false)
&& SetSecurityDescriptorDacl(&descriptor,
true,
pACL,
false) else {
return nil
}
// Make it self-contained (up to this point it uses pointers)
var dwRelativeSize = DWORD(0)
guard !MakeSelfRelativeSD(&descriptor, nil, &dwRelativeSize)
&& GetLastError() == ERROR_INSUFFICIENT_BUFFER else {
return nil
}
let pDescriptor = UnsafeMutableRawPointer.allocate(
byteCount: Int(dwRelativeSize),
alignment: MemoryLayout<SECURITY_DESCRIPTOR>.alignment
).assumingMemoryBound(to: SECURITY_DESCRIPTOR.self)
guard MakeSelfRelativeSD(&descriptor, pDescriptor, &dwRelativeSize) else {
pDescriptor.deallocate()
return nil
}
return UnsafeMutableRawPointer(pDescriptor)
}
fileprivate struct DecodedOpenFlags {
var dwDesiredAccess: DWORD
var dwCreationDisposition: DWORD
var bInheritHandle: WindowsBool
var dwFlagsAndAttributes: DWORD
init(_ oflag: Int32) {
switch oflag & (_O_CREAT | _O_EXCL | _O_TRUNC) {
case _O_CREAT | _O_EXCL, _O_CREAT | _O_EXCL | _O_TRUNC:
dwCreationDisposition = DWORD(CREATE_NEW)
case _O_CREAT:
dwCreationDisposition = DWORD(OPEN_ALWAYS)
case _O_CREAT | _O_TRUNC:
dwCreationDisposition = DWORD(CREATE_ALWAYS)
case _O_TRUNC:
dwCreationDisposition = DWORD(TRUNCATE_EXISTING)
default:
dwCreationDisposition = DWORD(OPEN_EXISTING)
}
// The _O_RDONLY, _O_WRONLY and _O_RDWR flags are non-overlapping
// on Windows; in particular, _O_RDONLY is zero, which means we can't
// test for it by AND-ing.
dwDesiredAccess = 0
switch (oflag & (_O_RDONLY|_O_WRONLY|_O_RDWR)) {
case _O_RDONLY:
dwDesiredAccess |= DWORD(GENERIC_READ)
case _O_WRONLY:
dwDesiredAccess |= DWORD(GENERIC_WRITE)
case _O_RDWR:
dwDesiredAccess |= DWORD(GENERIC_READ) | DWORD(GENERIC_WRITE)
default:
break
}
bInheritHandle = WindowsBool((oflag & _O_NOINHERIT) == 0)
dwFlagsAndAttributes = 0
if (oflag & _O_SEQUENTIAL) != 0 {
dwFlagsAndAttributes |= DWORD(FILE_FLAG_SEQUENTIAL_SCAN)
}
if (oflag & _O_RANDOM) != 0 {
dwFlagsAndAttributes |= DWORD(FILE_FLAG_RANDOM_ACCESS)
}
if (oflag & _O_TEMPORARY) != 0 {
dwFlagsAndAttributes |= DWORD(FILE_FLAG_DELETE_ON_CLOSE)
}
if (oflag & _O_SHORT_LIVED) != 0 {
dwFlagsAndAttributes |= DWORD(FILE_ATTRIBUTE_TEMPORARY)
} else {
dwFlagsAndAttributes |= DWORD(FILE_ATTRIBUTE_NORMAL)
}
}
}
#endif
-487
View File
@@ -1,487 +0,0 @@
/*
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
*/
#if os(Linux)
// Ugh, this is really bad. For Darwin, we can at least rely on
// these values not changing much, but in theory they could change
// per Linux flavor or version (if no ABI)
// MARK: errno
@_alwaysEmitIntoClient
internal var _EPERM: CInt { 1 }
@_alwaysEmitIntoClient
internal var _ENOENT: CInt { 2 }
@_alwaysEmitIntoClient
internal var _ESRCH: CInt { 3 }
@_alwaysEmitIntoClient
internal var _EINTR: CInt { 4 }
@_alwaysEmitIntoClient
internal var _EIO: CInt { 5 }
@_alwaysEmitIntoClient
internal var _ENXIO: CInt { 6 }
@_alwaysEmitIntoClient
internal var _E2BIG: CInt { 7 }
@_alwaysEmitIntoClient
internal var _ENOEXEC: CInt { 8 }
@_alwaysEmitIntoClient
internal var _EBADF: CInt { 9 }
@_alwaysEmitIntoClient
internal var _ECHILD: CInt { 10 }
@_alwaysEmitIntoClient
internal var _EAGAIN: CInt { 11 }
@_alwaysEmitIntoClient
internal var _ENOMEM: CInt { 12 }
@_alwaysEmitIntoClient
internal var _EACCES: CInt { 13 }
@_alwaysEmitIntoClient
internal var _EFAULT: CInt { 14 }
@_alwaysEmitIntoClient
internal var _ENOTBLK: CInt { 15 }
@_alwaysEmitIntoClient
internal var _EBUSY: CInt { 16 }
@_alwaysEmitIntoClient
internal var _EEXIST: CInt { 17 }
@_alwaysEmitIntoClient
internal var _EXDEV: CInt { 18 }
@_alwaysEmitIntoClient
internal var _ENODEV: CInt { 19 }
@_alwaysEmitIntoClient
internal var _ENOTDIR: CInt { 20 }
@_alwaysEmitIntoClient
internal var _EISDIR: CInt { 21 }
@_alwaysEmitIntoClient
internal var _EINVAL: CInt { 22 }
@_alwaysEmitIntoClient
internal var _ENFILE: CInt { 23 }
@_alwaysEmitIntoClient
internal var _EMFILE: CInt { 24 }
@_alwaysEmitIntoClient
internal var _ENOTTY: CInt { 25 }
@_alwaysEmitIntoClient
internal var _ETXTBSY: CInt { 26 }
@_alwaysEmitIntoClient
internal var _EFBIG: CInt { 27 }
@_alwaysEmitIntoClient
internal var _ENOSPC: CInt { 28 }
@_alwaysEmitIntoClient
internal var _ESPIPE: CInt { 29 }
@_alwaysEmitIntoClient
internal var _EROFS: CInt { 30 }
@_alwaysEmitIntoClient
internal var _EMLINK: CInt { 31 }
@_alwaysEmitIntoClient
internal var _EPIPE: CInt { 32 }
@_alwaysEmitIntoClient
internal var _EDOM: CInt { 33 }
@_alwaysEmitIntoClient
internal var _ERANGE: CInt { 34 }
@_alwaysEmitIntoClient
internal var _EDEADLK: CInt { 35 }
@_alwaysEmitIntoClient
internal var _ENAMETOOLONG: CInt { 36 }
@_alwaysEmitIntoClient
internal var _ENOLCK: CInt { 37 }
@_alwaysEmitIntoClient
internal var _ENOSYS: CInt { 38 }
@_alwaysEmitIntoClient
internal var _ENOTEMPTY: CInt { 39 }
@_alwaysEmitIntoClient
internal var _ELOOP: CInt { 40 }
@_alwaysEmitIntoClient
internal var _EWOULDBLOCK: CInt { _EAGAIN }
@_alwaysEmitIntoClient
internal var _ENOMSG: CInt { 42 }
@_alwaysEmitIntoClient
internal var _EIDRM: CInt { 43 }
@_alwaysEmitIntoClient
internal var _ECHRNG: CInt { 44 }
@_alwaysEmitIntoClient
internal var _EL2NSYNC: CInt { 45 }
@_alwaysEmitIntoClient
internal var _EL3HLT: CInt { 46 }
@_alwaysEmitIntoClient
internal var _EL3RST: CInt { 47 }
@_alwaysEmitIntoClient
internal var _ELNRNG: CInt { 48 }
@_alwaysEmitIntoClient
internal var _EUNATCH: CInt { 49 }
@_alwaysEmitIntoClient
internal var _ENOCSI: CInt { 50 }
@_alwaysEmitIntoClient
internal var _EL2HLT: CInt { 51 }
@_alwaysEmitIntoClient
internal var _EBADE: CInt { 52 }
@_alwaysEmitIntoClient
internal var _EBADR: CInt { 53 }
@_alwaysEmitIntoClient
internal var _EXFULL: CInt { 54 }
@_alwaysEmitIntoClient
internal var _ENOANO: CInt { 55 }
@_alwaysEmitIntoClient
internal var _EBADRQC: CInt { 56 }
@_alwaysEmitIntoClient
internal var _EBADSLT: CInt { 57 }
@_alwaysEmitIntoClient
internal var _EDEADLOCK: CInt { _EDEADLK }
@_alwaysEmitIntoClient
internal var _EBFONT: CInt { 59 }
@_alwaysEmitIntoClient
internal var _ENOSTR: CInt { 60 }
@_alwaysEmitIntoClient
internal var _ENODATA: CInt { 61 }
@_alwaysEmitIntoClient
internal var _ETIME: CInt { 62 }
@_alwaysEmitIntoClient
internal var _ENOSR: CInt { 63 }
@_alwaysEmitIntoClient
internal var _ENONET: CInt { 64 }
@_alwaysEmitIntoClient
internal var _ENOPKG: CInt { 65 }
@_alwaysEmitIntoClient
internal var _EREMOTE: CInt { 66 }
@_alwaysEmitIntoClient
internal var _ENOLINK: CInt { 67 }
@_alwaysEmitIntoClient
internal var _EADV: CInt { 68 }
@_alwaysEmitIntoClient
internal var _ESRMNT: CInt { 69 }
@_alwaysEmitIntoClient
internal var _ECOMM: CInt { 70 }
@_alwaysEmitIntoClient
internal var _EPROTO: CInt { 71 }
@_alwaysEmitIntoClient
internal var _EMULTIHOP: CInt { 72 }
@_alwaysEmitIntoClient
internal var _EDOTDOT: CInt { 73 }
@_alwaysEmitIntoClient
internal var _EBADMSG: CInt { 74 }
@_alwaysEmitIntoClient
internal var _EOVERFLOW: CInt { 75 }
@_alwaysEmitIntoClient
internal var _ENOTUNIQ: CInt { 76 }
@_alwaysEmitIntoClient
internal var _EBADFD: CInt { 77 }
@_alwaysEmitIntoClient
internal var _EREMCHG: CInt { 78 }
@_alwaysEmitIntoClient
internal var _ELIBACC: CInt { 79 }
@_alwaysEmitIntoClient
internal var _ELIBBAD: CInt { 80 }
@_alwaysEmitIntoClient
internal var _ELIBSCN: CInt { 81 }
@_alwaysEmitIntoClient
internal var _ELIBMAX: CInt { 82 }
@_alwaysEmitIntoClient
internal var _ELIBEXEC: CInt { 83 }
@_alwaysEmitIntoClient
internal var _EILSEQ: CInt { 84 }
@_alwaysEmitIntoClient
internal var _ERESTART: CInt { 85 }
@_alwaysEmitIntoClient
internal var _ESTRPIPE: CInt { 86 }
@_alwaysEmitIntoClient
internal var _EUSERS: CInt { 87 }
@_alwaysEmitIntoClient
internal var _ENOTSOCK: CInt { 88 }
@_alwaysEmitIntoClient
internal var _EDESTADDRREQ: CInt { 89 }
@_alwaysEmitIntoClient
internal var _EMSGSIZE: CInt { 90 }
@_alwaysEmitIntoClient
internal var _EPROTOTYPE: CInt { 91 }
@_alwaysEmitIntoClient
internal var _ENOPROTOOPT: CInt { 92 }
@_alwaysEmitIntoClient
internal var _EPROTONOSUPPORT: CInt { 93 }
@_alwaysEmitIntoClient
internal var _ESOCKTNOSUPPORT: CInt { 94 }
@_alwaysEmitIntoClient
internal var _EOPNOTSUPP: CInt { 95 }
@_alwaysEmitIntoClient
internal var _ENOTSUP: CInt { _EOPNOTSUPP }
@_alwaysEmitIntoClient
internal var _EPFNOSUPPORT: CInt { 96 }
@_alwaysEmitIntoClient
internal var _EAFNOSUPPORT: CInt { 97 }
@_alwaysEmitIntoClient
internal var _EADDRINUSE: CInt { 98 }
@_alwaysEmitIntoClient
internal var _EADDRNOTAVAIL: CInt { 99 }
@_alwaysEmitIntoClient
internal var _ENETDOWN: CInt { 100 }
@_alwaysEmitIntoClient
internal var _ENETUNREACH: CInt { 101 }
@_alwaysEmitIntoClient
internal var _ENETRESET: CInt { 102 }
@_alwaysEmitIntoClient
internal var _ECONNABORTED: CInt { 103 }
@_alwaysEmitIntoClient
internal var _ECONNRESET: CInt { 104 }
@_alwaysEmitIntoClient
internal var _ENOBUFS: CInt { 105 }
@_alwaysEmitIntoClient
internal var _EISCONN: CInt { 106 }
@_alwaysEmitIntoClient
internal var _ENOTCONN: CInt { 107 }
@_alwaysEmitIntoClient
internal var _ESHUTDOWN: CInt { 108 }
@_alwaysEmitIntoClient
internal var _ETOOMANYREFS: CInt { 109 }
@_alwaysEmitIntoClient
internal var _ETIMEDOUT: CInt { 110 }
@_alwaysEmitIntoClient
internal var _ECONNREFUSED: CInt { 111 }
@_alwaysEmitIntoClient
internal var _EHOSTDOWN: CInt { 112 }
@_alwaysEmitIntoClient
internal var _EHOSTUNREACH: CInt { 113 }
@_alwaysEmitIntoClient
internal var _EALREADY: CInt { 114 }
@_alwaysEmitIntoClient
internal var _EINPROGRESS: CInt { 115 }
@_alwaysEmitIntoClient
internal var _ESTALE: CInt { 116 }
@_alwaysEmitIntoClient
internal var _EUCLEAN: CInt { 117 }
@_alwaysEmitIntoClient
internal var _ENOTNAM: CInt { 118 }
@_alwaysEmitIntoClient
internal var _ENAVAIL: CInt { 119 }
@_alwaysEmitIntoClient
internal var _EISNAM: CInt { 120 }
@_alwaysEmitIntoClient
internal var _EREMOTEIO: CInt { 121 }
@_alwaysEmitIntoClient
internal var _EDQUOT: CInt { 122 }
@_alwaysEmitIntoClient
internal var _ENOMEDIUM: CInt { 123 }
@_alwaysEmitIntoClient
internal var _EMEDIUMTYPE: CInt { 124 }
@_alwaysEmitIntoClient
internal var _ECANCELED: CInt { 125 }
@_alwaysEmitIntoClient
internal var _ENOKEY: CInt { 126 }
@_alwaysEmitIntoClient
internal var _EKEYEXPIRED: CInt { 127 }
@_alwaysEmitIntoClient
internal var _EKEYREVOKED: CInt { 128 }
@_alwaysEmitIntoClient
internal var _EKEYREJECTED: CInt { 129 }
@_alwaysEmitIntoClient
internal var _EOWNERDEAD: CInt { 130 }
@_alwaysEmitIntoClient
internal var _ENOTRECOVERABLE: CInt { 131 }
@_alwaysEmitIntoClient
internal var _ERFKILL: CInt { 132 }
@_alwaysEmitIntoClient
internal var _EHWPOISON: CInt { 133 }
// MARK: File Operations
@_alwaysEmitIntoClient
internal var _O_ACCMODE: CInt { 0o00000003 }
@_alwaysEmitIntoClient
internal var _O_RDONLY: CInt { 0o00000000 }
@_alwaysEmitIntoClient
internal var _O_WRONLY: CInt { 0o00000001 }
@_alwaysEmitIntoClient
internal var _O_RDWR: CInt { 0o00000002 }
@_alwaysEmitIntoClient
internal var _O_CREAT: CInt { 0o00000100 }
@_alwaysEmitIntoClient
internal var _O_EXCL: CInt { 0o00000200 }
@_alwaysEmitIntoClient
internal var _O_NOCTTY: CInt { 0o00000400 }
@_alwaysEmitIntoClient
internal var _O_TRUNC: CInt { 0o00001000 }
@_alwaysEmitIntoClient
internal var _O_APPEND: CInt { 0o00002000 }
@_alwaysEmitIntoClient
internal var _O_NONBLOCK: CInt { 0o00004000 }
@_alwaysEmitIntoClient
internal var _O_DSYNC: CInt { 0o00010000 }
@_alwaysEmitIntoClient
internal var _FASYNC: CInt { 0o00020000 }
@_alwaysEmitIntoClient
internal var _O_DIRECT: CInt { 0o00040000 }
@_alwaysEmitIntoClient
internal var _O_LARGEFILE: CInt { 0o00100000 }
@_alwaysEmitIntoClient
internal var _O_DIRECTORY: CInt { 0o00200000 }
@_alwaysEmitIntoClient
internal var _O_NOFOLLOW: CInt { 0o00400000 }
@_alwaysEmitIntoClient
internal var _O_NOATIME: CInt { 0o01000000 }
@_alwaysEmitIntoClient
internal var _O_CLOEXEC: CInt { 0o02000000 }
@_alwaysEmitIntoClient
internal var _SEEK_SET: CInt { 0 }
@_alwaysEmitIntoClient
internal var _SEEK_CUR: CInt { 1 }
@_alwaysEmitIntoClient
internal var _SEEK_END: CInt { 2 }
#endif
+377
View File
@@ -0,0 +1,377 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2022 - 2025 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
*/
#if SYSTEM_PACKAGE_DARWIN
import Darwin.Mach
@available(System 1.4.0, *)
public protocol MachPortRight {}
@available(System 1.4.0, *)
@inlinable
internal func _machPrecondition(
file: StaticString = #file,
line: UInt = #line,
_ body: @autoclosure () -> kern_return_t
) {
let kr = body()
let expected = KERN_SUCCESS
precondition(kr == expected, file: file, line: line)
}
@available(System 1.4.0, *)
@frozen
public enum Mach {
@available(System 1.4.0, *)
public struct Port<RightType: MachPortRight>: ~Copyable {
@usableFromInline
internal var _name: mach_port_name_t
@usableFromInline
internal var _context: mach_port_context_t
/// Transfer ownership of an existing unmanaged Mach port right into a
/// `Mach.Port` by name.
///
/// This initializer traps if `name` is `MACH_PORT_NULL`, or if `name` is
/// `MACH_PORT_DEAD` and the `RightType` is `Mach.ReceiveRight`.
///
/// If the type of the right does not match the `RightType` of the
/// `Mach.Port` being constructed, behavior is undefined.
///
/// The underlying port right will be automatically deallocated at the
/// end of the `Mach.Port` instance's lifetime.
///
/// This initializer makes a syscall to guard the right.
public init(name: mach_port_name_t) {
precondition(name != mach_port_name_t(MACH_PORT_NULL),
"Mach.Port cannot be initialized with MACH_PORT_NULL")
self._name = name
if RightType.self == ReceiveRight.self {
precondition(
_name != (0xFFFFFFFF as mach_port_name_t) /* MACH_PORT_DEAD */,
"Receive rights cannot be dead names"
)
let secret = mach_port_context_t(arc4random())
_machPrecondition(mach_port_guard(mach_task_self_, name, secret, 0))
self._context = secret
}
else {
self._context = 0
}
}
/// Borrow access to the port name in a block that can perform
/// non-consuming operations.
///
/// Take care when using this function; many operations consume rights,
/// and send-once rights are easily consumed.
///
/// If the right is consumed, behavior is undefined.
///
/// The body block may optionally return something, which will then be
/// returned to the caller of withBorrowedName.
@inlinable
public func withBorrowedName<ReturnType>(
body: (mach_port_name_t) -> ReturnType
) -> ReturnType {
return body(_name)
}
deinit {
if RightType.self == ReceiveRight.self {
precondition(
_name != (0xFFFFFFFF as mach_port_name_t) /* MACH_PORT_DEAD */,
"Receive rights cannot be dead names"
)
_machPrecondition(
mach_port_destruct(mach_task_self_, _name, 0, _context)
)
} else {
assert(
RightType.self == SendRight.self ||
RightType.self == SendOnceRight.self
)
_machPrecondition(mach_port_deallocate(mach_task_self_, _name))
}
}
}
/// Possible errors that can be thrown by Mach.Port operations.
public enum PortRightError : Error {
/// Returned when an operation cannot be completed, because the Mach
/// port right has become a dead name. This is caused by deallocation of the
/// receive right on the other end.
case deadName
}
/// The MachPortRight type used to manage a receive right.
@frozen
public struct ReceiveRight: MachPortRight {}
/// The MachPortRight type used to manage a send right.
@frozen
public struct SendRight: MachPortRight {}
/// The MachPortRight type used to manage a send-once right.
///
/// Send-once rights are the most restrictive type of Mach port rights.
/// They cannot create other rights, and are consumed upon use.
///
/// Upon destruction a send-once notification will be sent to the
/// receiving end.
@frozen
public struct SendOnceRight: MachPortRight {}
}
@available(System 1.4.0, *)
extension Mach.Port where RightType == Mach.ReceiveRight {
/// Transfer ownership of an existing, unmanaged, but already guarded,
/// Mach port right into a Mach.Port by name.
///
/// This initializer aborts if name is MACH_PORT_NULL.
///
/// If the type of the right does not match the type T of Mach.Port<T>
/// being constructed, the behavior is undefined.
///
/// The underlying port right will be automatically deallocated when
/// the Mach.Port object is destroyed.
public init(name: mach_port_name_t, context: mach_port_context_t) {
precondition(name != mach_port_name_t(MACH_PORT_NULL),
"Mach.Port cannot be initialized with MACH_PORT_NULL")
self._name = name
self._context = context
}
/// Allocate a new Mach port with a receive right, creating a
/// Mach.Port<Mach.ReceiveRight> to manage it.
///
/// This initializer will abort if the right could not be created.
/// Callers may assert that a valid right is always returned.
@inlinable
@available(System 1.4.0, *)
public init() {
var storage: mach_port_name_t = mach_port_name_t(MACH_PORT_NULL)
_machPrecondition(
mach_port_allocate(mach_task_self_, MACH_PORT_RIGHT_RECEIVE, &storage)
)
// name-only init will guard ReceiveRights
self.init(name: storage)
}
/// Transfer ownership of the underlying port right to the caller.
///
/// Returns a tuple containing the Mach port name representing the right,
/// and the context value used to guard the right.
///
/// This operation liberates the right from management by the Mach.Port,
/// and the underlying right will no longer be automatically deallocated.
///
/// After this function completes, the Mach.Port is destroyed and no longer
/// usable.
@inlinable
@available(System 1.4.0, *)
public consuming func relinquish(
) -> (name: mach_port_name_t, context: mach_port_context_t) {
let destructured = (name: _name, context: _context)
discard self
return destructured
}
/// Remove guard and transfer ownership of the underlying port right to
/// the caller.
///
/// Returns the Mach port name representing the right.
///
/// This operation liberates the right from management by the Mach.Port,
/// and the underlying right will no longer be automatically deallocated.
///
/// After this function completes, the Mach.Port is destroyed and no longer
/// usable.
///
/// This function makes a syscall to remove the guard from
/// Mach.ReceiveRights. Use relinquish() to avoid the syscall and extract
/// the context value along with the port name.
@inlinable
@available(System 1.4.0, *)
public consuming func unguardAndRelinquish() -> mach_port_name_t {
let (name, context) = self.relinquish()
_machPrecondition(mach_port_unguard(mach_task_self_, name, context))
return name
}
/// Borrow access to the port name in a block that can perform
/// non-consuming operations.
///
/// Take care when using this function; many operations consume rights.
///
/// If the right is consumed, behavior is undefined.
///
/// The body block may optionally return something, which will then be
/// returned to the caller of withBorrowedName.
@inlinable
@available(System 1.4.0, *)
public func withBorrowedName<ReturnType>(
body: (mach_port_name_t, mach_port_context_t) -> ReturnType
) -> ReturnType {
return body(_name, _context)
}
/// Create a send-once right for a given receive right.
///
/// This does not affect the makeSendCount of the receive right.
///
/// This function will abort if the right could not be created.
/// Callers may assert that a valid right is always returned.
@inlinable
@available(System 1.4.0, *)
public func makeSendOnceRight() -> Mach.Port<Mach.SendOnceRight> {
// send once rights do not coalesce
var newRight: mach_port_name_t = mach_port_name_t(MACH_PORT_NULL)
var newRightType: mach_port_type_t = MACH_PORT_TYPE_NONE
_machPrecondition(
mach_port_extract_right(
mach_task_self_,
_name,
mach_msg_type_name_t(MACH_MSG_TYPE_MAKE_SEND_ONCE),
&newRight,
&newRightType
)
)
// The value of newRight is validated by the Mach.Port initializer
precondition(newRightType == MACH_MSG_TYPE_MOVE_SEND_ONCE)
return Mach.Port(name: newRight)
}
/// Create a send right for a given receive right.
///
/// This increments the makeSendCount of the receive right.
///
/// This function will abort if the right could not be created.
/// Callers may assert that a valid right is always returned.
@inlinable
@available(System 1.4.0, *)
public func makeSendRight() -> Mach.Port<Mach.SendRight> {
let how = MACH_MSG_TYPE_MAKE_SEND
// name is the same because send and recv rights are coalesced
_machPrecondition(
mach_port_insert_right(
mach_task_self_, _name, _name, mach_msg_type_name_t(how)
)
)
return Mach.Port(name: _name)
}
/// Access the make-send count.
///
/// Each get/set of this property makes a syscall.
@inlinable
@available(System 1.4.0, *)
public var makeSendCount: mach_port_mscount_t {
get {
var status: mach_port_status = mach_port_status()
var size = mach_msg_type_number_t(
MemoryLayout<mach_port_status>.size / MemoryLayout<natural_t>.size
)
withUnsafeMutablePointer(to: &status) {
[ _name = self._name ] in
let status = UnsafeMutableBufferPointer(start: $0, count: 1)
status.withMemoryRebound(to: integer_t.self) {
let info = $0.baseAddress
_machPrecondition(
mach_port_get_attributes(
mach_task_self_, _name, MACH_PORT_RECEIVE_STATUS, info, &size
)
)
}
}
return status.mps_mscount
}
set {
_machPrecondition(mach_port_set_mscount(mach_task_self_, _name, newValue))
}
}
}
@available(System 1.4.0, *)
extension Mach.Port where RightType == Mach.SendRight {
/// Transfer ownership of the underlying port right to the caller.
///
/// Returns the Mach port name representing the right.
///
/// This operation liberates the right from management by the Mach.Port,
/// and the underlying right will no longer be automatically deallocated.
///
/// After this function completes, the Mach.Port is destroyed and no longer
/// usable.
@inlinable
public consuming func relinquish() -> mach_port_name_t {
let name = _name
discard self
return name
}
/// Create another send right from a given send right.
///
/// This does not affect the makeSendCount of the receive right.
///
/// If the send right being copied has become a dead name, meaning the
/// receiving side has been deallocated, then copySendRight() will throw
/// a Mach.PortRightError.deadName error.
@inlinable
@available(System 1.4.0, *)
public func copySendRight() throws -> Mach.Port<Mach.SendRight> {
let how = MACH_MSG_TYPE_COPY_SEND
// name is the same because send rights are coalesced
let kr = mach_port_insert_right(
mach_task_self_, _name, _name, mach_msg_type_name_t(how)
)
if kr == KERN_INVALID_NAME || kr == KERN_INVALID_CAPABILITY {
throw Mach.PortRightError.deadName
}
_machPrecondition(kr)
return Mach.Port(name: _name)
}
}
@available(System 1.4.0, *)
extension Mach.Port where RightType == Mach.SendOnceRight {
/// Transfer ownership of the underlying port right to the caller.
///
/// Returns the Mach port name representing the right.
///
/// This operation liberates the right from management by the Mach.Port,
/// and the underlying right will no longer be automatically deallocated.
///
/// After this function completes, the Mach.Port is destroyed and no longer
/// usable.
@inlinable
@available(System 1.4.0, *)
public consuming func relinquish() -> mach_port_name_t {
let name = _name
discard self
return name
}
}
#endif
-20
View File
@@ -1,20 +0,0 @@
/*
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
*/
@_implementationOnly import SystemInternals
// Public typealiases that can't be reexported from SystemInternals
/// The C `mode_t` type.
#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
public typealias CModeT = UInt16
#else
public typealias CModeT = UInt32
#endif
+197
View File
@@ -0,0 +1,197 @@
/*
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
*/
@available(System 0.0.2, *)
extension String {
/// Creates a string by interpreting the null-terminated platform string as
/// UTF-8 on Unix and UTF-16 on Windows.
///
/// - Parameter platformString: The null-terminated platform string to be
/// interpreted as `CInterop.PlatformUnicodeEncoding`.
///
/// If the content of the platform string isn't well-formed Unicode,
/// this initializer replaces invalid bytes with U+FFFD.
/// This means that, depending on the semantics of the specific platform,
/// conversion to a string and back might result in a value that's different
/// from the original platform string.
@_disfavoredOverload
public init(platformString: UnsafePointer<CInterop.PlatformChar>) {
self.init(_errorCorrectingPlatformString: platformString)
}
/// Creates a string by interpreting the null-terminated platform string as
/// UTF-8 on Unix and UTF-16 on Windows.
///
/// - Parameter platformString: The null-terminated platform string to be
/// interpreted as `CInterop.PlatformUnicodeEncoding`.
///
/// - Note It is a precondition that `platformString` must be null-terminated.
/// The absence of a null byte will trigger a runtime error.
///
/// If the content of the platform string isn't well-formed Unicode,
/// this initializer replaces invalid bytes with U+FFFD.
/// This means that, depending on the semantics of the specific platform,
/// conversion to a string and back might result in a value that's different
/// from the original platform string.
@inlinable
@_alwaysEmitIntoClient
public init(platformString: [CInterop.PlatformChar]) {
guard let _ = platformString.firstIndex(of: 0) else {
fatalError(
"input of String.init(platformString:) must be null-terminated"
)
}
self = platformString.withUnsafeBufferPointer {
String(platformString: $0.baseAddress!)
}
}
@inlinable
@_alwaysEmitIntoClient
@available(*, deprecated, message: "Use String.init(_ scalar: Unicode.Scalar)")
public init(platformString: inout CInterop.PlatformChar) {
guard platformString == 0 else {
fatalError(
"input of String.init(platformString:) must be null-terminated"
)
}
self = ""
}
@inlinable
@_alwaysEmitIntoClient
@available(*, deprecated, message: "Use a copy of the String argument")
public init(platformString: String) {
if let nullLoc = platformString.firstIndex(of: "\0") {
self = String(platformString[..<nullLoc])
} else {
self = platformString
}
}
/// Creates a string by interpreting the null-terminated platform string as
/// UTF-8 on Unix and UTF-16 on Windows.
///
/// - Parameter platformString: The null-terminated platform string to be
/// interpreted as `CInterop.PlatformUnicodeEncoding`.
///
/// If the contents of the platform string isn't well-formed Unicode,
/// this initializer returns `nil`.
public init?(
validatingPlatformString platformString: UnsafePointer<CInterop.PlatformChar>
) {
self.init(_platformString: platformString)
}
/// Creates a string by interpreting the null-terminated platform string as
/// UTF-8 on Unix and UTF-16 on Windows.
///
/// - Parameter platformString: The null-terminated platform string to be
/// interpreted as `CInterop.PlatformUnicodeEncoding`.
///
/// - Note It is a precondition that `platformString` must be null-terminated.
/// The absence of a null byte will trigger a runtime error.
///
/// If the contents of the platform string isn't well-formed Unicode,
/// this initializer returns `nil`.
@inlinable
@_alwaysEmitIntoClient
public init?(
validatingPlatformString platformString: [CInterop.PlatformChar]
) {
guard let _ = platformString.firstIndex(of: 0) else {
fatalError(
"input of String.init(validatingPlatformString:) must be null-terminated"
)
}
guard let string = platformString.withUnsafeBufferPointer({
String(validatingPlatformString: $0.baseAddress!)
}) else {
return nil
}
self = string
}
@inlinable
@_alwaysEmitIntoClient
@available(*, deprecated, message: "Use String(_ scalar: Unicode.Scalar)")
public init?(
validatingPlatformString platformString: inout CInterop.PlatformChar
) {
guard platformString == 0 else {
fatalError(
"input of String.init(validatingPlatformString:) must be null-terminated"
)
}
self = ""
}
@inlinable
@_alwaysEmitIntoClient
@available(*, deprecated, message: "Use a copy of the String argument")
public init?(
validatingPlatformString platformString: String
) {
if let nullLoc = platformString.firstIndex(of: "\0") {
self = String(platformString[..<nullLoc])
} else {
self = platformString
}
}
/// Calls the given closure with a pointer to the contents of the string,
/// represented as a null-terminated platform string.
///
/// - Parameter body: A closure with a pointer parameter
/// that points to a null-terminated platform string.
/// If `body` has a return value,
/// that value is also used as the return value for this method.
/// - Returns: The return value, if any, of the `body` closure parameter.
///
/// The pointer passed as an argument to `body` is valid
/// only during the execution of this method.
/// Don't try to store the pointer for later use.
public func withPlatformString<Result>(
_ body: (UnsafePointer<CInterop.PlatformChar>) throws(SystemError) -> Result
) throws(SystemError) -> Result {
try _withPlatformString(body)
}
}
@available(System 0.0.2, *)
extension CInterop.PlatformChar {
internal var _platformCodeUnit: CInterop.PlatformUnicodeEncoding.CodeUnit {
#if os(Windows)
return self
#else
return CInterop.PlatformUnicodeEncoding.CodeUnit(bitPattern: self)
#endif
}
}
@available(System 0.0.2, *)
extension CInterop.PlatformUnicodeEncoding.CodeUnit {
internal var _platformChar: CInterop.PlatformChar {
#if os(Windows)
return self
#else
return CInterop.PlatformChar(bitPattern: self)
#endif
}
}
internal protocol _PlatformStringable {
func _withPlatformString<Result>(
_ body: (UnsafePointer<CInterop.PlatformChar>) throws(SystemError) -> Result
) throws(SystemError) -> Result
init?(_platformString: UnsafePointer<CInterop.PlatformChar>)
}
extension String: _PlatformStringable {}
+343
View File
@@ -0,0 +1,343 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 - 2024 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
*/
// A platform-native character representation, currently used for file paths
internal struct SystemChar:
RawRepresentable, Sendable, Comparable, Hashable {
internal typealias RawValue = CInterop.PlatformChar
internal var rawValue: RawValue
internal init(rawValue: RawValue) { self.rawValue = rawValue }
internal init(_ rawValue: RawValue) { self.init(rawValue: rawValue) }
static func < (lhs: SystemChar, rhs: SystemChar) -> Bool {
lhs.rawValue < rhs.rawValue
}
}
#if !$Embedded
extension SystemChar: Codable {}
#endif // !$Embedded
extension SystemChar {
internal init(ascii: Unicode.Scalar) {
self.init(rawValue: numericCast(UInt8(ascii: ascii)))
}
internal init(codeUnit: CInterop.PlatformUnicodeEncoding.CodeUnit) {
self.init(rawValue: codeUnit._platformChar)
}
internal static var null: SystemChar { SystemChar(0x0) }
internal static var slash: SystemChar { SystemChar(ascii: "/") }
internal static var backslash: SystemChar { SystemChar(ascii: #"\"#) }
internal static var dot: SystemChar { SystemChar(ascii: ".") }
internal static var colon: SystemChar { SystemChar(ascii: ":") }
internal static var question: SystemChar { SystemChar(ascii: "?") }
internal var codeUnit: CInterop.PlatformUnicodeEncoding.CodeUnit {
rawValue._platformCodeUnit
}
internal var asciiScalar: Unicode.Scalar? {
guard isASCII else { return nil }
return Unicode.Scalar(UInt8(truncatingIfNeeded: rawValue))
}
internal var isASCII: Bool {
(0...0x7F).contains(rawValue)
}
internal var isLetter: Bool {
guard isASCII else { return false }
let asciiRaw: UInt8 = numericCast(rawValue)
return (UInt8(ascii: "a") ... UInt8(ascii: "z")).contains(asciiRaw) ||
(UInt8(ascii: "A") ... UInt8(ascii: "Z")).contains(asciiRaw)
}
}
// A platform-native string representation, currently for file paths
//
// Always null-terminated.
internal struct SystemString: Sendable {
internal typealias Storage = [SystemChar]
internal var nullTerminatedStorage: Storage
}
extension SystemString {
internal init() {
self.nullTerminatedStorage = [.null]
_invariantCheck()
}
internal var length: Int {
let len = nullTerminatedStorage.count - 1
assert(len == self.count)
return len
}
// Common funnel point. Ensure all non-empty inits go here.
internal init(nullTerminated storage: Storage) {
self.nullTerminatedStorage = storage
_invariantCheck()
}
// Ensures that result is null-terminated
internal init<C: Collection>(_ chars: C) where C.Element == SystemChar {
var rawChars = Storage(chars)
if rawChars.last != .null {
rawChars.append(.null)
}
self.init(nullTerminated: rawChars)
}
}
extension SystemString {
fileprivate func _invariantsSatisfied() -> Bool {
guard !nullTerminatedStorage.isEmpty else { return false }
guard nullTerminatedStorage.last! == .null else { return false }
guard nullTerminatedStorage.firstIndex(of: .null) == length else {
return false
}
return true
}
fileprivate func _invariantCheck() {
#if DEBUG
precondition(_invariantsSatisfied())
#endif // DEBUG
}
}
extension SystemString: RandomAccessCollection, MutableCollection {
internal typealias Element = SystemChar
internal typealias Index = Storage.Index
internal typealias Indices = Range<Index>
internal var startIndex: Index {
nullTerminatedStorage.startIndex
}
internal var endIndex: Index {
nullTerminatedStorage.index(before: nullTerminatedStorage.endIndex)
}
internal subscript(position: Index) -> SystemChar {
_read {
precondition(position >= startIndex && position <= endIndex)
yield nullTerminatedStorage[position]
}
set(newValue) {
precondition(position >= startIndex && position <= endIndex)
nullTerminatedStorage[position] = newValue
_invariantCheck()
}
}
}
extension SystemString: RangeReplaceableCollection {
internal mutating func replaceSubrange<C: Collection>(
_ subrange: Range<Index>, with newElements: C
) where C.Element == SystemChar {
defer { _invariantCheck() }
nullTerminatedStorage.replaceSubrange(subrange, with: newElements)
}
internal mutating func reserveCapacity(_ n: Int) {
defer { _invariantCheck() }
nullTerminatedStorage.reserveCapacity(1 + n)
}
internal func withContiguousStorageIfAvailable<R>(
_ body: (UnsafeBufferPointer<SystemChar>) throws -> R
) rethrows -> R? {
// Do not include the null terminator, it is outside the Collection
try nullTerminatedStorage.withContiguousStorageIfAvailable {
try body(.init(start: $0.baseAddress, count: $0.count-1))
}
}
internal mutating func withContiguousMutableStorageIfAvailable<R>(
_ body: (inout UnsafeMutableBufferPointer<SystemChar>) throws -> R
) rethrows -> R? {
defer { _invariantCheck() }
// Do not include the null terminator, it is outside the Collection
return try nullTerminatedStorage.withContiguousMutableStorageIfAvailable {
var buffer = UnsafeMutableBufferPointer<SystemChar>(
start: $0.baseAddress, count: $0.count-1
)
return try body(&buffer)
}
}
}
extension SystemString: Hashable {}
#if !$Embedded
extension SystemString: Codable {
// Encoder is synthesized; it probably should have been explicit and used
// a single-value container, but making that change now is somewhat risky.
// Decoder is written explicitly to ensure that we validate invariants on
// untrusted input.
public init(from decoder: any Decoder) throws {
let container = try decoder.container(keyedBy: CodingKeys.self)
self.nullTerminatedStorage = try container.decode(
Storage.self, forKey: .nullTerminatedStorage
)
guard _invariantsSatisfied() else {
throw DecodingError.dataCorruptedError(
forKey: .nullTerminatedStorage,
in: container,
debugDescription:
"Encoding does not satisfy the invariants of SystemString"
)
}
}
}
#endif // !$Embedded
extension SystemString {
internal func withNullTerminatedSystemChars<T>(
_ f: (UnsafeBufferPointer<SystemChar>) throws -> T
) rethrows -> T {
try nullTerminatedStorage.withUnsafeBufferPointer(f)
}
// withCodeUnits does not include the null terminator
internal func withCodeUnits<T>(
_ f: (UnsafeBufferPointer<CInterop.PlatformUnicodeEncoding.CodeUnit>) throws -> T
) rethrows -> T {
try withNullTerminatedSystemChars {
try $0.withMemoryRebound(to: CInterop.PlatformUnicodeEncoding.CodeUnit.self) {
assert($0.last == .zero)
return try f(.init(start: $0.baseAddress, count: $0.count&-1))
}
}
}
}
extension Slice where Base == SystemString {
internal func withCodeUnits<T>(
_ f: (UnsafeBufferPointer<CInterop.PlatformUnicodeEncoding.CodeUnit>) throws -> T
) rethrows -> T {
try base.withCodeUnits {
try f(UnsafeBufferPointer(rebasing: $0[indices]))
}
}
internal var string: String {
withCodeUnits {
String(decoding: $0, as: CInterop.PlatformUnicodeEncoding.self)
}
}
internal func withPlatformString<T>(
_ f: (UnsafePointer<CInterop.PlatformChar>) throws -> T
) rethrows -> T {
// FIXME: avoid allocation if we're at the end
return try SystemString(self).withPlatformString(f)
}
}
extension String {
internal init(decoding str: SystemString) {
// TODO: Can avoid extra strlen
self = str.withPlatformString {
String(platformString: $0)
}
}
internal init?(validating str: SystemString) {
// TODO: Can avoid extra strlen
guard let str = str.withPlatformString(String.init(validatingPlatformString:))
else { return nil }
self = str
}
}
extension SystemString: ExpressibleByStringLiteral {
internal init(stringLiteral: String) {
self.init(stringLiteral)
}
internal init(_ string: String) {
// TODO: can avoid extra strlen
self = string.withPlatformString {
SystemString(platformString: $0)
}
}
}
extension SystemString: CustomStringConvertible, CustomDebugStringConvertible {
internal var string: String {
self.withCodeUnits {
String(decoding: $0, as: CInterop.PlatformUnicodeEncoding.self)
}
}
internal var description: String { string }
internal var debugDescription: String { description.debugDescription }
}
extension SystemString {
/// Creates a system string by copying bytes from a null-terminated platform string.
///
/// - Parameter platformString: A pointer to a null-terminated platform string.
internal init(platformString: UnsafePointer<CInterop.PlatformChar>) {
let count = 1 + system_platform_strlen(platformString)
// TODO: Is this the right way?
let chars: Array<SystemChar> = platformString.withMemoryRebound(
to: SystemChar.self, capacity: count
) {
let bufPtr = UnsafeBufferPointer(start: $0, count: count)
return Array(bufPtr)
}
self.init(nullTerminated: chars)
}
/// Calls the given closure with a pointer to the contents of the sytem string,
/// represented as a null-terminated platform string.
///
/// - Parameter body: A closure with a pointer parameter
/// that points to a null-terminated platform string.
/// If `body` has a return value,
/// that value is also used as the return value for this method.
/// - Returns: The return value, if any, of the `body` closure parameter.
///
/// The pointer passed as an argument to `body` is valid
/// only during the execution of this method.
/// Don't try to store the pointer for later use.
internal func withPlatformString<T>(
_ f: (UnsafePointer<CInterop.PlatformChar>) throws -> T
) rethrows -> T {
try withNullTerminatedSystemChars { chars in
let length = chars.count * MemoryLayout<SystemChar>.stride
return try chars.baseAddress!.withMemoryRebound(
to: CInterop.PlatformChar.self,
capacity: length / MemoryLayout<CInterop.PlatformChar>.stride
) { pointer in
assert(pointer[self.count] == 0)
return try f(pointer)
}
}
}
}
// TODO: SystemString should use a COW-interchangable storage form rather
// than array, so you could "borrow" the storage from a non-bridged String
// or Data or whatever
+117
View File
@@ -0,0 +1,117 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 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
*/
extension Array where Element == String {
internal typealias CStr = UnsafePointer<CChar>?
/// Call `body` with a buffer of `UnsafePointer<CChar>?` values,
/// suitable for passing to a C function that expects a C string array.
/// The buffer is guaranteed to be followed by an extra storage slot
/// containing a null pointer. (For C functions that expect an array
/// terminated with a null pointer.)
///
/// This function is careful not to heap allocate memory unless there are
/// too many strings, or if it needs to copy too much character data.
internal func _withCStringArray<R>(
_ body: (UnsafeBufferPointer<UnsafePointer<CChar>?>) throws -> R
) rethrows -> R {
if self.count == 0 {
// Fast path: empty array.
let p: CStr = nil
return try Swift.withUnsafePointer(to: p) { array in
try body(UnsafeBufferPointer(start: array, count: 0))
}
}
#if SYSTEM_OS_BUILD // String._guts isn't accessible from SwiftPM or CMake
if self.count == 1, self[0]._guts._isLargeZeroTerminatedContiguousUTF8 {
// Fast path: Single fast string.
let start = self[0]._guts._largeContiguousUTF8CodeUnits.baseAddress!
var p: (CStr, CStr) = (
UnsafeRawPointer(start).assumingMemoryBound(to: CChar.self),
nil
)
return try Swift.withUnsafeBytes(of: &p) { buffer in
let start = buffer.baseAddress!.assumingMemoryBound(to: CStr.self)
return try body(UnsafeBufferPointer(start: start, count: 1))
}
}
#endif
// We need to create a buffer for the C array.
return try _withStackBuffer(
capacity: (self.count + 1) * MemoryLayout<CStr>.stride
) { array in
let array = array.bindMemory(to: CStr.self)
// Calculate number of bytes we need for character storage
let bytes = self.reduce(into: 0) { count, string in
#if SYSTEM_OS_BUILD
if string._guts._isLargeZeroTerminatedContiguousUTF8 { return }
#endif
count += string.utf8.count + 1 // Plus one for terminating NUL
}
#if SYSTEM_OS_BUILD
if bytes == 0 {
// Fast path: we only contain strings with stable null-terminated storage
for i in self.indices {
let string = self[i]
precondition(string._guts._isLargeZeroTerminatedContiguousUTF8)
let address = string._guts._largeContiguousUTF8CodeUnits.baseAddress!
array[i] = UnsafeRawPointer(address).assumingMemoryBound(to: CChar.self)
}
array[self.count] = nil
return try body(UnsafeBufferPointer(rebasing: array.dropLast()))
}
#endif
return try _withStackBuffer(capacity: bytes) { chars in
var chars = chars
for i in self.indices {
let (cstr, scratchUsed) = self[i]._getCStr(with: chars)
array[i] = cstr.assumingMemoryBound(to: CChar.self)
chars = .init(rebasing: chars[scratchUsed...])
}
array[self.count] = nil
return try body(UnsafeBufferPointer(rebasing: array.dropLast()))
}
}
}
}
extension String {
fileprivate func _getCStr(
with scratch: UnsafeMutableRawBufferPointer
) -> (cstr: UnsafeRawPointer, scratchUsed: Int) {
#if SYSTEM_OS_BUILD
if _guts._isLargeZeroTerminatedContiguousUTF8 {
// This is a wonderful string, we can just use its storage address.
let address = _guts._largeContiguousUTF8CodeUnits.baseAddress!
return (UnsafeRawPointer(address), 0)
}
#endif
let r: (UnsafeRawPointer, Int)? = self.utf8.withContiguousStorageIfAvailable { source in
// This is a somewhat okay string -- we need to use memcpy.
precondition(source.count <= scratch.count)
let start = scratch.baseAddress!
start.copyMemory(from: source.baseAddress!, byteCount: source.count)
start.storeBytes(of: 0, toByteOffset: source.count, as: UInt8.self)
return (UnsafeRawPointer(start), source.count + 1)
}
if let r = r { return r }
// What a horrible string; we need to copy individual bytes.
precondition(self.utf8.count <= scratch.count)
var c = 0
for byte in self.utf8 {
scratch[c] = byte
c += 1
}
scratch[c] = 0
c += 1
return (UnsafeRawPointer(scratch.baseAddress!), c)
}
}
+81 -9
View File
@@ -1,28 +1,28 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 Apple Inc. and the Swift System project authors
Copyright (c) 2020 - 2021 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
*/
// Results in errno if i == -1
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
internal func valueOrErrno<I: FixedWidthInteger>(
@available(System 0.0.1, *)
private func valueOrErrno<I: FixedWidthInteger>(
_ i: I
) -> Result<I, Errno> {
i == -1 ? .failure(Errno.current) : .success(i)
}
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
internal func nothingOrErrno<I: FixedWidthInteger>(
@available(System 0.0.1, *)
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, *)
@available(System 0.0.1, *)
internal func valueOrErrno<I: FixedWidthInteger>(
retryOnInterrupt: Bool, _ f: () -> I
) -> Result<I, Errno> {
@@ -36,17 +36,34 @@ internal func valueOrErrno<I: FixedWidthInteger>(
} while true
}
@available(System 0.0.1, *)
internal func nothingOrErrno<I: FixedWidthInteger>(
retryOnInterrupt: Bool, _ f: () -> I
) -> Result<(), Errno> {
valueOrErrno(retryOnInterrupt: retryOnInterrupt, f).map { _ in () }
}
#if !$Embedded
// Run a precondition for debug client builds
internal func _debugPrecondition(
_ condition: @autoclosure () -> Bool, _ message: StaticString = StaticString(),
_ condition: @autoclosure () -> Bool,
_ message: StaticString = StaticString(),
file: StaticString = #file, line: UInt = #line
) {
// Only check in debug mode.
if _slowPath(_isDebugAssertConfiguration()) { precondition(condition()) }
if _slowPath(_isDebugAssertConfiguration()) {
precondition(
condition(), String(describing: message), file: file, line: line)
}
}
#endif // !$Embedded
extension OpaquePointer {
internal var _isNULL: Bool { OpaquePointer(bitPattern: Int(bitPattern: self)) == nil }
internal var _isNULL: Bool {
OpaquePointer(bitPattern: Int(bitPattern: self)) == nil
}
}
extension Sequence {
@@ -94,3 +111,58 @@ extension OptionSet {
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 }
}
}
}
internal func _withOptionalUnsafePointerOrNull<T, R>(
to value: T?,
_ body: (UnsafePointer<T>?) throws -> R
) rethrows -> R {
guard let value = value else {
return try body(nil)
}
return try withUnsafePointer(to: value, body)
}
/// Calls `body` with a temporary buffer of the indicated size,
/// possibly stack-allocated.
internal func _withStackBuffer<R>(
capacity: Int,
_ body: (UnsafeMutableRawBufferPointer) throws -> R
) rethrows -> R {
typealias StackStorage = (
UInt64, UInt64, UInt64, UInt64,
UInt64, UInt64, UInt64, UInt64,
UInt64, UInt64, UInt64, UInt64,
UInt64, UInt64, UInt64, UInt64
)
if capacity > MemoryLayout<StackStorage>.size {
var buffer = _RawBuffer(minimumCapacity: capacity)
return try buffer.withUnsafeMutableBytes { buffer in
try body(.init(rebasing: buffer[..<capacity]))
}
} else {
var storage: StackStorage = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
return try withUnsafeMutableBytes(of: &storage) { buffer in
try body(.init(rebasing: buffer[..<capacity]))
}
}
}
+73
View File
@@ -0,0 +1,73 @@
/*
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
*/
// TODO: Below should return an optional of what was eaten
extension Slice where Element: Equatable {
internal mutating func _eat(if p: (Element) -> Bool) -> Element? {
guard let s = self.first, p(s) else { return nil }
self = self.dropFirst()
return s
}
internal mutating func _eat(_ e: Element) -> Element? {
_eat(if: { $0 == e })
}
internal mutating func _eat(asserting e: Element) {
let p = _eat(e)
assert(p != nil)
}
internal mutating func _eat(count c: Int) -> Slice {
defer { self = self.dropFirst(c) }
return self.prefix(c)
}
internal mutating func _eatSequence<C: Collection>(_ es: C) -> Slice?
where C.Element == Element
{
guard self.starts(with: es) else { return nil }
return _eat(count: es.count)
}
internal mutating func _eatUntil(_ idx: Index) -> Slice {
precondition(idx >= startIndex && idx <= endIndex)
defer { self = self[idx...] }
return self[..<idx]
}
internal mutating func _eatThrough(_ idx: Index) -> Slice {
precondition(idx >= startIndex && idx <= endIndex)
guard idx != endIndex else {
defer { self = self[endIndex ..< endIndex] }
return self
}
defer { self = self[index(after: idx)...] }
return self[...idx]
}
// If `e` is present, eat up to first occurrence of `e`
internal mutating func _eatUntil(_ e: Element) -> Slice? {
guard let idx = self.firstIndex(of: e) else { return nil }
return _eatUntil(idx)
}
// If `e` is present, eat up to and through first occurrence of `e`
internal mutating func _eatThrough(_ e: Element) -> Slice? {
guard let idx = self.firstIndex(of: e) else { return nil }
return _eatThrough(idx)
}
// Eat any elements from the front matching the predicate
internal mutating func _eatWhile(_ p: (Element) -> Bool) -> Slice? {
let idx = firstIndex(where: { !p($0) }) ?? endIndex
guard idx != startIndex else { return nil }
return _eatUntil(idx)
}
}
-91
View File
@@ -1,91 +0,0 @@
/*
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
*/
import CSystem
// TODO: Should CSystem just include all the header files we need?
#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
import Darwin
#elseif os(Linux) || os(FreeBSD) || os(Android)
import Glibc
#else
#error("Unsupported Platform")
#endif
public typealias COffT = off_t
// MARK: syscalls and variables
#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
public var system_errno: CInt {
get { Darwin.errno }
set { Darwin.errno = newValue }
}
#else
public var system_errno: CInt {
get { Glibc.errno }
set { Glibc.errno = newValue }
}
#endif
public func system_open(_ path: UnsafePointer<CChar>, _ oflag: Int32) -> CInt {
open(path, oflag)
}
public func system_open(
_ path: UnsafePointer<CChar>, _ oflag: Int32, _ mode: mode_t
) -> CInt {
open(path, oflag, mode)
}
public func system_close(_ fd: Int32) -> Int32 {
close(fd)
}
public func system_read(
_ fd: Int32, _ buf: UnsafeMutableRawPointer!, _ nbyte: Int
) -> Int {
read(fd, buf, nbyte)
}
public func system_pread(
_ fd: Int32, _ buf: UnsafeMutableRawPointer!, _ nbyte: Int, _ offset: off_t
) -> Int {
pread(fd, buf, nbyte, offset)
}
public func system_lseek(
_ fd: Int32, _ off: off_t, _ whence: Int32
) -> off_t {
lseek(fd, off, whence)
}
public func system_write(
_ fd: Int32, _ buf: UnsafeRawPointer!, _ nbyte: Int
) -> Int {
write(fd, buf, nbyte)
}
public func system_pwrite(
_ fd: Int32, _ buf: UnsafeRawPointer!, _ nbyte: Int, _ offset: off_t
) -> Int {
pwrite(fd, buf, nbyte, offset)
}
// MARK: C stdlib decls
public func system_strerror(_ __errnum: Int32) -> UnsafeMutablePointer<Int8>! {
strerror(__errnum)
}
public func system_strlen(_ s: UnsafePointer<Int8>) -> Int {
strlen(s)
}
+78 -13
View File
@@ -1,16 +1,25 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 Apple Inc. and the Swift System project authors
Copyright (c) 2020 - 2025 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
*/
import XCTest
import SystemPackage
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
#if SYSTEM_PACKAGE
import SystemPackage
#else
import System
#endif
#if os(Windows)
import WinSDK
#endif
@available(System 0.0.1, *)
final class ErrnoTest: XCTestCase {
func testConstants() {
XCTAssert(EPERM == Errno.notPermitted.rawValue)
@@ -27,7 +36,9 @@ final class ErrnoTest: XCTestCase {
XCTAssert(ENOMEM == Errno.noMemory.rawValue)
XCTAssert(EACCES == Errno.permissionDenied.rawValue)
XCTAssert(EFAULT == Errno.badAddress.rawValue)
#if !os(Windows) && !os(WASI)
XCTAssert(ENOTBLK == Errno.notBlockDevice.rawValue)
#endif
XCTAssert(EBUSY == Errno.resourceBusy.rawValue)
XCTAssert(EEXIST == Errno.fileExists.rawValue)
XCTAssert(EXDEV == Errno.improperLink.rawValue)
@@ -37,8 +48,10 @@ final class ErrnoTest: XCTestCase {
XCTAssert(EINVAL == Errno.invalidArgument.rawValue)
XCTAssert(ENFILE == Errno.tooManyOpenFilesInSystem.rawValue)
XCTAssert(EMFILE == Errno.tooManyOpenFiles.rawValue)
#if !os(Windows)
XCTAssert(ENOTTY == Errno.inappropriateIOCTLForDevice.rawValue)
XCTAssert(ETXTBSY == Errno.textFileBusy.rawValue)
#endif
XCTAssert(EFBIG == Errno.fileTooLarge.rawValue)
XCTAssert(ENOSPC == Errno.noSpace.rawValue)
XCTAssert(ESPIPE == Errno.illegalSeek.rawValue)
@@ -56,9 +69,17 @@ final class ErrnoTest: XCTestCase {
XCTAssert(EPROTOTYPE == Errno.protocolWrongTypeForSocket.rawValue)
XCTAssert(ENOPROTOOPT == Errno.protocolNotAvailable.rawValue)
XCTAssert(EPROTONOSUPPORT == Errno.protocolNotSupported.rawValue)
XCTAssert(ESOCKTNOSUPPORT == Errno.socketTypeNotSupported.rawValue)
#if os(Windows)
XCTAssert(WSAESOCKTNOSUPPORT == Errno.socketTypeNotSupported.rawValue)
XCTAssert(WSAEOPNOTSUPP == Errno.notSupported.rawValue)
XCTAssert(WSAEPFNOSUPPORT == Errno.protocolFamilyNotSupported.rawValue)
#else
XCTAssert(ENOTSUP == Errno.notSupported.rawValue)
#if !os(WASI)
XCTAssert(ESOCKTNOSUPPORT == Errno.socketTypeNotSupported.rawValue)
XCTAssert(EPFNOSUPPORT == Errno.protocolFamilyNotSupported.rawValue)
#endif
#endif
XCTAssert(EAFNOSUPPORT == Errno.addressFamilyNotSupported.rawValue)
XCTAssert(EADDRINUSE == Errno.addressInUse.rawValue)
XCTAssert(EADDRNOTAVAIL == Errno.addressNotAvailable.rawValue)
@@ -70,24 +91,40 @@ final class ErrnoTest: XCTestCase {
XCTAssert(ENOBUFS == Errno.noBufferSpace.rawValue)
XCTAssert(EISCONN == Errno.socketIsConnected.rawValue)
XCTAssert(ENOTCONN == Errno.socketNotConnected.rawValue)
#if os(Windows)
XCTAssert(WSAESHUTDOWN == Errno.socketShutdown.rawValue)
#elseif !os(WASI)
XCTAssert(ESHUTDOWN == Errno.socketShutdown.rawValue)
#endif
XCTAssert(ETIMEDOUT == Errno.timedOut.rawValue)
XCTAssert(ECONNREFUSED == Errno.connectionRefused.rawValue)
XCTAssert(ELOOP == Errno.tooManySymbolicLinkLevels.rawValue)
XCTAssert(ENAMETOOLONG == Errno.fileNameTooLong.rawValue)
#if os(Windows)
XCTAssert(WSAEHOSTDOWN == Errno.hostIsDown.rawValue)
#elseif !os(WASI)
XCTAssert(EHOSTDOWN == Errno.hostIsDown.rawValue)
#endif
XCTAssert(EHOSTUNREACH == Errno.noRouteToHost.rawValue)
XCTAssert(ENOTEMPTY == Errno.directoryNotEmpty.rawValue)
#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
#if SYSTEM_PACKAGE_DARWIN
XCTAssert(EPROCLIM == Errno.tooManyProcesses.rawValue)
#endif
#if os(Windows)
XCTAssert(WSAEUSERS == Errno.tooManyUsers.rawValue)
XCTAssert(WSAEDQUOT == Errno.diskQuotaExceeded.rawValue)
XCTAssert(WSAESTALE == Errno.staleNFSFileHandle.rawValue)
#else
#if !os(WASI)
XCTAssert(EUSERS == Errno.tooManyUsers.rawValue)
#endif
XCTAssert(EDQUOT == Errno.diskQuotaExceeded.rawValue)
XCTAssert(ESTALE == Errno.staleNFSFileHandle.rawValue)
#endif
#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
#if SYSTEM_PACKAGE_DARWIN
XCTAssert(EBADRPC == Errno.rpcUnsuccessful.rawValue)
XCTAssert(ERPCMISMATCH == Errno.rpcVersionMismatch.rawValue)
XCTAssert(EPROGUNAVAIL == Errno.rpcProgramUnavailable.rawValue)
@@ -98,17 +135,22 @@ final class ErrnoTest: XCTestCase {
XCTAssert(ENOLCK == Errno.noLocks.rawValue)
XCTAssert(ENOSYS == Errno.noFunction.rawValue)
#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
XCTAssert(EFTYPE == Errno.badFileTypeOrFormat.rawValue)
XCTAssert(EAUTH == Errno.authenticationError.rawValue)
XCTAssert(ENEEDAUTH == Errno.needAuthenticator.rawValue)
#endif
#if SYSTEM_PACKAGE_DARWIN
XCTAssert(EPWROFF == Errno.devicePowerIsOff.rawValue)
XCTAssert(EDEVERR == Errno.deviceError.rawValue)
#endif
#if !os(Windows)
XCTAssert(EOVERFLOW == Errno.overflow.rawValue)
#endif
#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
#if SYSTEM_PACKAGE_DARWIN
XCTAssert(EBADEXEC == Errno.badExecutable.rawValue)
XCTAssert(EBADARCH == Errno.badCPUType.rawValue)
XCTAssert(ESHLIBVERS == Errno.sharedLibraryVersionMismatch.rawValue)
@@ -116,37 +158,60 @@ final class ErrnoTest: XCTestCase {
#endif
XCTAssert(ECANCELED == Errno.canceled.rawValue)
#if !os(Windows)
XCTAssert(EIDRM == Errno.identifierRemoved.rawValue)
XCTAssert(ENOMSG == Errno.noMessage.rawValue)
#endif
XCTAssert(EILSEQ == Errno.illegalByteSequence.rawValue)
#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
#if SYSTEM_PACKAGE_DARWIN
XCTAssert(ENOATTR == Errno.attributeNotFound.rawValue)
#endif
#if !os(Windows)
XCTAssert(EBADMSG == Errno.badMessage.rawValue)
XCTAssert(EMULTIHOP == Errno.multiHop.rawValue)
XCTAssert(ENODATA == Errno.noData.rawValue)
XCTAssert(ENOLINK == Errno.noLink.rawValue)
XCTAssert(EPROTO == Errno.protocolError.rawValue)
#endif
#if !os(Windows) && !os(FreeBSD) && !os(WASI)
XCTAssert(ENODATA == Errno.noData.rawValue)
XCTAssert(ENOSR == Errno.noStreamResources.rawValue)
XCTAssert(ENOSTR == Errno.notStream.rawValue)
XCTAssert(EPROTO == Errno.protocolError.rawValue)
XCTAssert(ETIME == Errno.timeout.rawValue)
#endif
XCTAssert(EOPNOTSUPP == Errno.notSupportedOnSocket.rawValue)
// From headers but not man page
#if !os(WASI) // Would need to use _getConst func from CSystem
XCTAssert(EWOULDBLOCK == Errno.wouldBlock.rawValue)
#endif
#if os(Windows)
XCTAssert(WSAETOOMANYREFS == Errno.tooManyReferences.rawValue)
XCTAssert(WSAEREMOTE == Errno.tooManyRemoteLevels.rawValue)
#elseif !os(WASI)
XCTAssert(ETOOMANYREFS == Errno.tooManyReferences.rawValue)
XCTAssert(EREMOTE == Errno.tooManyRemoteLevels.rawValue)
#endif
#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
#if SYSTEM_PACKAGE_DARWIN
XCTAssert(ENOPOLICY == Errno.noSuchPolicy.rawValue)
#endif
#if !os(Windows)
XCTAssert(ENOTRECOVERABLE == Errno.notRecoverable.rawValue)
XCTAssert(EOWNERDEAD == Errno.previousOwnerDied.rawValue)
#endif
#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
#if os(FreeBSD)
XCTAssert(ENOTCAPABLE == Errno.notCapable.rawValue)
XCTAssert(ECAPMODE == Errno.capabilityMode.rawValue)
XCTAssert(EINTEGRITY == Errno.integrityCheckFailed.rawValue)
#endif
#if SYSTEM_PACKAGE_DARWIN
XCTAssert(EQFULL == Errno.outputQueueFull.rawValue)
XCTAssert(ELAST == Errno.lastErrnoValue.rawValue)
#endif
@@ -0,0 +1,25 @@
/*
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
*/
#if SYSTEM_PACKAGE
@testable import SystemPackage
#else
@testable import System
#endif
extension FileDescriptor {
internal func fileSize(
retryOnInterrupt: Bool = true
) throws -> Int64 {
let current = try seek(offset: 0, from: .current)
let size = try seek(offset: 0, from: .end)
try seek(offset: current, from: .start)
return size
}
}
+270 -4
View File
@@ -1,17 +1,283 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 Apple Inc. and the Swift System project authors
Copyright (c) 2020 - 2025 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
*/
import XCTest
import SystemPackage
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
#if SYSTEM_PACKAGE
@testable import SystemPackage
#else
@testable import System
#endif
#if canImport(Android)
import Android
#elseif os(WASI)
import CSystem
#endif
@available(System 0.0.1, *)
final class FileOperationsTest: XCTestCase {
// TODO: Mocking based testing
#if ENABLE_MOCKING && !os(WASI) // Would need to use _getConst funcs from CSystem
func testSyscalls() {
let fd = FileDescriptor(rawValue: 1)
let rawBuf = UnsafeMutableRawBufferPointer.allocate(byteCount: 100, alignment: 4)
defer { rawBuf.deallocate() }
let bufAddr = rawBuf.baseAddress
let rawFD = fd.rawValue
let bufCount = rawBuf.count
let writeBuf = UnsafeRawBufferPointer(rawBuf)
let writeBufAddr = writeBuf.baseAddress
let syscallTestCases: Array<MockTestCase> = [
MockTestCase(name: "open", .interruptable, "a path", O_RDWR | O_APPEND) {
retryOnInterrupt in
_ = try FileDescriptor.open(
"a path", .readWrite, options: [.append], retryOnInterrupt: retryOnInterrupt)
},
MockTestCase(name: "open", .interruptable, "a path", O_WRONLY | O_CREAT | O_APPEND, 0o777) {
retryOnInterrupt in
_ = try FileDescriptor.open(
"a path", .writeOnly, options: [.create, .append],
permissions: [.groupReadWriteExecute, .ownerReadWriteExecute, .otherReadWriteExecute],
retryOnInterrupt: retryOnInterrupt)
},
MockTestCase(name: "read", .interruptable, rawFD, bufAddr, bufCount) {
retryOnInterrupt in
_ = try fd.read(into: rawBuf, retryOnInterrupt: retryOnInterrupt)
},
MockTestCase(name: "pread", .interruptable, rawFD, bufAddr, bufCount, 5) {
retryOnInterrupt in
_ = try fd.read(fromAbsoluteOffset: 5, into: rawBuf, retryOnInterrupt: retryOnInterrupt)
},
MockTestCase(name: "lseek", .noInterrupt, rawFD, -2, SEEK_END) {
_ in
_ = try fd.seek(offset: -2, from: .end)
},
MockTestCase(name: "write", .interruptable, rawFD, writeBufAddr, bufCount) {
retryOnInterrupt in
_ = try fd.write(writeBuf, retryOnInterrupt: retryOnInterrupt)
},
MockTestCase(name: "pwrite", .interruptable, rawFD, writeBufAddr, bufCount, 7) {
retryOnInterrupt in
_ = try fd.write(toAbsoluteOffset: 7, writeBuf, retryOnInterrupt: retryOnInterrupt)
},
MockTestCase(name: "close", .noInterrupt, rawFD) {
_ in
_ = try fd.close()
},
MockTestCase(name: "dup", .interruptable, rawFD) { retryOnInterrupt in
_ = try fd.duplicate(retryOnInterrupt: retryOnInterrupt)
},
MockTestCase(name: "dup2", .interruptable, rawFD, 42) { retryOnInterrupt in
_ = try fd.duplicate(as: FileDescriptor(rawValue: 42),
retryOnInterrupt: retryOnInterrupt)
},
]
for test in syscallTestCases { test.runAllTests() }
}
#endif // ENABLE_MOCKING && !os(WASI)
func testWriteFromEmptyBuffer() throws {
#if os(Windows)
let fd = try FileDescriptor.open(FilePath("NUL"), .writeOnly)
#else
let fd = try FileDescriptor.open(FilePath("/dev/null"), .writeOnly)
#endif
let written1 = try fd.write(toAbsoluteOffset: 0, .init(start: nil, count: 0))
XCTAssertEqual(written1, 0)
let pointer = UnsafeMutableRawPointer.allocate(byteCount: 8, alignment: 8)
defer { pointer.deallocate() }
let empty = UnsafeRawBufferPointer(start: pointer, count: 0)
let written2 = try fd.write(toAbsoluteOffset: 0, empty)
XCTAssertEqual(written2, 0)
}
#if os(Windows)
// Generate a file containing random bytes; this should not be used
// for cryptography, it's just for testing.
func generateRandomData(at path: FilePath, count: Int) throws {
let fd = try FileDescriptor.open(path, .readWrite,
options: [.create, .truncate])
defer {
try! fd.close()
}
let data = [UInt8](
sequence(first: 0,
next: {
_ in UInt8.random(in: UInt8.min...UInt8.max)
}).dropFirst().prefix(count)
)
try data.withUnsafeBytes {
_ = try fd.write($0)
}
}
#endif
func testReadToEmptyBuffer() throws {
try withTemporaryFilePath(basename: "testReadToEmptyBuffer") { path in
#if os(Windows)
// Windows doesn't have an equivalent to /dev/random, so generate
// some random bytes and write them to a file for the next step.
let randomPath = path.appending("random.txt")
try generateRandomData(at: randomPath, count: 16)
let fd = try FileDescriptor.open(randomPath, .readOnly)
#else // !os(Windows)
let fd = try FileDescriptor.open(FilePath("/dev/random"), .readOnly)
#endif
let read1 = try fd.read(fromAbsoluteOffset: 0, into: .init(start: nil, count: 0))
XCTAssertEqual(read1, 0)
let pointer = UnsafeMutableRawPointer.allocate(byteCount: 8, alignment: 8)
defer { pointer.deallocate() }
let empty = UnsafeMutableRawBufferPointer(start: pointer, count: 0)
let read2 = try fd.read(fromAbsoluteOffset: 0, into: empty)
XCTAssertEqual(read2, 0)
}
}
func testHelpers() {
// TODO: Test writeAll, writeAll(toAbsoluteOffset), closeAfter
}
#if !os(WASI) // WASI has no pipe
func testAdHocPipe() throws {
// Ad-hoc test testing `Pipe` functionality.
// We cannot test `Pipe` using `MockTestCase` because it calls `pipe` with a pointer to an array local to the `Pipe`, the address of which we do not know prior to invoking `Pipe`.
let pipe = try FileDescriptor.pipe()
try pipe.readEnd.closeAfter {
try pipe.writeEnd.closeAfter {
var abc = "abc"
try abc.withUTF8 {
_ = try pipe.writeEnd.write(UnsafeRawBufferPointer($0))
}
let readLen = 3
let readBytes = try Array<UInt8>(unsafeUninitializedCapacity: readLen) { buf, count in
count = try pipe.readEnd.read(into: UnsafeMutableRawBufferPointer(buf))
}
XCTAssertEqual(readBytes, Array(abc.utf8))
}
}
}
#endif
func testAdHocOpen() {
// Ad-hoc test touching a file system.
do {
// TODO: Test this against a virtual in-memory file system
try withTemporaryFilePath(basename: "testAdhocOpen") { path in
let fd = try FileDescriptor.open(path.appending("b.txt"), .readWrite, options: [.create, .truncate], permissions: .ownerReadWrite)
try fd.closeAfter {
try fd.writeAll("abc".utf8)
var def = "def"
try def.withUTF8 {
_ = try fd.write(UnsafeRawBufferPointer($0))
}
try fd.seek(offset: 1, from: .start)
let readLen = 3
let readBytes = try Array<UInt8>(unsafeUninitializedCapacity: readLen) { (buf, count) in
count = try fd.read(into: UnsafeMutableRawBufferPointer(buf))
}
let preadBytes = try Array<UInt8>(unsafeUninitializedCapacity: readLen) { (buf, count) in
count = try fd.read(fromAbsoluteOffset: 1, into: UnsafeMutableRawBufferPointer(buf))
}
XCTAssertEqual(readBytes.first!, "b".utf8.first!)
XCTAssertEqual(readBytes, preadBytes)
// TODO: seek
}
}
} catch let err as Errno {
print("caught \(err))")
// Should we assert? I'd be interested in knowing if this happened
XCTAssert(false)
} catch {
fatalError("FATAL: `testAdHocOpen`")
}
}
#if ENABLE_MOCKING
func testGithubIssues() {
// https://github.com/apple/swift-system/issues/26
#if os(WASI)
let openOptions = _getConst_O_WRONLY() | _getConst_O_CREAT()
#else
let openOptions = O_WRONLY | O_CREAT
#endif
let issue26 = MockTestCase(
name: "open", .interruptable, "a path", openOptions, 0o020
) {
retryOnInterrupt in
_ = try FileDescriptor.open(
"a path", .writeOnly, options: [.create],
permissions: [.groupWrite],
retryOnInterrupt: retryOnInterrupt)
}
issue26.runAllTests()
}
#endif // ENABLE_MOCKING
func testResizeFile() throws {
try withTemporaryFilePath(basename: "testResizeFile") { path in
let fd = try FileDescriptor.open(path.appending("\(UUID().uuidString).txt"), .readWrite, options: [.create, .truncate], permissions: .ownerReadWrite)
try fd.closeAfter {
// File should be empty initially.
XCTAssertEqual(try fd.fileSize(), 0)
// Write 3 bytes.
try fd.writeAll("abc".utf8)
// File should now be 3 bytes.
XCTAssertEqual(try fd.fileSize(), 3)
// Resize to 6 bytes.
try fd.resize(to: 6)
// File should now be 6 bytes.
XCTAssertEqual(try fd.fileSize(), 6)
// Read in the 6 bytes.
let readBytes = try Array<UInt8>(unsafeUninitializedCapacity: 6) { (buf, count) in
try fd.seek(offset: 0, from: .start)
// Should have read all 6 bytes.
count = try fd.read(into: UnsafeMutableRawBufferPointer(buf))
XCTAssertEqual(count, 6)
}
// First 3 bytes should be unaffected by resize.
XCTAssertEqual(Array(readBytes[..<3]), Array("abc".utf8))
// Extension should be padded with zeros.
XCTAssertEqual(Array(readBytes[3...]), Array(repeating: 0, count: 3))
// File should still be 6 bytes.
XCTAssertEqual(try fd.fileSize(), 6)
// Resize to 2 bytes.
try fd.resize(to: 2)
// File should now be 2 bytes.
XCTAssertEqual(try fd.fileSize(), 2)
// Read in file with a buffer big enough for 6 bytes.
let readBytesAfterTruncation = try Array<UInt8>(unsafeUninitializedCapacity: 6) { (buf, count) in
try fd.seek(offset: 0, from: .start)
count = try fd.read(into: UnsafeMutableRawBufferPointer(buf))
// Should only have read 2 bytes.
XCTAssertEqual(count, 2)
}
// Written content was trunctated.
XCTAssertEqual(readBytesAfterTruncation, Array("ab".utf8))
}
}
}
}
@@ -0,0 +1,247 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2024 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
*/
import XCTest
#if os(Windows)
#if SYSTEM_PACKAGE
@testable import SystemPackage
#else
@testable import System
#endif
import WinSDK
@available(iOS 8, *)
final class FileOperationsTestWindows: XCTestCase {
private let r = ACCESS_MASK(
FILE_READ_ATTRIBUTES
| FILE_READ_DATA
| FILE_READ_EA
| STANDARD_RIGHTS_READ
| SYNCHRONIZE
)
private let w = ACCESS_MASK(
FILE_APPEND_DATA
| FILE_WRITE_ATTRIBUTES
| FILE_WRITE_DATA
| FILE_WRITE_EA
| STANDARD_RIGHTS_WRITE
| SYNCHRONIZE
)
private let x = ACCESS_MASK(
FILE_EXECUTE
| FILE_READ_ATTRIBUTES
| STANDARD_RIGHTS_EXECUTE
| SYNCHRONIZE
)
private struct Test {
var permissions: CModeT
var ownerAccess: ACCESS_MASK
var groupAccess: ACCESS_MASK
var otherAccess: ACCESS_MASK
init(_ permissions: CModeT,
_ ownerAccess: ACCESS_MASK,
_ groupAccess: ACCESS_MASK,
_ otherAccess: ACCESS_MASK) {
self.permissions = permissions
self.ownerAccess = ownerAccess
self.groupAccess = groupAccess
self.otherAccess = otherAccess
}
}
/// Retrieve the owner, group and other access masks for a given file.
///
/// - Parameters:
/// - path: The path to the file to inspect
/// - Returns: A tuple of ACCESS_MASK values.
func getAccessMasks(
path: FilePath
) -> (ACCESS_MASK, ACCESS_MASK, ACCESS_MASK) {
var SIDAuthWorld = SID_IDENTIFIER_AUTHORITY(Value: (0, 0, 0, 0, 0, 1))
var psidEveryone: PSID? = nil
XCTAssert(AllocateAndInitializeSid(&SIDAuthWorld, 1,
DWORD(SECURITY_WORLD_RID),
0, 0, 0, 0, 0, 0, 0,
&psidEveryone))
defer {
FreeSid(psidEveryone)
}
var everyone = TRUSTEE_W(
pMultipleTrustee: nil,
MultipleTrusteeOperation: NO_MULTIPLE_TRUSTEE,
TrusteeForm: TRUSTEE_IS_SID,
TrusteeType: TRUSTEE_IS_GROUP,
ptstrName:
psidEveryone!.assumingMemoryBound(to: CInterop.PlatformChar.self)
)
return path.withPlatformString { objectName in
var psidOwner: PSID? = nil
var psidGroup: PSID? = nil
var pDacl: PACL? = nil
var pSD: PSECURITY_DESCRIPTOR? = nil
XCTAssertEqual(GetNamedSecurityInfoW(
objectName,
SE_FILE_OBJECT,
SECURITY_INFORMATION(
DACL_SECURITY_INFORMATION
| GROUP_SECURITY_INFORMATION
| OWNER_SECURITY_INFORMATION
),
&psidOwner,
&psidGroup,
&pDacl,
nil,
&pSD), DWORD(ERROR_SUCCESS))
defer {
LocalFree(pSD)
}
var owner = TRUSTEE_W(
pMultipleTrustee: nil,
MultipleTrusteeOperation: NO_MULTIPLE_TRUSTEE,
TrusteeForm: TRUSTEE_IS_SID,
TrusteeType: TRUSTEE_IS_USER,
ptstrName:
psidOwner!.assumingMemoryBound(to: CInterop.PlatformChar.self)
)
var group = TRUSTEE_W(
pMultipleTrustee: nil,
MultipleTrusteeOperation: NO_MULTIPLE_TRUSTEE,
TrusteeForm: TRUSTEE_IS_SID,
TrusteeType: TRUSTEE_IS_GROUP,
ptstrName:
psidGroup!.assumingMemoryBound(to: CInterop.PlatformChar.self)
)
var ownerAccess = ACCESS_MASK(0)
var groupAccess = ACCESS_MASK(0)
var otherAccess = ACCESS_MASK(0)
XCTAssertEqual(GetEffectiveRightsFromAclW(
pDacl,
&owner,
&ownerAccess), DWORD(ERROR_SUCCESS))
XCTAssertEqual(GetEffectiveRightsFromAclW(
pDacl,
&group,
&groupAccess), DWORD(ERROR_SUCCESS))
XCTAssertEqual(GetEffectiveRightsFromAclW(
pDacl,
&everyone,
&otherAccess), DWORD(ERROR_SUCCESS))
return (ownerAccess, groupAccess, otherAccess)
}
}
private func runTests(_ tests: [Test], at path: FilePath) throws {
for test in tests {
let octal = String(test.permissions, radix: 8)
let testPath = path.appending("test-\(octal).txt")
let fd = try FileDescriptor.open(
testPath,
.readWrite,
options: [.create, .truncate],
permissions: FilePermissions(rawValue: test.permissions)
)
_ = try fd.closeAfter {
try fd.writeAll("Hello World".utf8)
}
let (ownerAccess, groupAccess, otherAccess)
= getAccessMasks(path: testPath)
XCTAssertEqual(ownerAccess, test.ownerAccess)
XCTAssertEqual(groupAccess, test.groupAccess)
XCTAssertEqual(otherAccess, test.otherAccess)
}
}
/// Test that the umask works properly
func testUmask() throws {
// See https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/persistent-storage#permissions
try XCTSkipIf(NSUserName() == "ContainerAdministrator", "containers use a different permission model")
// Default mask should be 0o022
XCTAssertEqual(FilePermissions.creationMask, [.groupWrite, .otherWrite])
try withTemporaryFilePath(basename: "testUmask") { path in
let tests = [
Test(0o000, 0, 0, 0),
Test(0o700, r|w|x, 0, 0),
Test(0o770, r|w|x, r|x, 0),
Test(0o777, r|w|x, r|x, r|x)
]
try runTests(tests, at: path)
}
try FilePermissions.withCreationMask([.groupWrite, .groupExecute,
.otherWrite, .otherExecute]) {
try withTemporaryFilePath(basename: "testUmask") { path in
let tests = [
Test(0o000, 0, 0, 0),
Test(0o700, r|w|x, 0, 0),
Test(0o770, r|w|x, r, 0),
Test(0o777, r|w|x, r, r)
]
try runTests(tests, at: path)
}
}
}
/// Test that setting permissions on a file works as expected
func testPermissions() throws {
// See https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/persistent-storage#permissions
try XCTSkipIf(NSUserName() == "ContainerAdministrator", "containers use a different permission model")
try FilePermissions.withCreationMask([]) {
try withTemporaryFilePath(basename: "testPermissions") { path in
let tests = [
Test(0o000, 0, 0, 0),
Test(0o400, r, 0, 0),
Test(0o200, w, 0, 0),
Test(0o100, x, 0, 0),
Test(0o040, 0, r, 0),
Test(0o020, 0, w, 0),
Test(0o010, 0, x, 0),
Test(0o004, 0, 0, r),
Test(0o002, 0, 0, w),
Test(0o001, 0, 0, x),
Test(0o700, r|w|x, 0, 0),
Test(0o770, r|w|x, r|w|x, 0),
Test(0o777, r|w|x, r|w|x, r|w|x),
Test(0o755, r|w|x, r|x, r|x),
Test(0o644, r|w, r, r),
Test(0o007, 0, 0, r|w|x),
Test(0o070, 0, r|w|x, 0),
Test(0o077, 0, r|w|x, r|w|x),
]
try runTests(tests, at: path)
}
}
}
}
#endif // os(Windows)
-76
View File
@@ -1,76 +0,0 @@
/*
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
*/
import XCTest
import SystemPackage
extension UnsafePointer where Pointee == UInt8 {
internal var _asCChar: UnsafePointer<CChar> {
UnsafeRawPointer(self).assumingMemoryBound(to: CChar.self)
}
}
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
func filePathFromUnterminatedBytes<S: Sequence>(_ bytes: S) -> FilePath where S.Element == UInt8 {
var array = Array(bytes)
assert(array.last != 0, "already null terminated")
array += [0]
return array.withUnsafeBufferPointer {
FilePath(cString: $0.baseAddress!._asCChar)
}
}
let invalidBytes: [UInt8] = [0x2F, 0x61, 0x2F, 0x62, 0x2F, 0x83]
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
final class FilePathTest: XCTestCase {
struct TestPath {
let filePath: FilePath
let string: String
let validUTF8: Bool
}
let testPaths: [TestPath] = [
// empty
TestPath(filePath: FilePath(), string: String(), validUTF8: true),
// valid ascii
TestPath(filePath: "/a/b/c", string: "/a/b/c", validUTF8: true),
// valid utf8
TestPath(filePath: "/あ/🧟‍♀️", string: "/あ/🧟‍♀️", validUTF8: true),
// invalid utf8
TestPath(filePath: filePathFromUnterminatedBytes(invalidBytes), string: String(decoding: invalidBytes, as: UTF8.self), validUTF8: false),
]
func testFilePath() {
XCTAssertEqual(0, FilePath().length)
for testPath in testPaths {
XCTAssertEqual(testPath.string, String(decoding: testPath.filePath))
if testPath.validUTF8 {
XCTAssertEqual(testPath.filePath, FilePath(testPath.string))
XCTAssertEqual(testPath.string, String(validatingUTF8: testPath.filePath))
} else {
XCTAssertNotEqual(testPath.filePath, FilePath(testPath.string))
XCTAssertNil(String(validatingUTF8: testPath.filePath))
}
testPath.filePath.withCString {
XCTAssertEqual(testPath.string, String(cString: $0))
XCTAssertEqual(testPath.filePath, FilePath(cString: $0))
}
}
}
}
@@ -0,0 +1,292 @@
/*
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
*/
import XCTest
#if SYSTEM_PACKAGE
@testable import SystemPackage
#else
@testable import System
#endif
@available(System 0.0.2, *)
struct TestPathComponents: TestCase {
var path: FilePath
var expectedRoot: FilePath.Root?
var expectedComponents: [FilePath.Component]
var pathComponents: Array<FilePath.Component> { Array(path.components) }
let file: StaticString
let line: UInt
func failureMessage(_ reason: String?) -> String {
"""
Fail \(reason ?? "")
path: \(path)
components: \(pathComponents))
expected: \(expectedComponents)
"""
}
init<C: Collection>(
_ path: FilePath,
root: FilePath.Root?,
_ components: C,
file: StaticString = #file, line: UInt = #line
) where C.Element == FilePath.Component {
self.path = path
self.expectedRoot = root
self.expectedComponents = Array(components)
self.file = file
self.line = line
}
func testComponents() {
expectEqual(expectedRoot, path.root)
expectEqualSequence(
expectedComponents, Array(path.components), "testComponents()")
}
func testBidi() {
expectEqualSequence(
expectedComponents.reversed(), path.components.reversed(), "reversed()")
expectEqualSequence(
path.components, path.components.reversed().reversed(),
"reversed().reversed()")
for i in 0 ..< path.components.count {
expectEqualSequence(
expectedComponents.dropLast(i), path.components.dropLast(i), "dropLast")
expectEqualSequence(
expectedComponents.suffix(i), path.components.suffix(i), "suffix")
}
}
func testRRC() {
// TODO: programmatic tests showing parity with Array<Component>
}
func testModify() {
if path.root == nil {
let rootedPath = FilePath(root: "/", path.components)
expectNotEqual(rootedPath, path)
var pathCopy = path
expectEqual(path, pathCopy)
pathCopy.components = rootedPath.components
expectNil(pathCopy.root, "components.set doesn't assign root")
expectEqual(path, pathCopy)
} else {
let rootlessPath = FilePath(root: nil, path.components)
var pathCopy = path
expectEqual(path, pathCopy)
pathCopy.components = rootlessPath.components
expectNotNil(pathCopy.root, "components.set preserves root")
expectEqual(path, pathCopy)
}
}
func runAllTests() {
testComponents()
testBidi()
testRRC()
testModify()
}
}
@available(System 0.0.2, *)
final class FilePathComponentsTest: XCTestCase {
func testAdHocRRC() {
var path: FilePath = "/usr/local/bin"
func expect(
_ s: String,
_ file: StaticString = #file,
_ line: UInt = #line
) {
if path == FilePath(s) { return }
defer { print("expected: \(s), actual: \(path)") }
XCTAssert(false, file: file, line: line)
}
// Run `body`, restoring `path` afterwards
func restoreAfter(
body: () -> ()
) {
let copy = path
defer { path = copy }
body()
}
// Interior removal keeps path prefix intact, if there is one
restoreAfter {
path = "prefix//middle1/middle2////suffix"
let suffix = path.components.indices.last!
path.components.removeSubrange(..<suffix)
expect("suffix")
}
restoreAfter {
path = "prefix//middle1/middle2////suffix"
let firstMiddle = path.components.index(
path.components.startIndex, offsetBy: 1)
let suffix = path.components.indices.last!
path.components.removeSubrange(firstMiddle ..< suffix)
expect("prefix/suffix")
}
restoreAfter {
path.components.removeFirst()
expect("/local/bin")
path.components.removeFirst()
expect("/bin")
}
restoreAfter {
path.components.insert(
contentsOf: ["bar", "baz"], at: path.components.startIndex)
expect("/bar/baz/usr/local/bin")
}
restoreAfter {
path.components.insert("start", at: path.components.startIndex)
expect("/start/usr/local/bin")
path.components.insert("prefix", at: path.components.startIndex)
expect("/prefix/start/usr/local/bin")
path.components.removeSubrange(
..<path.components.index(path.components.startIndex, offsetBy: 4))
expect("/bin")
path.components.removeFirst()
expect("/")
path.components.append(contentsOf: ["usr", "local", "bin"])
expect("/usr/local/bin")
path.components.removeLast(2)
expect("/usr")
}
restoreAfter {
path.root = nil
expect("usr/local/bin")
path.components.removeAll()
expect("")
path.components.insert("foo", at: path.components.startIndex)
expect("foo")
path.components.removeAll()
path.components.insert(
contentsOf: ["bar", "baz"], at: path.components.startIndex)
expect("bar/baz")
}
restoreAfter {
path.components.append("tail")
expect("/usr/local/bin/tail")
path.components.append(contentsOf: ["tail2", "tail3", "tail4"])
expect("/usr/local/bin/tail/tail2/tail3/tail4")
}
// Insertion into the middle adds trailing separator
restoreAfter {
path.components.remove(
at: path.components.index(after: path.components.startIndex))
expect("/usr/bin")
path.components.insert("middle", at: path.components.indices.last!)
expect("/usr/middle/bin")
path.components.insert(
contentsOf: ["middle2", "middle3"], at: path.components.indices.last!)
expect("/usr/middle/middle2/middle3/bin")
let slice = path.components.dropFirst().dropLast()
let range = slice.startIndex ..< slice.endIndex
path.components.replaceSubrange(
range, with: ["newMiddle", "newMiddle2", "newMiddle3", "newMiddle4/"])
expect("/usr/newMiddle/newMiddle2/newMiddle3/newMiddle4/bin")
}
restoreAfter {
path.components.removeLast(3)
expect("/")
path.components.append(contentsOf: ["bar", "baz"])
expect("/bar/baz")
}
// Empty insertions / removals
restoreAfter {
path.components.replaceSubrange(..<path.components.startIndex, with: [])
expect("/usr/local/bin")
path.components.replaceSubrange(path.components.endIndex..., with: [])
expect("/usr/local/bin")
path.components.insert(contentsOf: [], at: path.components.startIndex)
expect("/usr/local/bin")
path.components.insert(contentsOf: [], at: path.components.indices.last!)
expect("/usr/local/bin")
}
}
func testCases() {
var testPaths: Array<TestPathComponents> = [
TestPathComponents("", root: nil, []),
TestPathComponents("/", root: "/", []),
TestPathComponents("foo", root: nil, ["foo"]),
TestPathComponents("foo/", root: nil, ["foo"]),
TestPathComponents("/foo", root: "/", ["foo"]),
TestPathComponents("foo/bar", root: nil, ["foo", "bar"]),
TestPathComponents("foo/bar/", root: nil, ["foo", "bar"]),
TestPathComponents("/foo/bar", root: "/", ["foo", "bar"]),
TestPathComponents("/foo///bar", root: "/", ["foo", "bar"]),
TestPathComponents("foo/bar/", root: nil, ["foo", "bar"]),
TestPathComponents("foo///bar/baz/", root: nil, ["foo", "bar", "baz"]),
TestPathComponents("./", root: nil, ["."]),
TestPathComponents("./..", root: nil, [".", ".."]),
TestPathComponents("/./..//", root: "/", [".", ".."]),
]
#if !os(Windows)
testPaths.append(contentsOf:[
TestPathComponents("///foo//", root: "/", ["foo"]),
TestPathComponents("//foo///bar/baz/", root: "/", ["foo", "bar", "baz"])
])
#else
// On Windows, these are UNC paths
testPaths.append(contentsOf:[
TestPathComponents("///foo//", root: "///foo//", []),
TestPathComponents("//foo///bar/baz/", root: "//foo//", ["bar", "baz"])
])
#endif
testPaths.forEach {
$0.runAllTests()
}
}
func testSeparatorNormalization() {
var paths: Array<FilePath> = [
"/a/b",
"/a/b/",
"/a//b/",
"/a/b//",
"/a/b////",
"/a////b/",
]
#if !os(Windows)
paths.append("//a/b")
paths.append("///a/b")
paths.append("///a////b")
paths.append("///a////b///")
#endif
for path in paths {
var path = path
path._normalizeSeparators()
XCTAssertEqual(path, "/a/b")
}
}
}
// TODO: Test hashValue and equatable for equal components, i.e. make
// sure indices are not part of the hash.
@@ -0,0 +1,129 @@
/*
This source file is part of the Swift System open source project
Copyright (c)2024 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
*/
import XCTest
#if SYSTEM_PACKAGE
@testable import SystemPackage
#else
@testable import System
#endif
@available(System 0.0.1, *)
final class FilePathDecodableTest: XCTestCase {
func testInvalidFilePath() {
// _storage is a valid SystemString, but the invariants of FilePath are
// violated (specifically, _storage is not normal).
let input: [UInt8] = [
123, 34, 95,115,116,111,114, 97,103,101, 34, 58,123, 34,110,117,108,108,
84,101,114,109,105,110, 97,116,101,100, 83,116,111,114, 97,103,101, 34,
58, 91, 49, 48, 57, 44, 45, 55, 54, 44, 53, 53, 44, 55, 49, 44, 49, 52,
44, 53, 57, 44, 45, 49, 49, 50, 44, 45, 56, 52, 44, 52, 50, 44, 45, 55,
48, 44, 45, 49, 48, 52, 44, 55, 51, 44, 45, 54, 44, 50, 44, 53, 55, 44,
54, 50, 44, 45, 56, 55, 44, 45, 53, 44, 45, 54, 53, 44, 45, 51, 57, 44,
45, 49, 48, 57, 44, 45, 55, 54, 44, 51, 48, 44, 53, 50, 44, 45, 56, 50,
44, 45, 54, 48, 44, 45, 50, 44, 56, 53, 44, 49, 50, 51, 44, 45, 56, 52,
44, 45, 53, 56, 44, 49, 49, 52, 44, 49, 44, 45, 49, 49, 54, 44, 56, 48,
44, 49, 48, 52, 44, 45, 55, 56, 44, 45, 52, 53, 44, 49, 54, 44, 45, 52,
54, 44, 55, 44, 49, 49, 56, 44, 45, 50, 52, 44, 54, 50, 44, 54, 52, 44,
45, 52, 49, 44, 45, 49, 48, 51, 44, 53, 44, 45, 55, 53, 44, 50, 50, 44,
45, 49, 48, 53, 44, 45, 49, 54, 44, 52, 55, 44, 52, 55, 44, 49, 50, 52,
44, 45, 53, 55, 44, 53, 51, 44, 49, 49, 49, 44, 49, 53, 44, 45, 50, 55,
44, 54, 54, 44, 45, 49, 54, 44, 49, 48, 50, 44, 49, 48, 54, 44, 49, 51,
44, 49, 48, 53, 44, 45, 49, 49, 50, 44, 55, 56, 44, 45, 53, 48, 44, 50,
48, 44, 56, 44, 45, 50, 55, 44, 52, 52, 44, 52, 44, 56, 44, 54, 53, 44,
50, 51, 44, 57, 55, 44, 45, 50, 56, 44, 56, 56, 44, 52, 50, 44, 45, 51,
54, 44, 45, 50, 51, 44, 49, 48, 51, 44, 57, 57, 44, 45, 53, 56, 44, 45,
49, 49, 48, 44, 45, 53, 52, 44, 45, 49, 49, 55, 44, 45, 57, 52, 44, 45,
55, 50, 44, 50, 57, 44, 45, 50, 52, 44, 45, 56, 52, 44, 53, 55, 44, 45,
49, 50, 54, 44, 52, 52, 44, 55, 53, 44, 55, 54, 44, 52, 57, 44, 45, 52,
49, 44, 45, 50, 53, 44, 50, 52, 44, 45, 49, 50, 54, 44, 55, 44, 50, 56,
44, 45, 52, 56, 44, 56, 55, 44, 51, 49, 44, 45, 49, 49, 53, 44, 55, 44,
45, 54, 48, 44, 53, 57, 44, 49, 51, 44, 55, 57, 44, 53, 48, 44, 45, 57,
54, 44, 45, 50, 44, 45, 50, 52, 44, 45, 57, 49, 44, 55, 49, 44, 45, 49,
50, 53, 44, 52, 50, 44, 45, 56, 52, 44, 52, 44, 53, 57, 44, 49, 50, 53,
44, 49, 50, 49, 44, 45, 50, 54, 44, 45, 49, 50, 44, 45, 49, 48, 53, 44,
53, 54, 44, 49, 49, 48, 44, 49, 52, 44, 45, 49, 48, 52, 44, 45, 53, 50,
44, 45, 53, 56, 44, 45, 54, 44, 45, 50, 54, 44, 45, 52, 55, 44, 53, 57,
44, 52, 50, 44, 49, 50, 51, 44, 52, 52, 44, 45, 57, 50, 44, 45, 50, 57,
44, 45, 51, 54, 44, 45, 54, 50, 44, 50, 54, 44, 45, 49, 55, 44, 45, 49,
48, 44, 45, 56, 49, 44, 54, 49, 44, 52, 55, 44, 45, 57, 52, 44, 45, 49,
48, 54, 44, 49, 53, 44, 49, 48, 48, 44, 45, 49, 50, 49, 44, 45, 49, 49,
49, 44, 51, 44, 45, 57, 44, 52, 54, 44, 45, 55, 48, 44, 45, 49, 57, 44,
52, 56, 44, 45, 49, 50, 44, 45, 57, 49, 44, 45, 50, 48, 44, 49, 51, 44,
54, 53, 44, 45, 55, 48, 44, 52, 49, 44, 45, 57, 53, 44, 49, 48, 52, 44,
45, 55, 53, 44, 45, 49, 49, 53, 44, 49, 48, 49, 44, 45, 57, 52, 44, 45,
49, 50, 51, 44, 45, 51, 53, 44, 45, 50, 49, 44, 45, 52, 50, 44, 45, 51,
48, 44, 45, 55, 49, 44, 45, 49, 49, 57, 44, 52, 52, 44, 49, 49, 49, 44,
49, 48, 53, 44, 54, 54, 44, 45, 49, 50, 54, 44, 55, 50, 44, 45, 52, 48,
44, 49, 50, 49, 44, 45, 50, 49, 44, 52, 50, 44, 45, 55, 56, 44, 49, 50,
54, 44, 56, 49, 44, 45, 57, 52, 44, 55, 52, 44, 49, 49, 50, 44, 45, 56,
54, 44, 51, 50, 44, 55, 54, 44, 49, 49, 55, 44, 45, 56, 44, 56, 54, 44,
49, 48, 51, 44, 54, 50, 44, 49, 49, 55, 44, 54, 55, 44, 45, 56, 54, 44,
45, 49, 48, 48, 44, 45, 49, 48, 57, 44, 45, 53, 52, 44, 45, 51, 49, 44,
45, 56, 57, 44, 48, 93,125,125,
]
XCTAssertThrowsError(try JSONDecoder().decode(
FilePath.self,
from: Data(input)
))
}
func testInvalidSystemString() {
// _storage is a SystemString whose invariants are violated; it contains
// a non-terminating null byte.
let input: [UInt8] = [
123, 34, 95,115,116,111,114, 97,103,101, 34, 58,123, 34,110,117,108,108,
84,101,114,109,105,110, 97,116,101,100, 83,116,111,114, 97,103,101, 34,
58, 91, 49, 49, 49, 44, 48, 44, 45, 49, 54, 44, 57, 49, 44, 52, 54, 44,
45, 49, 48, 50, 44, 49, 49, 53, 44, 45, 50, 49, 44, 45, 49, 49, 56, 44,
52, 57, 44, 57, 50, 44, 45, 49, 48, 44, 53, 56, 44, 45, 55, 48, 44, 57,
55, 44, 56, 44, 57, 57, 44, 48, 93,125, 125
]
XCTAssertThrowsError(try JSONDecoder().decode(
FilePath.self,
from: Data(input)
))
}
func testInvalidExample() {
// Another misformed example from Johannes that violates FilePath's
// invariants by virtue of not being normalized.
let input: [UInt8] = [
123, 34, 95,115,116,111,114, 97,103,101, 34, 58,123, 34,110,117,108,108,
84,101,114,109,105,110, 97,116,101,100, 83,116,111,114, 97,103,101, 34,
58, 91, 56, 55, 44, 50, 52, 44, 45, 49, 49, 53, 44, 45, 49, 57, 44, 49,
50, 50, 44, 45, 54, 56, 44, 57, 49, 44, 45, 49, 48, 54, 44, 45, 49, 48,
48, 44, 45, 49, 49, 52, 44, 53, 54, 44, 45, 54, 53, 44, 49, 49, 56, 44,
45, 54, 48, 44, 54, 54, 44, 45, 52, 50, 44, 55, 55, 44, 45, 54, 44, 45,
52, 50, 44, 45, 56, 56, 44, 52, 55, 44, 48, 93,125, 125
]
XCTAssertThrowsError(try JSONDecoder().decode(
FilePath.self,
from: Data(input)
))
}
func testEmptyString() {
// FilePath with an empty (and hence not null-terminated) SystemString.
let input: [UInt8] = [
123, 34, 95,115,116,111,114, 97,103,101, 34, 58,123, 34,110,117,108,108,
84,101,114,109,105,110, 97,116,101,100, 83,116,111,114, 97,103,101, 34,
58, 91, 93,125,125
]
XCTAssertThrowsError(try JSONDecoder().decode(
FilePath.self,
from: Data(input)
))
}
}
@@ -0,0 +1,107 @@
#if SYSTEM_PACKAGE
@testable import SystemPackage
#else
@testable import System
#endif
// Why can't I write this extension on `FilePath.ComponentView.SubSequence`?
@available(System 0.0.2, *)
extension Slice where Base == FilePath.ComponentView {
internal var _storageSlice: SystemString.SubSequence {
base._path._storage[self.startIndex._storage ..< self.endIndex._storage]
}
}
// Proposed API that didn't make the cut, but we stil want to keep our testing for
@available(System 0.0.2, *)
extension FilePath {
/// Returns `self` relative to `base`.
/// This does not cosult the file system or resolve symlinks.
///
/// Returns `nil` if `self.root != base.root`.
///
/// On Windows, if any component of either path could be interpreted as the root of
/// a traditional DOS path (e.g. a directory named `C:`), returns `nil`.
///
/// Example:
///
/// let path: FilePath = "/usr/local/bin"
/// path.lexicallyRelative(toBase: "/usr/local") == "bin"
/// path.lexicallyRelative(toBase: "/usr/local/bin/ls") == ".."
/// path.lexicallyRelative(toBase: "/tmp/foo.txt") == "../../usr/local/bin"
/// path.lexicallyRelative(toBase: "local/bin") == nil
internal func lexicallyRelative(toBase base: FilePath) -> FilePath? {
guard root == base.root else { return nil }
// FIXME: On Windows, return nil if any component looks like a root
let (tail, baseTail) = _dropCommonPrefix(components, base.components)
var prefix = SystemString()
for _ in 0..<baseTail.count {
prefix.append(.dot)
prefix.append(.dot)
prefix.append(platformSeparator)
}
return FilePath(prefix + tail._storageSlice)
}
/// Whether a lexically-normalized `self` contains a lexically-normalized
/// `other`.
public func lexicallyContains(_ other: FilePath) -> Bool {
guard !other.isEmpty else { return true }
guard !isEmpty else { return false }
let (selfLex, otherLex) =
(self.lexicallyNormalized(), other.lexicallyNormalized())
if otherLex.isAbsolute { return selfLex.starts(with: otherLex) }
// FIXME: Windows semantics with relative roots?
// TODO: better than this naive algorithm
var slice = selfLex.components[...]
while !slice.isEmpty {
if slice.starts(with: otherLex.components) { return true }
slice = slice.dropFirst()
}
return false
}
}
extension Collection where Element: Equatable, SubSequence == Slice<Self> {
// Mock up RangeSet functionality until it's real
func indices(where p: (Element) throws -> Bool) rethrows -> [Range<Index>] {
var result = Array<Range<Index>>()
guard !isEmpty else { return result }
var i = startIndex
while i != endIndex {
let next = index(after: i)
if try p(self[i]) {
result.append(i..<next)
}
i = next
}
return result
}
}
extension RangeReplaceableCollection {
mutating func removeSubranges(_ subranges: [Range<Index>]) {
guard !subranges.isEmpty else { return }
var result = Self()
var idx = startIndex
for range in subranges {
result.append(contentsOf: self[idx..<range.lowerBound])
idx = range.upperBound
}
if idx != endIndex {
result.append(contentsOf: self[idx...])
}
self = result
}
}
@@ -0,0 +1,109 @@
/*
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
*/
#if ENABLE_MOCKING
import XCTest
#if SYSTEM_PACKAGE
import SystemPackage
#else
import System
#endif
private struct ParsingTestCase: TestCase {
// Whether we want the path to be constructed and syntactically
// manipulated as though it were a Windows path
let isWindows: Bool
// We defer forming the path until `runAllTests()` executes,
// so that we can switch between unix and windows behavior.
var pathStr: String
// The expected path post separator normalization
var normalized: String
var file: StaticString
var line: UInt
}
extension ParsingTestCase {
static func unix(
_ path: String, normalized: String,
file: StaticString = #file, line: UInt = #line
) -> ParsingTestCase {
ParsingTestCase(
isWindows: false,
pathStr: path, normalized: normalized,
file: file, line: line)
}
static func windows(
_ path: String, normalized: String,
file: StaticString = #file, line: UInt = #line
) -> ParsingTestCase {
ParsingTestCase(
isWindows: true,
pathStr: path, normalized: normalized,
file: file, line: line)
}
}
extension ParsingTestCase {
func runAllTests() {
withWindowsPaths(enabled: isWindows) {
let path = FilePath(pathStr)
expectEqual(normalized, path.description)
}
}
}
#if SYSTEM_PACKAGE
@testable import SystemPackage
#else
@testable import System
#endif
@available(System 0.0.2, *)
final class FilePathParsingTest: XCTestCase {
func testNormalization() {
let unixPaths: Array<ParsingTestCase> = [
.unix("/", normalized: "/"),
.unix("", normalized: ""),
.unix("//", normalized: "/"),
.unix("///", normalized: "/"),
.unix("/foo/bar/", normalized: "/foo/bar"),
.unix("foo//bar", normalized: "foo/bar"),
.unix("//foo/bar//baz/", normalized: "/foo/bar/baz"),
.unix("/foo/bar/baz//", normalized: "/foo/bar/baz"),
.unix("/foo/bar/baz///", normalized: "/foo/bar/baz"),
]
let windowsPaths: Array<ParsingTestCase> = [
.windows(#"C:\\folder\file\"#, normalized: #"C:\folder\file"#),
.windows(#"C:folder\\\file\\\"#, normalized: #"C:folder\file"#),
.windows(#"C:/foo//bar/"#, normalized: #"C:\foo\bar"#),
.windows(#"\\server\share\"#, normalized: #"\\server\share\"#),
.windows(#"//server/share/"#, normalized: #"\\server\share\"#),
.windows(#"\\?\UNC/server\share\"#, normalized: #"\\?\UNC\server\share\"#),
.windows(#"\\.\C:\"#, normalized: #"\\.\C:\"#),
.windows(#"C:\"#, normalized: #"C:\"#),
.windows(#"\"#, normalized: #"\"#),
]
for test in unixPaths {
test.runAllTests()
}
for test in windowsPaths {
test.runAllTests()
}
}
}
#endif // ENABLE_MOCKING
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,58 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2024 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
*/
import XCTest
#if SYSTEM_PACKAGE
@testable import SystemPackage
#else
@testable import System
#endif
final class TemporaryPathTest: XCTestCase {
#if SYSTEM_PACKAGE_DARWIN
func testNotInSlashTmp() throws {
try withTemporaryFilePath(basename: "NotInSlashTmp") { path in
// We shouldn't be using "/tmp" on Darwin
XCTAssertNotEqual(path.components.first!, "tmp")
}
}
#endif
func testUnique() throws {
try withTemporaryFilePath(basename: "test") { path in
let strPath = String(decoding: path)
XCTAssert(strPath.contains("test"))
try withTemporaryFilePath(basename: "test") { path2 in
let strPath2 = String(decoding: path2)
XCTAssertNotEqual(strPath, strPath2)
}
}
}
func testCleanup() throws {
var thePath: FilePath? = nil
try withTemporaryFilePath(basename: "test") { path in
thePath = path.appending("foo.txt")
let fd = try FileDescriptor.open(thePath!, .readWrite,
options: [.create, .truncate],
permissions: .ownerReadWrite)
_ = try fd.closeAfter {
try fd.writeAll("Hello World".utf8)
}
}
XCTAssertThrowsError(try FileDescriptor.open(thePath!, .readOnly)) {
error in
XCTAssertEqual(error as! Errno, Errno.noSuchFileOrDirectory)
}
}
}
@@ -0,0 +1,105 @@
/*
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
*/
import XCTest
#if SYSTEM_PACKAGE
import SystemPackage
#else
import System
#endif
@available(System 0.0.1, *)
func filePathFromInvalidCodePointSequence<S: Sequence>(_ bytes: S) -> FilePath where S.Element == CInterop.PlatformUnicodeEncoding.CodeUnit {
var array = Array(bytes)
assert(array.last != 0, "already null terminated")
array += [0]
return array.withUnsafeBufferPointer {
$0.withMemoryRebound(to: CInterop.PlatformChar.self) {
FilePath(platformString: $0.baseAddress!)
}
}
}
@available(System 0.0.2, *)
final class FilePathTest: XCTestCase {
struct TestPath {
let filePath: FilePath
let string: String
let validString: Bool
init(filePath: FilePath, string: String, validString: Bool) {
self.filePath = filePath
#if os(Windows)
self.string = string.replacingOccurrences(of: "/", with: "\\")
#else
self.string = string
#endif
self.validString = validString
}
}
#if os(Windows)
static let invalidSequence: [UTF16.CodeUnit] = [0xd800, 0x0020]
static let invalidSequenceTest =
TestPath(filePath: filePathFromInvalidCodePointSequence(invalidSequence),
string: String(decoding: invalidSequence, as: UTF16.self),
validString: false)
#else
static let invalidSequence: [UTF8.CodeUnit] = [0x2F, 0x61, 0x2F, 0x62, 0x2F, 0x83]
static let invalidSequenceTest =
TestPath(filePath: filePathFromInvalidCodePointSequence(invalidSequence),
string: String(decoding: invalidSequence, as: UTF8.self),
validString: false)
#endif
var testPaths: [TestPath] = [
// empty
TestPath(filePath: FilePath(), string: String(), validString: true),
// valid ascii
TestPath(filePath: "/a/b/c", string: "/a/b/c", validString: true),
// valid utf8
TestPath(filePath: "/あ/🧟‍♀️", string: "/あ/🧟‍♀️", validString: true),
// invalid sequence
invalidSequenceTest,
]
func testFilePath() {
XCTAssertEqual(0, FilePath().length)
for testPath in testPaths {
XCTAssertEqual(testPath.string, String(decoding: testPath.filePath))
// TODO: test component CodeUnit representation validation
if testPath.validString {
XCTAssertEqual(testPath.filePath, FilePath(testPath.string))
XCTAssertEqual(testPath.string, String(validating: testPath.filePath))
} else {
XCTAssertNotEqual(testPath.filePath, FilePath(testPath.string))
XCTAssertNil(String(validating: testPath.filePath))
}
testPath.filePath.withPlatformString {
#if os(Windows)
XCTAssertEqual(testPath.string, String(decodingCString: $0, as: UTF16.self))
#else
XCTAssertEqual(testPath.string, String(cString: $0))
#endif
XCTAssertEqual(testPath.filePath, FilePath(platformString: $0))
}
}
}
}
+33 -6
View File
@@ -1,44 +1,71 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 Apple Inc. and the Swift System project authors
Copyright (c) 2020 - 2025 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
*/
import XCTest
import SystemPackage
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
#if SYSTEM_PACKAGE
import SystemPackage
#else
import System
#endif
#if canImport(Android)
import Android
#endif
@available(System 0.0.1, *)
final class FileDescriptorTest: XCTestCase {
func testStandardDescriptors() {
XCTAssertEqual(FileDescriptor.standardInput.rawValue, 0)
XCTAssertEqual(FileDescriptor.standardOutput.rawValue, 1)
XCTAssertEqual(FileDescriptor.standardError.rawValue, 2)
}
// Test the constants match the C header values. For various reasons,
func testConstants() {
XCTAssertEqual(O_RDONLY, FileDescriptor.AccessMode.readOnly.rawValue)
XCTAssertEqual(O_WRONLY, FileDescriptor.AccessMode.writeOnly.rawValue)
XCTAssertEqual(O_RDWR, FileDescriptor.AccessMode.readWrite.rawValue)
#if !os(WASI) // Would need to use _getConst funcs from CSystem
#if !os(Windows)
XCTAssertEqual(O_NONBLOCK, FileDescriptor.OpenOptions.nonBlocking.rawValue)
#endif
XCTAssertEqual(O_APPEND, FileDescriptor.OpenOptions.append.rawValue)
XCTAssertEqual(O_CREAT, FileDescriptor.OpenOptions.create.rawValue)
XCTAssertEqual(O_TRUNC, FileDescriptor.OpenOptions.truncate.rawValue)
XCTAssertEqual(O_EXCL, FileDescriptor.OpenOptions.exclusiveCreate.rawValue)
#endif // !os(WASI
#if !os(Windows)
XCTAssertEqual(O_NOFOLLOW, FileDescriptor.OpenOptions.noFollow.rawValue)
XCTAssertEqual(O_CLOEXEC, FileDescriptor.OpenOptions.closeOnExec.rawValue)
#endif
// BSD only
#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
XCTAssertEqual(O_SHLOCK, FileDescriptor.OpenOptions.sharedLock.rawValue)
XCTAssertEqual(O_EXLOCK, FileDescriptor.OpenOptions.exclusiveLock.rawValue)
#endif
#if SYSTEM_PACKAGE_DARWIN
XCTAssertEqual(O_SYMLINK, FileDescriptor.OpenOptions.symlink.rawValue)
XCTAssertEqual(O_EVTONLY, FileDescriptor.OpenOptions.eventOnly.rawValue)
#endif
#if os(FreeBSD)
XCTAssertEqual(O_SYNC, FileDescriptor.OpenOptions.sync.rawValue)
#endif
XCTAssertEqual(SEEK_SET, FileDescriptor.SeekOrigin.start.rawValue)
XCTAssertEqual(SEEK_CUR, FileDescriptor.SeekOrigin.current.rawValue)
XCTAssertEqual(SEEK_END, FileDescriptor.SeekOrigin.end.rawValue)
#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
#if SYSTEM_PACKAGE_DARWIN || os(FreeBSD)
XCTAssertEqual(SEEK_HOLE, FileDescriptor.SeekOrigin.nextHole.rawValue)
XCTAssertEqual(SEEK_DATA, FileDescriptor.SeekOrigin.nextData.rawValue)
#endif
@@ -49,7 +76,7 @@ final class FileDescriptorTest: XCTestCase {
}
// @available(macOS 10.16, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
@available(System 0.0.1, *)
final class FilePermissionsTest: XCTestCase {
func testPermissions() {
+34
View File
@@ -0,0 +1,34 @@
#if compiler(>=6.2) && $Lifetimes
#if os(Linux)
import XCTest
#if SYSTEM_PACKAGE
@testable import SystemPackage
#else
import System
#endif
func requestBytes(_ request: consuming RawIORequest) -> [UInt8] {
return withUnsafePointer(to: request.rawValue) {
let requestBuf = UnsafeBufferPointer(start: $0, count: 1)
let rawBytes = UnsafeRawBufferPointer(requestBuf)
return .init(rawBytes)
}
}
// This test suite compares various IORequests bit-for-bit to IORequests
// that were generated with liburing or manually written out,
// which are known to work correctly.
final class IORequestTests: XCTestCase {
func testNop() {
let req = IORing.Request.nop().makeRawRequest()
let sourceBytes = requestBytes(req)
// convenient property of nop: it's all zeros!
// for some unknown reason, liburing sets the fd field to -1.
// we're not trying to be bug-compatible with it, so 0 *should* work.
XCTAssertEqual(sourceBytes, .init(repeating: 0, count: 64))
}
}
#endif // os(Linux)
#endif // compiler(>=6.2) && $Lifetimes
+132
View File
@@ -0,0 +1,132 @@
#if compiler(>=6.2) && $Lifetimes
#if os(Linux)
import XCTest
import CSystem //for eventfd
#if SYSTEM_PACKAGE
import SystemPackage
#else
import System
#endif
func uringEnabled() throws -> Bool {
do {
let procPath = FilePath("/proc/sys/kernel/io_uring_disabled")
let fd = try FileDescriptor.open(procPath, .readOnly)
let buffer = UnsafeMutableRawBufferPointer.allocate(byteCount: 1024, alignment: 0)
_ = try fd.read(into: buffer)
if buffer.load(fromByteOffset: 0, as: Int.self) == 0 {
return true
}
} catch (_) {
return false
}
return false
}
final class IORingTests: XCTestCase {
func testInit() throws {
guard try uringEnabled() else { return }
_ = try IORing(queueDepth: 32, flags: [])
}
func testNop() throws {
guard try uringEnabled() else { return }
var ring = try IORing(queueDepth: 32, flags: [])
_ = try ring.submit(linkedRequests: .nop())
let completion = try ring.blockingConsumeCompletion()
XCTAssertEqual(completion.result, 0)
}
func makeHelloWorldFile() throws -> (dir: FileDescriptor, file: FilePath) {
mkdir("/tmp/IORingTests/", 0o777)
let path: FilePath = "/tmp/IORingTests/test.txt"
let fd = try FileDescriptor.open(
path,
.readWrite,
options: .create,
permissions: .ownerReadWrite
)
try fd.writeAll("Hello, World!".utf8)
try fd.close()
let parent = try FileDescriptor.open("/tmp/IORingTests/", .readOnly)
return (parent, path)
}
func cleanUpHelloWorldFile(_ parent: FileDescriptor) throws {
try parent.close()
rmdir("/tmp/IORingTests/")
}
func setupTestRing(depth: Int, fileSlots: Int, buffers: [UnsafeMutableRawBufferPointer]) throws -> IORing {
var ring: IORing = try IORing(queueDepth: UInt32(depth))
_ = try ring.registerFileSlots(count: 1)
_ = try ring.registerBuffers(buffers)
return ring
}
func testUndersizedSubmissionQueue() throws {
guard try uringEnabled() else { return }
var ring: IORing = try IORing(queueDepth: 1)
let enqueued = ring.prepare(linkedRequests: .nop(), .nop())
XCTAssertFalse(enqueued)
}
// Exercises opening, reading, closing, registered files, registered buffers, and eventfd
func testOpenReadAndWriteFixedFile() throws {
guard try uringEnabled() else { return }
let (parent, path) = try makeHelloWorldFile()
let rawBuffer = UnsafeMutableRawBufferPointer.allocate(byteCount: 13, alignment: 16)
var ring = try setupTestRing(depth: 6, fileSlots: 1, buffers: [rawBuffer])
let eventFD = FileDescriptor(rawValue: eventfd(0, Int32(EFD_SEMAPHORE)))
try ring.registerEventFD(eventFD)
//Part 1: read the file we just created, and make sure the eventfd fires
let enqueued = try ring.submit(linkedRequests:
.open(path, in: parent, into: ring.registeredFileSlots[0], mode: .readOnly),
.read(ring.registeredFileSlots[0], into: ring.registeredBuffers[0]),
.close(ring.registeredFileSlots[0]))
XCTAssert(enqueued)
let efdBuf = UnsafeMutableRawBufferPointer.allocate(byteCount: 8, alignment: 0)
_ = try eventFD.read(into: efdBuf)
_ = try ring.blockingConsumeCompletion() //open
_ = try eventFD.read(into: efdBuf)
_ = try ring.blockingConsumeCompletion() //read
_ = try eventFD.read(into: efdBuf)
_ = try ring.blockingConsumeCompletion() //close
let result = String(cString: rawBuffer.assumingMemoryBound(to: CChar.self).baseAddress!)
XCTAssertEqual(result, "Hello, World!")
//Part 2: delete that file, then use the ring to write out a new one
let rmResult = path.withPlatformString {
remove($0)
}
XCTAssertEqual(rmResult, 0)
let enqueued2 = try ring.submit(linkedRequests:
.open(path, in: parent, into: ring.registeredFileSlots[0], mode: .readWrite, options: .create, permissions: .ownerReadWrite),
.write(ring.registeredBuffers[0], into: ring.registeredFileSlots[0]),
.close(ring.registeredFileSlots[0]))
XCTAssert(enqueued2)
_ = try eventFD.read(into: efdBuf)
_ = try ring.blockingConsumeCompletion() //open
_ = try eventFD.read(into: efdBuf)
_ = try ring.blockingConsumeCompletion() //write
_ = try eventFD.read(into: efdBuf)
_ = try ring.blockingConsumeCompletion() //close
memset(rawBuffer.baseAddress!, 0, rawBuffer.count)
//Verify using a non-ring IO method that what we wrote matches our expectations
print("about to open")
let nonRingFD = try FileDescriptor.open(path, .readOnly)
let bytesRead = try nonRingFD.read(into: rawBuffer)
XCTAssert(bytesRead == 13)
let result2 = String(cString: rawBuffer.assumingMemoryBound(to: CChar.self).baseAddress!)
XCTAssertEqual(result2, "Hello, World!")
try cleanUpHelloWorldFile(parent)
efdBuf.deallocate()
rawBuffer.deallocate()
}
}
#endif // os(Linux)
#endif // compiler(>=6.2) && $Lifetimes
+242
View File
@@ -0,0 +1,242 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2022 - 2025 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
*/
#if SYSTEM_PACKAGE_DARWIN
import XCTest
import Darwin.Mach
#if SYSTEM_PACKAGE
import SystemPackage
#else
import System
#endif
@available(System 1.4.0, *)
final class MachPortTests: XCTestCase {
func refCountForMachPortName(name:mach_port_name_t, kind:mach_port_right_t) -> mach_port_urefs_t {
var refCount:mach_port_urefs_t = .max
let kr = mach_port_get_refs(mach_task_self_, name, kind, &refCount)
if kr == KERN_INVALID_NAME {
refCount = 0
} else {
XCTAssertEqual(kr, KERN_SUCCESS)
}
return refCount
}
func scopedReceiveRight(name:mach_port_name_t) -> mach_port_urefs_t {
let right = Mach.Port<Mach.ReceiveRight>(name:name) // this should automatically deallocate when going out of scope
defer { _ = right }
return refCountForMachPortName(name:name, kind:MACH_PORT_RIGHT_RECEIVE)
}
func testReceiveRightDeallocation() throws {
var name: mach_port_name_t = 0xFFFFFFFF
let kr = mach_port_allocate(mach_task_self_, MACH_PORT_RIGHT_RECEIVE, &name)
XCTAssertEqual(kr, KERN_SUCCESS)
XCTAssertNotEqual(name, 0xFFFFFFFF)
let originalCount = refCountForMachPortName(name: name, kind: MACH_PORT_RIGHT_RECEIVE)
XCTAssertEqual(originalCount, 1)
let incrementedCount = scopedReceiveRight(name:name)
XCTAssertEqual(incrementedCount, 1);
let deallocated = refCountForMachPortName(name:name, kind: MACH_PORT_RIGHT_RECEIVE)
XCTAssertEqual(deallocated, 0);
}
func consumeSendRightAutomatically(name:mach_port_name_t) -> mach_port_urefs_t {
let send = Mach.Port<Mach.SendRight>(name:name) // this should automatically deallocate when going out of scope
return send.withBorrowedName { name in
// Get the ref count before automatic deallocation happens
return refCountForMachPortName(name:name, kind:MACH_PORT_RIGHT_SEND)
}
}
func testSendRightDeallocation() throws {
let recv = Mach.Port<Mach.ReceiveRight>()
recv.withBorrowedName { name in
let kr = mach_port_insert_right(mach_task_self_, name, name, mach_msg_type_name_t(MACH_MSG_TYPE_MAKE_SEND))
XCTAssertEqual(kr, KERN_SUCCESS)
let one = consumeSendRightAutomatically(name:name)
XCTAssertEqual(one, 1);
let zero = refCountForMachPortName(name:name, kind:MACH_PORT_RIGHT_SEND)
XCTAssertEqual(zero, 0);
}
}
func testSendRightRelinquishment() throws {
let recv = Mach.Port<Mach.ReceiveRight>()
let name = ({
let send = recv.makeSendRight()
let one = send.withBorrowedName { name in
return self.refCountForMachPortName(name:name, kind:MACH_PORT_RIGHT_SEND)
}
XCTAssertEqual(one, 1)
return send.relinquish()
})()
let stillOne = refCountForMachPortName(name:name, kind:MACH_PORT_RIGHT_SEND)
XCTAssertEqual(stillOne, 1)
recv.withBorrowedName {
let alsoOne = refCountForMachPortName(name: $0, kind: MACH_PORT_RIGHT_RECEIVE)
XCTAssertEqual(alsoOne, 1)
}
}
func testSendOnceRightRelinquishment() throws {
let recv = Mach.Port<Mach.ReceiveRight>()
let name = ({
let send = recv.makeSendOnceRight()
let one = send.withBorrowedName { name in
return self.refCountForMachPortName(name: name, kind: MACH_PORT_RIGHT_SEND_ONCE)
}
XCTAssertEqual(one, 1)
return send.relinquish()
})()
let stillOne = refCountForMachPortName(name: name, kind: MACH_PORT_RIGHT_SEND_ONCE)
XCTAssertEqual(stillOne, 1)
recv.withBorrowedName {
let alsoOne = refCountForMachPortName(name: $0, kind: MACH_PORT_RIGHT_RECEIVE)
XCTAssertEqual(alsoOne, 1)
}
}
func testReceiveRightRelinquishment() throws {
let recv = Mach.Port<Mach.ReceiveRight>()
let one = recv.withBorrowedName {
self.refCountForMachPortName(name: $0, kind: MACH_PORT_RIGHT_RECEIVE)
}
XCTAssertEqual(one, 1)
let name = recv.unguardAndRelinquish()
let stillOne = refCountForMachPortName(name: name, kind: MACH_PORT_RIGHT_RECEIVE)
XCTAssertEqual(stillOne, 1)
}
func testMakeSendCountSettable() throws {
var recv = Mach.Port<Mach.ReceiveRight>()
XCTAssertEqual(recv.makeSendCount, 0)
recv.makeSendCount = 7
XCTAssertEqual(recv.makeSendCount, 7)
}
func makeSendRight() throws -> Mach.Port<Mach.SendRight> {
let recv = Mach.Port<Mach.ReceiveRight>()
let zero = recv.makeSendCount
XCTAssertEqual(zero, 0)
let send = recv.makeSendRight()
let one = recv.makeSendCount
XCTAssertEqual(one, 1)
return send
}
func testMakeSendCountIncrement() throws {
_ = try makeSendRight()
}
func testMakeSendOnceDoesntIncrementMakeSendCount() throws {
let recv = Mach.Port<Mach.ReceiveRight>()
let zero = recv.makeSendCount
XCTAssertEqual(zero, 0)
_ = recv.makeSendOnceRight()
let same = recv.makeSendCount
XCTAssertEqual(same, zero)
}
func testMakeSendOnceIsUnique() throws {
let recv = Mach.Port<Mach.ReceiveRight>()
let once = recv.makeSendOnceRight()
recv.withBorrowedName { rname in
once.withBorrowedName { oname in
XCTAssertNotEqual(oname, rname)
}
}
}
func testCopySend() throws {
let recv = Mach.Port<Mach.ReceiveRight>()
let zero = recv.makeSendCount
XCTAssertEqual(zero, 0)
let send = recv.makeSendRight()
let one = recv.makeSendCount
XCTAssertEqual(one, 1)
_ = try send.copySendRight()
let same = recv.makeSendCount
XCTAssertEqual(same, one)
}
func testCopyDeadName() throws {
let recv = Mach.Port<Mach.ReceiveRight>()
let send = recv.makeSendRight()
_ = consume recv // and turn `send` into a dead name
XCTAssertThrowsError(
_ = try send.copySendRight(),
"Copying a dead name should throw"
) { error in
XCTAssertEqual(
error as! Mach.PortRightError, Mach.PortRightError.deadName
)
}
}
func testCopyDeadName2() throws {
let send = Mach.Port<Mach.SendRight>(name: 0xffffffff)
XCTAssertThrowsError(
_ = try send.copySendRight(),
"Copying a dead name should throw"
) { error in
XCTAssertEqual(
error as! Mach.PortRightError, Mach.PortRightError.deadName
)
}
}
func testMakeReceiveRightFromExistingName() throws {
var name = mach_port_name_t(MACH_PORT_NULL)
var kr = mach_port_allocate(mach_task_self_, MACH_PORT_RIGHT_RECEIVE, &name)
XCTAssertEqual(kr, KERN_SUCCESS)
XCTAssertNotEqual(name, mach_port_name_t(MACH_PORT_NULL))
let context = mach_port_context_t(arc4random())
kr = mach_port_guard(mach_task_self_, name, context, 0)
XCTAssertEqual(kr, KERN_SUCCESS)
let right = Mach.Port<Mach.ReceiveRight>(name: name, context: context)
right.withBorrowedName {
XCTAssertEqual(name, $0)
XCTAssertEqual(context, $1)
}
}
func testDeinitDeadSendRights() throws {
let recv = Mach.Port<Mach.ReceiveRight>()
let send = recv.makeSendRight()
let send1 = recv.makeSendOnceRight()
_ = consume recv
// `send` and `send1` have become dead names
_ = consume send
_ = consume send1
}
}
#endif
+52
View File
@@ -0,0 +1,52 @@
/*
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
*/
#if ENABLE_MOCKING
import XCTest
#if SYSTEM_PACKAGE
@testable import SystemPackage
#else
@testable import System
#endif
@available(System 0.0.2, *)
final class MockingTest: XCTestCase {
func testMocking() {
XCTAssertFalse(mockingEnabled)
MockingDriver.withMockingEnabled { driver in
XCTAssertTrue(mockingEnabled)
XCTAssertTrue(driver === currentMockingDriver)
XCTAssertEqual(driver.forceErrno, .none)
let forced = ForceErrno.always(errno: 42)
driver.forceErrno = forced
XCTAssertEqual(driver.forceErrno, forced)
// Test that a nested call swaps in a new driver and restores the old one after
MockingDriver.withMockingEnabled { nestedDriver in
XCTAssertTrue(mockingEnabled)
XCTAssertTrue(nestedDriver === currentMockingDriver)
XCTAssertFalse(nestedDriver === driver)
XCTAssertEqual(nestedDriver.forceErrno, .none)
}
XCTAssertTrue(mockingEnabled)
XCTAssertEqual(driver.forceErrno, forced)
}
XCTAssertFalse(mockingEnabled)
// Mocking should be enabled even if we do not refer to the driver
MockingDriver.withMockingEnabled { _ in
XCTAssertTrue(mockingEnabled)
}
XCTAssertFalse(mockingEnabled)
}
}
#endif // ENABLE_MOCKING
+39
View File
@@ -0,0 +1,39 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 - 2021 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
*/
import XCTest
#if SYSTEM_PACKAGE
@testable import SystemPackage
#else
@testable import System
#endif
final class SystemCharTest: XCTestCase {
func testIsLetter() {
let valid = SystemString(
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
for char in valid {
XCTAssertTrue(char.isLetter)
}
// non printable
for value in 0..<(UInt8(ascii: " ")) {
XCTAssertFalse(SystemChar(codeUnit: CInterop.PlatformUnicodeEncoding.CodeUnit(value)).isLetter)
}
XCTAssertFalse(SystemChar(codeUnit: 0x7F).isLetter) // DEL
// misc other
let invalid = SystemString(
##" !"#$%&'()*+,-./0123456789:;<=>?@[\]^_`{|}~"##)
for char in invalid {
XCTAssertFalse(char.isLetter)
}
}
}
+425
View File
@@ -0,0 +1,425 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2020 - 2024 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
*/
// Tests for PlatformString, SystemString, and FilePath's forwarding APIs
// TODO: Adapt test to Windows
import XCTest
#if SYSTEM_PACKAGE
@testable import SystemPackage
#else
@testable import System
#endif
private func makeRaw(
_ str: String
) -> [CInterop.PlatformChar] {
var str = str
#if os(Windows)
var array = Array(str.utf16)
#else
var array = str.withUTF8 { $0.withMemoryRebound(to: CChar.self, Array.init) }
#endif
array.append(0)
return array
}
private func makeStr(
_ raw: [CInterop.PlatformChar]
) -> String {
precondition((raw.last ?? 0) == 0)
// FIXME: Unfortunately, this relies on some of the same mechanisms tested...
return raw.withUnsafeBufferPointer {
String(platformString: $0.baseAddress!)
}
}
struct StringTest: TestCase {
// The error-corrected string
var string: String
// The raw contents
var raw: [CInterop.PlatformChar]
var isValid: Bool
var file: StaticString
var line: UInt
func runAllTests() {
precondition((raw.last ?? 0) == 0, "invalid test case")
// Test idempotence post-validation
string.withPlatformString {
if isValid {
let len = system_platform_strlen($0)
expectEqual(raw.count, 1+len, "Validation idempotence")
expectEqualSequence(raw, UnsafeBufferPointer(start: $0, count: 1+len),
"Validation idempotence")
}
let str = String(platformString: $0)
expectEqualSequence(
string.unicodeScalars, str.unicodeScalars, "Validation idempotence")
let validStr = String(validatingPlatformString: $0)
expectEqual(string, validStr, "Validation idempotence")
}
// Test String, SystemString, FilePath construction
let sysStr = SystemString(string)
expectEqualSequence(string.unicodeScalars, sysStr.string.unicodeScalars)
expectEqual(string, String(decoding: sysStr))
expectEqual(string, String(validating: sysStr))
let sysRaw = raw.withUnsafeBufferPointer {
SystemString(platformString: $0.baseAddress!)
}
expectEqual(string, String(decoding: sysRaw))
expectEqual(isValid, nil != String(validating: sysRaw))
expectEqual(isValid, sysStr == sysRaw)
let strDecoded = raw.withUnsafeBufferPointer {
String(platformString: $0.baseAddress!)
}
expectEqualSequence(string.unicodeScalars, strDecoded.unicodeScalars)
let strValidated = raw.withUnsafeBufferPointer {
String(validatingPlatformString: $0.baseAddress!)
}
expectEqual(isValid, strValidated != nil, "String(validatingPlatformString:)")
expectEqual(isValid, strDecoded == strValidated,
"String(validatingPlatformString:)")
// Test null insertion
let rawChars = raw.lazy.map { SystemChar($0) }
expectEqual(sysRaw, SystemString(rawChars.dropLast()))
sysRaw.withNullTerminatedSystemChars {
expectEqualSequence(rawChars, $0, "rawChars")
}
// Whether the content has normalized separators
let hasNormalSeparators: Bool = {
var normalSys = sysRaw
normalSys._normalizeSeparators()
return normalSys == sysRaw
}()
let fpStr = FilePath(string)
if hasNormalSeparators {
expectEqualSequence(
string.unicodeScalars, fpStr.string.unicodeScalars, "FilePath from string")
expectEqual(string, String(decoding: fpStr), "FilePath from string")
expectEqual(string, String(validating: fpStr), "FilePath from string")
expectEqual(sysStr, fpStr._storage, "FilePath from string")
}
let fpRaw = FilePath(sysRaw)
if hasNormalSeparators {
expectEqual(string, String(decoding: fpRaw), "raw FilePath")
expectEqual(isValid, nil != String(validating: fpRaw), "raw FilePath")
expectEqual(sysRaw, fpRaw._storage, "raw FilePath")
expectEqual(isValid, fpStr == fpRaw, "raw FilePath")
}
fpRaw.withPlatformString { fp0 in
fpRaw._storage.withPlatformString { storage0 in
expectEqual(fp0, storage0,
"FilePath withPlatformString address forwarding")
}
}
let isComponent = string == fpRaw.components.first?.string
if hasNormalSeparators && isComponent {
// Test FilePath.Component
let compStr = FilePath.Component(string)!
expectEqualSequence(
string.unicodeScalars, compStr.string.unicodeScalars, "Component from string")
expectEqual(string, String(decoding: compStr), "Component from string")
expectEqual(string, String(validating: compStr), "Component from string")
expectEqual(sysStr, compStr._slice.base, "Component from string")
let compRaw = FilePath.Component(sysRaw)!
expectEqual(string, String(decoding: compRaw), "raw Component")
expectEqual(isValid, nil != String(validating: compRaw), "raw Component")
expectEqual(sysRaw, compRaw._slice.base, "raw Component")
expectEqual(isValid, compStr == compRaw, "raw Component")
// TODO: Below works after we add last component optimization
// compRaw.withPlatformString { fp0 in
// compRaw.slice.base.withPlatformString { storage0 in
// expectEqual(fp0, storage0,
// "Component withPlatformString address forwarding")
// }
// }
}
sysRaw.withPlatformString {
let len = system_platform_strlen($0)
expectEqual(raw.count, 1+len, "SystemString.withPlatformString")
expectEqualSequence(raw, UnsafeBufferPointer(start: $0, count: 1+len),
"SystemString.withPlatformString")
if hasNormalSeparators {
expectEqual(sysRaw, FilePath(platformString: $0)._storage)
if isComponent {
expectEqual(
sysRaw, FilePath.Component(platformString: $0)!._slice.base)
}
}
}
}
}
extension StringTest {
static func valid(
_ str: String,
file: StaticString = #file, line: UInt = #line
) -> StringTest {
StringTest(
string: str,
raw: makeRaw(str),
isValid: true,
file: file, line: line)
}
static func invalid(
_ raw: [CInterop.PlatformChar],
file: StaticString = #file, line: UInt = #line
) -> StringTest {
StringTest(
string: makeStr(raw),
raw: raw,
isValid: false,
file: file, line: line)
}
}
final class SystemStringTest: XCTestCase {
let validCases: Array<StringTest> = [
.valid(""),
.valid("a"),
.valid("abc"),
.valid("/あ/🧟‍♀️"),
.valid("/あ\\🧟‍♀️"),
.valid("/あ\\🧟‍♀️///"),
.valid("あ_🧟‍♀️"),
.valid("/a/b/c"),
.valid("/a/b/c//"),
.valid(#"\a\b\c\\"#),
.valid("_a_b_c"),
]
#if os(Windows)
let invalidCases: Array<StringTest> = [
// TODO: Unpaired surrogates
]
#else
let invalidCases: Array<StringTest> = [
.invalid([CChar(bitPattern: 0x80), 0]),
.invalid([CChar(bitPattern: 0xFF), 0]),
.invalid([0x2F, 0x61, 0x2F, 0x62, 0x2F, CChar(bitPattern: 0x83), 0]),
]
#endif
func testPlatformString() {
for test in validCases {
test.runAllTests()
}
for test in invalidCases {
test.runAllTests()
}
}
// TODO: More exhaustive RAC+RRC SystemString tests
func testAdHoc() {
var str: SystemString = "abc"
str.append(SystemChar(ascii: "d"))
XCTAssert(str == "abcd")
XCTAssert(str.count == 4)
XCTAssert(str.count == str.length)
str.reserveCapacity(100)
XCTAssert(str == "abcd")
}
func testStringProperty() {
let source: [CInterop.PlatformChar] = [0x61, 0x62, 0, 0x63]
let str = SystemString(platformString: source)
XCTAssertEqual(str.string, str[...].string)
}
}
extension SystemStringTest {
func test_String_initWithArrayConversion() {
let source: [CInterop.PlatformChar] = [0x61, 0x62, 0, 0x63]
let str = String(platformString: source)
source.withUnsafeBufferPointer {
XCTAssertEqual(str, String(platformString: $0.baseAddress!))
}
}
@available(*, deprecated) // silence the warning for using a deprecated api
func test_String_initWithStringConversion() {
let source = "ab\0c"
var str: String
str = String(platformString: source)
source.withPlatformString {
XCTAssertEqual(str, String(platformString: $0))
}
str = String(platformString: "")
XCTAssertEqual(str.isEmpty, true)
}
@available(*, deprecated) // silence the warning for using a deprecated api
func test_String_initWithInoutConversion() {
var c: CInterop.PlatformChar = 0
let str = String(platformString: &c)
// Any other value of `c` would violate the null-terminated precondition
XCTAssertEqual(str.isEmpty, true)
}
func test_String_validatingPlatformStringWithArrayConversion() {
var source: [CInterop.PlatformChar] = [0x61, 0x62, 0, 0x63]
var str: String?
str = String(validatingPlatformString: source)
source.withUnsafeBufferPointer {
XCTAssertEqual(str, String(validatingPlatformString: $0.baseAddress!))
}
source[1] = CInterop.PlatformChar(truncatingIfNeeded: 0xdfff)
str = String(validatingPlatformString: source)
XCTAssertNil(str)
}
@available(*, deprecated) // silence the warning for using a deprecated api
func test_String_validatingPlatformStringWithStringConversion() {
let source = "ab\0c"
var str: String?
str = String(validatingPlatformString: source)
XCTAssertNotNil(str)
source.withPlatformString {
XCTAssertEqual(str, String.init(validatingPlatformString: $0))
}
str = String(validatingPlatformString: "")
XCTAssertNotNil(str)
XCTAssertEqual(str?.isEmpty, true)
}
@available(*, deprecated) // silence the warning for using a deprecated api
func test_String_validatingPlatformStringWithInoutConversion() {
var c: CInterop.PlatformChar = 0
let str = String(validatingPlatformString: &c)
// Any other value of `c` would violate the null-terminated precondition
XCTAssertNotNil(str)
XCTAssertEqual(str?.isEmpty, true)
}
func test_FilePath_initWithArrayConversion() {
let source: [CInterop.PlatformChar] = [0x61, 0x62, 0, 0x63]
let path = FilePath(platformString: source)
source.withUnsafeBufferPointer {
XCTAssertEqual(path, FilePath(platformString: $0.baseAddress!))
}
}
@available(*, deprecated) // silence the warning for using a deprecated api
func test_FilePath_initWithStringConversion() {
let source = "ab\0c"
var path: FilePath
path = FilePath(platformString: source)
source.withPlatformString {
XCTAssertEqual(path, FilePath(platformString: $0))
}
path = FilePath(platformString: "")
XCTAssertEqual(path.string.isEmpty, true)
}
@available(*, deprecated) // silence the warning for using a deprecated api
func test_FilePath_initWithInoutConversion() {
var c: CInterop.PlatformChar = 0
let path = FilePath(platformString: &c)
// Any other value of `c` would violate the null-terminated precondition
XCTAssertEqual(path.string.isEmpty, true)
}
func test_FilePathComponent_initWithArrayConversion() {
var source: [CInterop.PlatformChar] = [0x61, 0x62, 0, 0x63]
var component: FilePath.Component?
component = FilePath.Component(platformString: source)
source.withUnsafeBufferPointer {
XCTAssertEqual(component, .init(platformString: $0.baseAddress!))
}
source[1] = CInterop.PlatformChar(truncatingIfNeeded: 0xffff)
component = FilePath.Component(platformString: source)
source.withUnsafeBufferPointer {
XCTAssertEqual(component, .init(platformString: $0.baseAddress!))
}
}
@available(*, deprecated) // silence the warning for using a deprecated api
func test_FilePathComponent_initWithStringConversion() {
let source = "ab\0c"
var component: FilePath.Component?
component = FilePath.Component(platformString: source)
source.withPlatformString {
XCTAssertEqual(component, FilePath.Component(platformString: $0))
}
component = FilePath.Component(platformString: "")
XCTAssertNil(component)
}
@available(*, deprecated) // silence the warning for using a deprecated api
func test_FilePathComponent_initWithInoutConversion() {
var c: CInterop.PlatformChar = 0
let component = FilePath.Component(platformString: &c)
XCTAssertNil(component)
}
func test_FilePathRoot_initWithArrayConversion() {
let source: [CInterop.PlatformChar]
#if os(Windows)
source = [0x41, 0x3a, 0x5c, 0, 0x7f]
#else // unix
source = [0x2f, 0, 0x7f]
#endif
var root: FilePath.Root?
root = FilePath.Root(platformString: source)
source.withUnsafeBufferPointer {
XCTAssertEqual(root, FilePath.Root(platformString: $0.baseAddress!))
}
}
@available(*, deprecated) // silence the warning for using a deprecated api
func test_FilePathRoot_initWithStringConversion() {
#if os(Windows)
let source = "C:\\\0 and the rest"
#else // unix
let source = "/\0 and the rest"
#endif
var root: FilePath.Root?
root = FilePath.Root(platformString: source)
source.withPlatformString {
XCTAssertEqual(root, FilePath.Root(platformString: $0))
}
root = FilePath.Root(platformString: "")
XCTAssertNil(root)
}
@available(*, deprecated) // silence the warning for using a deprecated api
func test_FilePathRoot_initWithInoutConversion() {
var c: CInterop.PlatformChar = 0
let root = FilePath.Root(platformString: &c)
XCTAssertNil(root)
}
}
@@ -0,0 +1,253 @@
/*
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
*/
import XCTest
#if SYSTEM_PACKAGE
@testable import SystemPackage
#else
@testable import System
#endif
internal struct Wildcard: Hashable {}
#if ENABLE_MOCKING
extension Trace.Entry {
/// This implements `==` with wildcard matching.
/// (`Entry` cannot conform to `Equatable`/`Hashable` this way because
/// the wildcard matching `==` relation isn't transitive.)
internal func matches(_ other: Self) -> Bool {
guard self.name == other.name else { return false }
guard self.arguments.count == other.arguments.count else { return false }
for i in self.arguments.indices {
if self.arguments[i] is Wildcard || other.arguments[i] is Wildcard {
continue
}
guard self.arguments[i] == other.arguments[i] else { return false }
}
return true
}
}
#endif // ENABLE_MOCKING
// To aid debugging, force failures to fatal error
internal var forceFatalFailures = false
internal protocol TestCase {
// TODO: want a source location stack, more fidelity, kinds of stack entries, etc
var file: StaticString { get }
var line: UInt { get }
// TODO: Instead have an attribute to register a test in a allTests var, similar to the argument parser.
func runAllTests()
// Customization hook: add adornment to reported failure reason
// Defaut: reason or empty
func failureMessage(_ reason: String?) -> String
}
extension TestCase {
// Default implementation
func failureMessage(_ reason: String?) -> String { reason ?? "" }
func expectEqualSequence<S1: Sequence, S2: Sequence>(
_ expected: S1, _ actual: S2,
_ message: String? = nil
) where S1.Element: Equatable, S1.Element == S2.Element {
if !expected.elementsEqual(actual) {
defer { print("expected: \(expected)\n actual: \(actual)") }
fail(message)
}
}
func expectEqual<E: Equatable>(
_ expected: E, _ actual: E,
_ message: String? = nil
) {
if actual != expected {
defer { print("expected: \(expected)\n actual: \(actual)") }
fail(message)
}
}
func expectNotEqual<E: Equatable>(
_ expected: E, _ actual: E,
_ message: String? = nil
) {
if actual == expected {
defer { print("expected not equal: \(expected) and \(actual)") }
fail(message)
}
}
#if ENABLE_MOCKING
func expectMatch(
_ expected: Trace.Entry?, _ actual: Trace.Entry?,
_ message: String? = nil
) {
func check() -> Bool {
switch (expected, actual) {
case let (expected?, actual?):
return expected.matches(actual)
case (nil, nil):
return true
default:
return false
}
}
if !check() {
let e = expected.map { "\($0)" } ?? "nil"
let a = actual.map { "\($0)" } ?? "nil"
defer { print("expected: \(e)\n actual: \(a)") }
fail(message)
}
}
#endif // ENABLE_MOCKING
func expectNil<T>(
_ actual: T?,
_ message: String? = nil
) {
if actual != nil {
defer { print("expected nil: \(actual!)") }
fail(message)
}
}
func expectNotNil<T>(
_ actual: T?,
_ message: String? = nil
) {
if actual == nil {
defer { print("expected non-nil") }
fail(message)
}
}
func expectTrue(
_ actual: Bool,
_ message: String? = nil
) {
if !actual { fail(message) }
}
func expectFalse(
_ actual: Bool,
_ message: String? = nil
) {
if actual { fail(message) }
}
func fail(_ reason: String? = nil) {
XCTAssert(false, failureMessage(reason), file: file, line: line)
if forceFatalFailures {
fatalError(reason ?? "<no reason>")
}
}
}
#if ENABLE_MOCKING
internal struct MockTestCase: TestCase {
var file: StaticString
var line: UInt
var expected: Trace.Entry
var interruptBehavior: InterruptBehavior
var interruptable: Bool { return interruptBehavior == .interruptable }
internal enum InterruptBehavior {
// Retry the syscall on EINTR
case interruptable
// Cannot return EINTR
case noInterrupt
// Cannot error at all
case noError
}
var body: (_ retryOnInterrupt: Bool) throws -> ()
init(
_ file: StaticString = #file,
_ line: UInt = #line,
name: String,
_ interruptable: InterruptBehavior,
_ args: AnyHashable...,
body: @escaping (_ retryOnInterrupt: Bool) throws -> ()
) {
self.file = file
self.line = line
self.expected = Trace.Entry(name: name, args)
self.interruptBehavior = interruptable
self.body = body
}
func runAllTests() {
XCTAssertFalse(MockingDriver.enabled)
MockingDriver.withMockingEnabled { mocking in
// Make sure we completely match the trace queue
self.expectTrue(mocking.trace.isEmpty)
defer { self.expectTrue(mocking.trace.isEmpty) }
// Test our API mappings to the lower-level syscall invocation
do {
try body(true)
self.expectMatch(self.expected, mocking.trace.dequeue())
} catch {
self.fail()
}
// Non-error-ing syscalls shouldn't ever throw
guard interruptBehavior != .noError else {
do {
try body(interruptable)
self.expectMatch(self.expected, mocking.trace.dequeue())
try body(!interruptable)
self.expectMatch(self.expected, mocking.trace.dequeue())
} catch {
self.fail()
}
return
}
// Test interupt behavior. Interruptable calls will be told not to
// retry to catch the EINTR. Non-interruptable calls will be told to
// retry, to make sure they don't spin (e.g. if API changes to include
// interruptable)
do {
mocking.forceErrno = .always(errno: EINTR)
try body(!interruptable)
self.fail()
} catch Errno.interrupted {
// Success!
self.expectMatch(self.expected, mocking.trace.dequeue())
} catch {
self.fail()
}
// Force a limited number of EINTRs, and make sure interruptable functions
// retry that number of times. Non-interruptable functions should throw it.
do {
mocking.forceErrno = .counted(errno: EINTR, count: 3)
try body(interruptable)
self.expectMatch(self.expected, mocking.trace.dequeue()) // EINTR
self.expectMatch(self.expected, mocking.trace.dequeue()) // EINTR
self.expectMatch(self.expected, mocking.trace.dequeue()) // EINTR
self.expectMatch(self.expected, mocking.trace.dequeue()) // Success
} catch Errno.interrupted {
self.expectFalse(interruptable)
self.expectMatch(self.expected, mocking.trace.dequeue()) // EINTR
} catch {
self.fail()
}
}
}
}
#endif // ENABLE_MOCKING
internal func withWindowsPaths(enabled: Bool, _ body: () -> ()) {
_withWindowsPaths(enabled: enabled, body)
}
+89
View File
@@ -0,0 +1,89 @@
/*
This source file is part of the Swift System open source project
Copyright (c) 2021 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
*/
import XCTest
#if SYSTEM_PACKAGE
@testable import SystemPackage
#else
@testable import System
#endif
class UtilTests: XCTestCase {
func testStackBuffer() {
// Exercises _withStackBuffer a bit, in hopes any bugs will
// show up as ASan failures.
for size in stride(from: 0, to: 1000, by: 5) {
var called = false
_withStackBuffer(capacity: size) { buffer in
XCTAssertFalse(called)
called = true
buffer.initializeMemory(as: UInt8.self, repeating: 42)
}
XCTAssertTrue(called)
}
}
func testCStringArray() {
func check(
_ array: [String],
file: StaticString = #file,
line: UInt = #line
) {
array._withCStringArray { carray in
let actual = carray.map { $0.map { String(cString: $0) } ?? "<NULL>" }
XCTAssertEqual(actual, array, file: file, line: line)
// Verify that there is a null pointer following the last item in
// carray. (Note: this is intentionally addressing beyond the
// end of the buffer, as the function promises that is going to be okay.)
XCTAssertNil((carray.baseAddress! + carray.count).pointee)
}
}
check([])
check([""])
check(["", ""])
check(["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", ""])
// String literals of various sizes and counts
check(["hello"])
check(["hello", "world"])
check(["This is a rather large string literal"])
check([
"This is a rather large string literal",
"This is small",
"This one is not that small -- it's even longer than the first",
])
check([
"This is a rather large string literal",
"This one is not that small -- it's even longer than the first",
"And this is the largest of them all. I wonder if it even fits on a line"
])
check(Array(repeating: "", count: 100))
check(Array(repeating: "Hiii", count: 100))
check(["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"])
check(["", "b", "", "d", "", "f", "", "h", "", "j", "", "👨‍👨‍👧‍👦👩‍❤️‍💋‍👨", "m"])
var girls = ["Dörothy", "Róse", "Blánche", "Sőphia"]
check(girls) // Small strings
for i in girls.indices {
// Convert to native
girls[i] = "\(girls[i]) \(girls[i]) \(girls[i])"
}
check(girls) // Native large strings
for i in girls.indices {
let data = girls[i].data(using: .utf16)!
girls[i] = NSString(
data: data,
encoding: String.Encoding.utf16.rawValue
)! as String
}
check(girls) // UTF-16 Cocoa strings
}
}
-49
View File
@@ -1,49 +0,0 @@
#if !canImport(ObjectiveC)
import XCTest
extension ErrnoTest {
// DO NOT MODIFY: This is autogenerated, use:
// `swift test --generate-linuxmain`
// to regenerate.
static let __allTests__ErrnoTest = [
("testConstants", testConstants),
("testPatternMatching", testPatternMatching),
]
}
extension FileDescriptorTest {
// DO NOT MODIFY: This is autogenerated, use:
// `swift test --generate-linuxmain`
// to regenerate.
static let __allTests__FileDescriptorTest = [
("testConstants", testConstants),
]
}
extension FilePathTest {
// DO NOT MODIFY: This is autogenerated, use:
// `swift test --generate-linuxmain`
// to regenerate.
static let __allTests__FilePathTest = [
("testFilePath", testFilePath),
]
}
extension FilePermissionsTest {
// DO NOT MODIFY: This is autogenerated, use:
// `swift test --generate-linuxmain`
// to regenerate.
static let __allTests__FilePermissionsTest = [
("testPermissions", testPermissions),
]
}
public func __allTests() -> [XCTestCaseEntry] {
return [
testCase(ErrnoTest.__allTests__ErrnoTest),
testCase(FileDescriptorTest.__allTests__FileDescriptorTest),
testCase(FilePathTest.__allTests__FilePathTest),
testCase(FilePermissionsTest.__allTests__FilePermissionsTest),
]
}
#endif
+19
View File
@@ -0,0 +1,19 @@
#[[
This source file is part of the Swift System open source Project
Copyright (c) 2021 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
#]]
set(SWIFT_SYSTEM_EXPORTS_FILE ${CMAKE_CURRENT_BINARY_DIR}/SwiftSystemExports.cmake)
configure_file(SwiftSystemConfig.cmake.in
${CMAKE_CURRENT_BINARY_DIR}/SwiftSystemConfig.cmake)
get_property(SWIFT_SYSTEM_EXPORTS GLOBAL PROPERTY SWIFT_SYSTEM_EXPORTS)
export(TARGETS ${SWIFT_SYSTEM_EXPORTS}
NAMESPACE SwiftSystem::
FILE ${SWIFT_SYSTEM_EXPORTS_FILE}
EXPORT_LINK_INTERFACE_LIBRARIES)
+120
View File
@@ -0,0 +1,120 @@
#[[
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
#]]
# Returns the architecture name in a variable
#
# Usage:
# get_swift_host_arch(result_var_name)
#
# Sets ${result_var_name} with the converted architecture name derived from
# CMAKE_SYSTEM_PROCESSOR.
function(get_swift_host_arch result_var_name)
if("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "x86_64")
set("${result_var_name}" "x86_64" PARENT_SCOPE)
elseif ("${CMAKE_SYSTEM_PROCESSOR}" MATCHES "AArch64|aarch64|arm64|ARM64")
if(CMAKE_SYSTEM_NAME MATCHES Darwin)
set("${result_var_name}" "arm64" PARENT_SCOPE)
else()
set("${result_var_name}" "aarch64" PARENT_SCOPE)
endif()
elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "ppc64")
set("${result_var_name}" "powerpc64" PARENT_SCOPE)
elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "ppc64le")
set("${result_var_name}" "powerpc64le" PARENT_SCOPE)
elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "s390x")
set("${result_var_name}" "s390x" PARENT_SCOPE)
elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "armv6l")
set("${result_var_name}" "armv6" PARENT_SCOPE)
elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "armv7l")
set("${result_var_name}" "armv7" PARENT_SCOPE)
elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "armv7-a")
set("${result_var_name}" "armv7" PARENT_SCOPE)
elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "amd64")
set("${result_var_name}" "x86_64" PARENT_SCOPE)
elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "AMD64")
set("${result_var_name}" "x86_64" PARENT_SCOPE)
elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "IA64")
set("${result_var_name}" "itanium" PARENT_SCOPE)
elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "x86")
set("${result_var_name}" "i686" PARENT_SCOPE)
elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "i686")
set("${result_var_name}" "i686" PARENT_SCOPE)
elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "riscv64")
set("${result_var_name}" "riscv64" PARENT_SCOPE)
else()
message(FATAL_ERROR "Unrecognized architecture on host system: ${CMAKE_SYSTEM_PROCESSOR}")
endif()
endfunction()
# Returns the os name in a variable
#
# Usage:
# get_swift_host_os(result_var_name)
#
#
# Sets ${result_var_name} with the converted OS name derived from
# CMAKE_SYSTEM_NAME.
function(get_swift_host_os result_var_name)
if(CMAKE_SYSTEM_NAME STREQUAL Darwin)
set(${result_var_name} macosx PARENT_SCOPE)
else()
string(TOLOWER ${CMAKE_SYSTEM_NAME} cmake_system_name_lc)
set(${result_var_name} ${cmake_system_name_lc} PARENT_SCOPE)
endif()
endfunction()
if(NOT Swift_MODULE_TRIPLE)
# Attempt to get the module triple from the Swift compiler.
set(module_triple_command "${CMAKE_Swift_COMPILER}" -print-target-info)
if(CMAKE_Swift_COMPILER_TARGET)
list(APPEND module_triple_command -target ${CMAKE_Swift_COMPILER_TARGET})
endif()
execute_process(COMMAND ${module_triple_command}
OUTPUT_VARIABLE target_info_json)
string(JSON module_triple GET "${target_info_json}" "target" "moduleTriple")
# Exit now if we failed to infer the triple.
if(NOT module_triple)
message(FATAL_ERROR
"Failed to get module triple from Swift compiler. "
"Compiler output: ${target_info_json}")
endif()
# Cache the module triple for future use.
set(Swift_MODULE_TRIPLE "${module_triple}" CACHE STRING "swift module triple used for installed swiftmodule and swiftinterface files")
mark_as_advanced(Swift_MODULE_TRIPLE)
endif()
function(_install_target module)
get_swift_host_os(swift_os)
get_target_property(type ${module} TYPE)
if(type STREQUAL STATIC_LIBRARY)
set(swift swift_static)
else()
set(swift swift)
endif()
install(TARGETS ${module})
if(type STREQUAL EXECUTABLE)
return()
endif()
get_target_property(module_name ${module} Swift_MODULE_NAME)
if(NOT module_name)
set(module_name ${module})
endif()
install(FILES $<TARGET_PROPERTY:${module},Swift_MODULE_DIRECTORY>/${module_name}.swiftdoc
DESTINATION ${CMAKE_INSTALL_LIBDIR}/${swift}/${swift_os}/${module_name}.swiftmodule
RENAME ${Swift_MODULE_TRIPLE}.swiftdoc)
install(FILES $<TARGET_PROPERTY:${module},Swift_MODULE_DIRECTORY>/${module_name}.swiftmodule
DESTINATION ${CMAKE_INSTALL_LIBDIR}/${swift}/${swift_os}/${module_name}.swiftmodule
RENAME ${Swift_MODULE_TRIPLE}.swiftmodule)
endfunction()
+12
View File
@@ -0,0 +1,12 @@
#[[
This source file is part of the Swift System open source Project
Copyright (c) 2021 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
#]]
if(NOT TARGET SystemPackage)
include("@SWIFT_SYSTEM_EXPORTS_FILE@")
endif()