Function alloc_perry_string

native/watchos/src/lib.rs:58–87

Allocate a Perry-side heap string (StringHeader + UTF-8 payload) and return its pointer as the i64 the FFI boundary expects. Mirrors `perry_str`'s layout so a string we hand back is read identically to one Perry passed us. Returning this (never 0) for a `returns:"string"` function is mandatory: Perry's inline `.length` dereferences the pointer, so a null segfaults the caller.

(s: &str)

/// Perry's inline `.length` dereferences the pointer, so a null segfaults the
/// caller.
fn alloc_perry_string(s: &str) -> i64 {
    let bytes = s.as_bytes();
    let byte_len = bytes.len();
    let utf16_len = if bytes.iter().all(|&b| b < 0x80) {
        byte_len
    } else {
        s.encode_utf16().count()
    };
    // A value RETURNED across the FFI boundary is consumed by Perry's internal
    // string machinery, whose canonical StringHeader is 5×u32 = 20 bytes
    // (utf16_len, byte_len, capacity, refcount, flags) with data at +20.
    // (The local 16-byte `StringHeader`/`perry_str` above describe the *incoming*
    // arg representation, which omits `flags`; don't conflate the two.)
    const HEADER_SIZE: usize = 20;
    let total = HEADER_SIZE + byte_len;
    unsafe {
        let layout = std::alloc::Layout::from_size_align(total, 4).unwrap();
        let ptr = std::alloc::alloc(layout);
        if ptr.is_null() {
            return 0;
        }
        *(ptr.add(0) as *mut u32) = utf16_len as u32;
        *(ptr.add(4) as *mut u32) = byte_len as u32;
        *(ptr.add(8) as *mut u32) = byte_len as u32; // capacity
        *(ptr.add(12) as *mut u32) = 1; // refcount = unique
        *(ptr.add(16) as *mut u32) = 0; // flags
        std::ptr::copy_nonoverlapping(bytes.as_ptr(), ptr.add(HEADER_SIZE), byte_len);
        ptr as i64
    }
}

use std::ffi::{c_char, c_void};
use std::sync::atomic::{AtomicI64, AtomicU64, AtomicUsize, Ordering};