Something went wrong. Try again.
Jam Programming Language jamlang.org
compiler
Something went wrong. Try again.
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071// Built-in `asPtr` / `asMutPtr` methods on `[N]T` arrays.// Modeled on Rust's `[T; N]::as_ptr` / `as_mut_ptr`: the method// name picks the mutability of the returned pointer; the body// is a single bitcast of the array's storage address to a// `PtrMany(elem)`. No `&arr[0]` and no `as`-cast at call sites.//// Jam doesn't track const-vs-mut at the pointer-type level today// (both `*const[] T` and `*mut[] T` intern as the same TypeIdx),// so the two methods produce structurally identical values; the// name encodes intent only. Once pointer-mutability is enforced,// `asPtr` will narrow to `*const[] T` and `asMutPtr` stays mut.
const { assert } = import("test");
extern fn write(fd: i32, buf: *const[] u8, count: u64) i64;
fn loadFirstByteConst(p: *const[] u8) u8 { return p[0];}
fn writeThirdByteMut(p: *mut[] u8, v: u8) { p[2] = v;}
tfn asPtrPassesArrayAddressToFFI() { // `asPtr` is the FFI-facing read-only variant. The result is // assignable to a *const[] u8 param without any further cast. var arr: [3]u8 = [10, 20, 30]; assert(loadFirstByteConst(arr.asPtr()) as i32, 10);}
tfn asMutPtrAllowsWriteThroughThePointer() { // `asMutPtr` is the FFI-facing read-write variant. Writes // through the returned pointer are visible on the original // array — confirms the call returns the storage address, not // a copy. var arr: [4]u8 = [0; 4]; writeThirdByteMut(arr.asMutPtr(), 99); assert(arr[2] as i32, 99);}
tfn asPtrZeroOverhead() { // Several `asPtr` calls in a row should each yield the same // base address (no spilling, no allocation). We confirm // indirectly: a read via the second call sees the write // through the first. var arr: [2]u8 = [0; 2]; var p: *mut[] u8 = arr.asMutPtr(); p[0] = 42; var q: *const[] u8 = arr.asPtr(); assert(q[0] as i32, 42);}
tfn asPtrOnLargerType() { // Different element type — verifies the bitcast targets the // right `PtrMany(elem)` based on the array's element TypeIdx. var arr: [4]i32 = [100, 200, 300, 400]; var p: *const[] i32 = arr.asPtr(); assert(p[0], 100); assert(p[3], 400);}
tfn asPtrAfterMutationVisible() { // Mutation through `[i] = …` and read through `asPtr()` see // the same memory. var arr: [3]u8 = [1, 2, 3]; arr[1] = 9; var p: *const[] u8 = arr.asPtr(); assert(p[1] as i32, 9);}