Restructured the source code in the Playdate bindings target.

2026-07-25 12:40:14 +02:00
parent 2e7ee12ec1
commit b435a6e8bd
106 changed files with 3754 additions and 3746 deletions
@@ -0,0 +1,103 @@
+internal import CPlaydate
+
+extension File {
+    /// An open file. Wraps `SDFile`. The file is closed on deinit if it has
+    /// not been closed explicitly.
+    public final class Handle {
+        let pointer: UnsafeMutableRawPointer
+        private var isClosed = false
+
+        /// Opens the file at `path`.
+        public init(path: String, mode: Options) throws(PlaydateError) {
+            let pointer = path.withPlaydateCString {
+                fileAPI.pointee.open.unsafelyUnwrapped($0, mode.cValue)
+            }
+            guard let pointer else { throw lastFileError() }
+            self.pointer = pointer
+        }
+
+        deinit {
+            if !isClosed {
+                _ = fileAPI.pointee.close.unsafelyUnwrapped(pointer)
+            }
+        }
+
+        /// Closes the file. Further operations are invalid.
+        public func close() throws(PlaydateError) {
+            guard !isClosed else { return }
+            isClosed = true
+            if fileAPI.pointee.close.unsafelyUnwrapped(pointer) != 0 { throw lastFileError() }
+        }
+
+        /// Reads up to `buffer.count` bytes into `buffer`. Returns the number
+        /// of bytes read; 0 indicates end of file.
+        public func read(into buffer: UnsafeMutableRawBufferPointer) throws(PlaydateError) -> Int {
+            let result = fileAPI.pointee.read.unsafelyUnwrapped(
+                pointer, buffer.baseAddress, UInt32(buffer.count))
+            if result < 0 { throw lastFileError() }
+            return Int(result)
+        }
+
+        /// Reads up to `length` bytes and returns them.
+        public func read(length: Int) throws(PlaydateError) -> [UInt8] {
+            var bytes = [UInt8](repeating: 0, count: length)
+            let result = bytes.withUnsafeMutableBytes { buffer in
+                fileAPI.pointee.read.unsafelyUnwrapped(pointer, buffer.baseAddress, UInt32(buffer.count))
+            }
+            if result < 0 { throw lastFileError() }
+            bytes.removeLast(length - Int(result))
+            return bytes
+        }
+
+        /// Writes the buffer to the file. Returns the number of bytes written.
+        @discardableResult
+        public func write(_ buffer: UnsafeRawBufferPointer) throws(PlaydateError) -> Int {
+            let result = fileAPI.pointee.write.unsafelyUnwrapped(
+                pointer, buffer.baseAddress, UInt32(buffer.count))
+            if result < 0 { throw lastFileError() }
+            return Int(result)
+        }
+
+        /// Writes the bytes to the file. Returns the number of bytes written.
+        @discardableResult
+        public func write(_ bytes: [UInt8]) throws(PlaydateError) -> Int {
+            let result = bytes.withUnsafeBytes { buffer in
+                fileAPI.pointee.write.unsafelyUnwrapped(pointer, buffer.baseAddress, UInt32(buffer.count))
+            }
+            if result < 0 { throw lastFileError() }
+            return Int(result)
+        }
+
+        /// Writes the string's UTF-8 to the file. Returns the bytes written.
+        @discardableResult
+        public func write(_ string: String) throws(PlaydateError) -> Int {
+            let result = string.withPlaydateUTF8 { bytes, count in
+                fileAPI.pointee.write.unsafelyUnwrapped(pointer, bytes, UInt32(count))
+            }
+            if result < 0 { throw lastFileError() }
+            return Int(result)
+        }
+
+        /// Flushes buffered writes to disk. Returns the bytes written.
+        @discardableResult
+        public func flush() throws(PlaydateError) -> Int {
+            let result = fileAPI.pointee.flush.unsafelyUnwrapped(pointer)
+            if result < 0 { throw lastFileError() }
+            return Int(result)
+        }
+
+        /// The current read/write offset.
+        public func tell() throws(PlaydateError) -> Int {
+            let result = fileAPI.pointee.tell.unsafelyUnwrapped(pointer)
+            if result < 0 { throw lastFileError() }
+            return Int(result)
+        }
+
+        /// Moves the read/write offset to `offset` relative to `origin`.
+        public func seek(to offset: Int, from origin: SeekOrigin = .start) throws(PlaydateError) {
+            if fileAPI.pointee.seek.unsafelyUnwrapped(pointer, Int32(offset), origin.rawValue) != 0 {
+                throw lastFileError()
+            }
+        }
+    }
+}
@@ -0,0 +1,8 @@
+extension File {
+    /// The origin used by `Handle.seek(to:from:)`.
+    public enum SeekOrigin: Int32, Sendable {
+        case start = 0
+        case current = 1
+        case end = 2
+    }
+}
@@ -0,0 +1,73 @@
+internal import CPlaydate
+
+var fileAPI: UnsafePointer<playdate_file> { Playdate.fileAPI.unsafelyUnwrapped }
+
+/// The most recent file system error as a thrown error.
+func lastFileError() -> PlaydateError {
+    PlaydateError(cString: fileAPI.pointee.geterr.unsafelyUnwrapped())
+}
+
+/// The file API: access to the game's Data directory and pdx contents.
+public enum File {}
+
+extension File {
+    // MARK: - Directory operations
+
+    /// Calls `each` with the name of every file in `path`. Subdirectory names
+    /// end in a slash. Throws if the directory does not exist.
+    public static func listFiles(at path: String, showHidden: Bool = false,
+                                 _ each: (String) -> Void) throws(PlaydateError) {
+        let result = withoutActuallyEscaping(each) { each in
+            var callback = each
+            return path.withPlaydateCString { cPath in
+                withUnsafeMutablePointer(to: &callback) { callbackPointer in
+                    fileAPI.pointee.listfiles.unsafelyUnwrapped(cPath, { cName, userdata in
+                        guard let cName, let userdata else { return }
+                        let each = userdata.assumingMemoryBound(to: ((String) -> Void).self).pointee
+                        each(String(playdateCString: cName))
+                    }, callbackPointer, showHidden ? 1 : 0)
+                }
+            }
+        }
+        if result != 0 { throw lastFileError() }
+    }
+
+    /// Information about the file or directory at `path`.
+    public static func stat(_ path: String) throws(PlaydateError) -> Stat {
+        var stat = FileStat()
+        let result = path.withPlaydateCString { fileAPI.pointee.stat.unsafelyUnwrapped($0, &stat) }
+        if result != 0 { throw lastFileError() }
+        return Stat(
+            isDirectory: stat.isdir != 0,
+            size: stat.size,
+            modified: System.DateTime(
+                year: UInt16(stat.m_year), month: UInt8(stat.m_month), day: UInt8(stat.m_day),
+                hour: UInt8(stat.m_hour), minute: UInt8(stat.m_minute), second: UInt8(stat.m_second)))
+    }
+
+    /// Creates a directory (and intermediate directories) in the Data directory.
+    public static func mkdir(_ path: String) throws(PlaydateError) {
+        let result = path.withPlaydateCString { fileAPI.pointee.mkdir.unsafelyUnwrapped($0) }
+        if result != 0 { throw lastFileError() }
+    }
+
+    /// Deletes the file or directory at `path`. Directories require
+    /// `recursive` to be deleted with their contents.
+    public static func unlink(_ path: String, recursive: Bool = false) throws(PlaydateError) {
+        let result = path.withPlaydateCString {
+            fileAPI.pointee.unlink.unsafelyUnwrapped($0, recursive ? 1 : 0)
+        }
+        if result != 0 { throw lastFileError() }
+    }
+
+    /// Renames (moves) a file in the Data directory, overwriting any existing
+    /// file at the destination.
+    public static func rename(from: String, to: String) throws(PlaydateError) {
+        let result = from.withPlaydateCString { cFrom in
+            to.withPlaydateCString { cTo in
+                fileAPI.pointee.rename.unsafelyUnwrapped(cFrom, cTo)
+            }
+        }
+        if result != 0 { throw lastFileError() }
+    }
+}
@@ -0,0 +1,20 @@
+internal import CPlaydate
+
+extension File {
+    /// How to open a file.
+    public struct Options: OptionSet, Sendable {
+        public let rawValue: UInt32
+        public init(rawValue: UInt32) { self.rawValue = rawValue }
+
+        /// Read from the game pdx, then the Data directory.
+        public static let read = Options(rawValue: UInt32(kFileRead.rawValue))
+        /// Read from the Data directory only.
+        public static let readData = Options(rawValue: UInt32(kFileReadData.rawValue))
+        /// Write to the Data directory, truncating an existing file.
+        public static let write = Options(rawValue: UInt32(kFileWrite.rawValue))
+        /// Write to the Data directory, appending to an existing file.
+        public static let append = Options(rawValue: UInt32(kFileAppend.rawValue))
+
+        var cValue: FileOptions { FileOptions(FileOptions.RawValue(rawValue)) }
+    }
+}
@@ -0,0 +1,8 @@
+extension File {
+    /// Information about a file or directory, mirroring `FileStat`.
+    public struct Stat: Sendable {
+        public let isDirectory: Bool
+        public let size: UInt32
+        public let modified: System.DateTime
+    }
+}