javierandClaude Fable 5
d914e0f8fb
Two hot-path optimizations for the device's Cortex-M7 (and debug simulator builds): - The ten sub-API pointers are cached once in Playdate.initialize(with:); wrapper accessors now return UnsafePointer and call sites read a single field through it, instead of unwrapping the optional API struct and copying a whole sub-API struct of function pointers on every call. Nested sub-APIs (sound classes, effects, video, tilemap, http/tcp) derive from the cached pointers with one field load. - String -> C conversions (withPlaydateCString, and a new withPlaydateUTF8 used by the text drawing/measuring APIs) use withUnsafeTemporaryAllocation instead of building a ContiguousArray, so logging and drawText in the update loop no longer heap-allocate per call. Verified within the Embedded Swift subset by the device cross-compile. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
70 lines
2.7 KiB
Swift
70 lines
2.7 KiB
Swift
//
|
|
// Support.swift
|
|
// Internal helpers shared by the wrappers.
|
|
//
|
|
// C-string conversions are implemented manually (rather than with
|
|
// `String(cString:)` / `withCString`) so the module stays within the
|
|
// Embedded Swift subset used for device builds.
|
|
//
|
|
|
|
internal import CPlaydate
|
|
|
|
extension String {
|
|
/// Creates a string by copying a null-terminated UTF-8 C string.
|
|
init(playdateCString pointer: UnsafePointer<CChar>) {
|
|
var count = 0
|
|
while pointer[count] != 0 { count += 1 }
|
|
let bytes = UnsafeRawBufferPointer(start: pointer, count: count)
|
|
self = String(decoding: bytes, as: UTF8.self)
|
|
}
|
|
|
|
/// Creates a string from a nullable C string, or `nil` if the pointer is null.
|
|
init?(playdateCString pointer: UnsafePointer<CChar>?) {
|
|
guard let pointer else { return nil }
|
|
self.init(playdateCString: pointer)
|
|
}
|
|
|
|
/// Calls `body` with a temporary null-terminated UTF-8 copy of the
|
|
/// string. The copy lives on the stack for short strings, so calling
|
|
/// this in the update loop does not churn the heap.
|
|
func withPlaydateCString<Result>(_ body: (UnsafePointer<CChar>) -> Result) -> Result {
|
|
let count = utf8.count
|
|
return withUnsafeTemporaryAllocation(of: CChar.self, capacity: count + 1) { buffer in
|
|
var index = 0
|
|
for byte in utf8 {
|
|
buffer[index] = CChar(bitPattern: byte)
|
|
index += 1
|
|
}
|
|
buffer[count] = 0
|
|
return body(buffer.baseAddress.unsafelyUnwrapped)
|
|
}
|
|
}
|
|
|
|
/// Calls `body` with a temporary buffer of the string's UTF-8 bytes (not
|
|
/// null-terminated) and its length, for the `(const void*, size_t)` text
|
|
/// APIs. Stack-allocated for short strings.
|
|
func withPlaydateUTF8<Result>(_ body: (UnsafeRawPointer, Int) -> Result) -> Result {
|
|
let count = utf8.count
|
|
return withUnsafeTemporaryAllocation(of: UInt8.self, capacity: count + 1) { buffer in
|
|
var index = 0
|
|
for byte in utf8 {
|
|
buffer[index] = byte
|
|
index += 1
|
|
}
|
|
return body(UnsafeRawPointer(buffer.baseAddress.unsafelyUnwrapped), count)
|
|
}
|
|
}
|
|
|
|
/// Copies the string into a newly allocated null-terminated C string.
|
|
/// The caller owns the memory and must free it with `deallocate()`.
|
|
func copiedPlaydateCString() -> UnsafeMutablePointer<CChar> {
|
|
let utf8 = ContiguousArray(self.utf8)
|
|
let buffer = UnsafeMutablePointer<CChar>.allocate(capacity: utf8.count + 1)
|
|
for (index, byte) in utf8.enumerated() {
|
|
buffer[index] = CChar(bitPattern: byte)
|
|
}
|
|
buffer[utf8.count] = 0
|
|
return buffer
|
|
}
|
|
}
|