@salang/sa 0.1.3 → 0.1.4

package/sa_std/sync/rwlock.sa

@@ -0,0 +1,369 @@
+@import "rwlock.sal"
+@import "../time.sai"
+
+@__rwlock_release_read(lock: ptr) -> void:
+L_ENTRY:
+    readers = atomic_load lock+RwLock_readers as i32 acquire
+    had_reader = sgt readers, 0
+    br had_reader -> L_RELEASE_CLAIM, L_RELEASE_UNDERFLOW
+
+L_RELEASE_CLAIM:
+    next_readers = sub readers, 1
+    old_readers, released = cmpxchg lock+RwLock_readers, readers, next_readers as i32 acq_rel acquire
+    br released -> L_RELEASE_OK, L_RELEASE_RETRY
+
+L_RELEASE_RETRY:
+    !released
+    !old_readers
+    !next_readers
+    !had_reader
+    !readers
+    jmp L_ENTRY
+
+L_RELEASE_UNDERFLOW:
+    !had_reader
+    !readers
+    panic(1601)
+
+L_RELEASE_OK:
+    !released
+    !old_readers
+    !next_readers
+    !had_reader
+    !readers
+    !lock
+    return
+
+[MACRO] RWLOCK_NEW %out_lock
+    %out_lock = alloc RwLock_SIZE
+    store %out_lock+RwLock_readers, 0 as i32
+    store %out_lock+RwLock_writing, 0 as i32
+[END_MACRO]
+
+[MACRO] RWLOCK_NEW_I32 %out_lock, %value
+    %out_lock = alloc RwLockI32_SIZE
+    store %out_lock+RwLock_readers, 0 as i32
+    store %out_lock+RwLock_writing, 0 as i32
+    store %out_lock+RwLock_data, %value as i32
+[END_MACRO]
+
+[MACRO] RWLOCK_READER_COUNT %out_count, %lock_reg
+    %out_count = atomic_load %lock_reg+RwLock_readers as i32 acquire
+[END_MACRO]
+
+[MACRO] RWLOCK_IS_WRITING %out_bool, %lock_reg
+    __rwlock_writing_state_%out_bool = atomic_load %lock_reg+RwLock_writing as i32 acquire
+    %out_bool = ne __rwlock_writing_state_%out_bool, 0
+    !__rwlock_writing_state_%out_bool
+[END_MACRO]
+
+[MACRO] RWLOCK_IS_UNLOCKED %out_bool, %lock_reg
+    __rwlock_readers_state_%out_bool = atomic_load %lock_reg+RwLock_readers as i32 acquire
+    __rwlock_writing_state_%out_bool = atomic_load %lock_reg+RwLock_writing as i32 acquire
+    __rwlock_no_readers_%out_bool = eq __rwlock_readers_state_%out_bool, 0
+    __rwlock_no_writer_%out_bool = eq __rwlock_writing_state_%out_bool, 0
+    %out_bool = and __rwlock_no_readers_%out_bool, __rwlock_no_writer_%out_bool
+    !__rwlock_no_writer_%out_bool
+    !__rwlock_no_readers_%out_bool
+    !__rwlock_writing_state_%out_bool
+    !__rwlock_readers_state_%out_bool
+[END_MACRO]
+
+[MACRO] RWLOCK_TRY_READ_NOERR %out_ok, %out_guard, %lock_reg
+    __rwlock_read_ok_slot_%out_ok = alloc 8
+    __rwlock_read_guard_slot_%out_ok = alloc 8
+    __rwlock_read_writing_%out_ok = atomic_load %lock_reg+RwLock_writing as i32 acquire
+    __rwlock_read_can_read_%out_ok = eq __rwlock_read_writing_%out_ok, 0
+    br __rwlock_read_can_read_%out_ok -> L_RWLOCK_READ_NOERR_OK_%out_ok, L_RWLOCK_READ_NOERR_FAIL_%out_ok
+L_RWLOCK_READ_NOERR_OK_%out_ok:
+    __rwlock_read_old_%out_ok = atomic_rmw_add %lock_reg+RwLock_readers, 1 as i32 acq_rel
+    __rwlock_read_after_writing_%out_ok = atomic_load %lock_reg+RwLock_writing as i32 acquire
+    __rwlock_read_still_ok_%out_ok = eq __rwlock_read_after_writing_%out_ok, 0
+    br __rwlock_read_still_ok_%out_ok -> L_RWLOCK_READ_NOERR_COMMIT_%out_ok, L_RWLOCK_READ_NOERR_ROLLBACK_%out_ok
+L_RWLOCK_READ_NOERR_COMMIT_%out_ok:
+    store __rwlock_read_guard_slot_%out_ok+0, %lock_reg as ptr
+    store __rwlock_read_ok_slot_%out_ok+0, 1 as u64
+    !__rwlock_read_still_ok_%out_ok
+    !__rwlock_read_after_writing_%out_ok
+    !__rwlock_read_old_%out_ok
+    jmp L_RWLOCK_READ_NOERR_DONE_%out_ok
+L_RWLOCK_READ_NOERR_ROLLBACK_%out_ok:
+    __rwlock_read_rollback_%out_ok = atomic_rmw_sub %lock_reg+RwLock_readers, 1 as i32 acq_rel
+    store __rwlock_read_guard_slot_%out_ok+0, 0 as ptr
+    store __rwlock_read_ok_slot_%out_ok+0, 0 as u64
+    !__rwlock_read_rollback_%out_ok
+    !__rwlock_read_still_ok_%out_ok
+    !__rwlock_read_after_writing_%out_ok
+    !__rwlock_read_old_%out_ok
+    jmp L_RWLOCK_READ_NOERR_DONE_%out_ok
+L_RWLOCK_READ_NOERR_FAIL_%out_ok:
+    store __rwlock_read_guard_slot_%out_ok+0, 0 as ptr
+    store __rwlock_read_ok_slot_%out_ok+0, 0 as u64
+    jmp L_RWLOCK_READ_NOERR_DONE_%out_ok
+L_RWLOCK_READ_NOERR_DONE_%out_ok:
+    %out_guard = load __rwlock_read_guard_slot_%out_ok+0 as ptr
+    %out_ok = load __rwlock_read_ok_slot_%out_ok+0 as u64
+    !__rwlock_read_guard_slot_%out_ok
+    !__rwlock_read_ok_slot_%out_ok
+    !__rwlock_read_can_read_%out_ok
+    !__rwlock_read_writing_%out_ok
+[END_MACRO]
+
+[MACRO] RWLOCK_TRY_WRITE_NOERR %out_ok, %out_guard, %lock_reg
+    __rwlock_write_ok_slot_%out_ok = alloc 8
+    __rwlock_write_guard_slot_%out_ok = alloc 8
+    __rwlock_write_writing_%out_ok, __rwlock_write_claim_ok_%out_ok = cmpxchg %lock_reg+RwLock_writing, 0, 1 as i32 acq_rel acquire
+    br __rwlock_write_claim_ok_%out_ok -> L_RWLOCK_WRITE_NOERR_CLAIMED_%out_ok, L_RWLOCK_WRITE_NOERR_FAIL_%out_ok
+L_RWLOCK_WRITE_NOERR_CLAIMED_%out_ok:
+    __rwlock_write_readers_%out_ok = atomic_load %lock_reg+RwLock_readers as i32 acquire
+    __rwlock_write_no_readers_%out_ok = eq __rwlock_write_readers_%out_ok, 0
+    br __rwlock_write_no_readers_%out_ok -> L_RWLOCK_WRITE_NOERR_OK_%out_ok, L_RWLOCK_WRITE_NOERR_ROLLBACK_%out_ok
+L_RWLOCK_WRITE_NOERR_OK_%out_ok:
+    store __rwlock_write_guard_slot_%out_ok+0, %lock_reg as ptr
+    store __rwlock_write_ok_slot_%out_ok+0, 1 as u64
+    !__rwlock_write_no_readers_%out_ok
+    !__rwlock_write_readers_%out_ok
+    jmp L_RWLOCK_WRITE_NOERR_DONE_%out_ok
+L_RWLOCK_WRITE_NOERR_ROLLBACK_%out_ok:
+    atomic_store %lock_reg+RwLock_writing, 0 as i32 release
+    store __rwlock_write_guard_slot_%out_ok+0, 0 as ptr
+    store __rwlock_write_ok_slot_%out_ok+0, 0 as u64
+    !__rwlock_write_no_readers_%out_ok
+    !__rwlock_write_readers_%out_ok
+    jmp L_RWLOCK_WRITE_NOERR_DONE_%out_ok
+L_RWLOCK_WRITE_NOERR_FAIL_%out_ok:
+    store __rwlock_write_guard_slot_%out_ok+0, 0 as ptr
+    store __rwlock_write_ok_slot_%out_ok+0, 0 as u64
+    jmp L_RWLOCK_WRITE_NOERR_DONE_%out_ok
+L_RWLOCK_WRITE_NOERR_DONE_%out_ok:
+    %out_guard = load __rwlock_write_guard_slot_%out_ok+0 as ptr
+    %out_ok = load __rwlock_write_ok_slot_%out_ok+0 as u64
+    !__rwlock_write_guard_slot_%out_ok
+    !__rwlock_write_ok_slot_%out_ok
+    !__rwlock_write_claim_ok_%out_ok
+    !__rwlock_write_writing_%out_ok
+[END_MACRO]
+
+[MACRO] RWLOCK_TRY_READ %out_ok, %out_guard, %lock_reg, %err_label
+    __rwlock_writing_%out_ok = atomic_load %lock_reg+RwLock_writing as i32 acquire
+    __rwlock_can_read_%out_ok = eq __rwlock_writing_%out_ok, 0
+    br __rwlock_can_read_%out_ok -> L_RWLOCK_TRY_READ_OK_%out_ok, L_RWLOCK_TRY_READ_FAIL_%out_ok
+L_RWLOCK_TRY_READ_OK_%out_ok:
+    __rwlock_readers_%out_ok = atomic_rmw_add %lock_reg+RwLock_readers, 1 as i32 acq_rel
+    __rwlock_after_writing_%out_ok = atomic_load %lock_reg+RwLock_writing as i32 acquire
+    __rwlock_still_can_read_%out_ok = eq __rwlock_after_writing_%out_ok, 0
+    br __rwlock_still_can_read_%out_ok -> L_RWLOCK_TRY_READ_COMMIT_%out_ok, L_RWLOCK_TRY_READ_ROLLBACK_%out_ok
+L_RWLOCK_TRY_READ_COMMIT_%out_ok:
+    %out_guard = add %lock_reg, 0
+    %out_ok = add 0, 1
+    !__rwlock_still_can_read_%out_ok
+    !__rwlock_after_writing_%out_ok
+    !__rwlock_can_read_%out_ok
+    !__rwlock_writing_%out_ok
+    !__rwlock_readers_%out_ok
+    jmp L_RWLOCK_TRY_READ_END_%out_ok
+L_RWLOCK_TRY_READ_ROLLBACK_%out_ok:
+    __rwlock_rollback_%out_ok = atomic_rmw_sub %lock_reg+RwLock_readers, 1 as i32 acq_rel
+    %out_guard = add 0, 0
+    %out_ok = add 0, 0
+    !__rwlock_rollback_%out_ok
+    !__rwlock_still_can_read_%out_ok
+    !__rwlock_after_writing_%out_ok
+    !__rwlock_can_read_%out_ok
+    !__rwlock_writing_%out_ok
+    !__rwlock_readers_%out_ok
+    jmp %err_label
+L_RWLOCK_TRY_READ_FAIL_%out_ok:
+    %out_guard = add 0, 0
+    %out_ok = add 0, 0
+    !__rwlock_can_read_%out_ok
+    !__rwlock_writing_%out_ok
+    jmp %err_label
+L_RWLOCK_TRY_READ_END_%out_ok:
+[END_MACRO]
+
+[MACRO] RWLOCK_TRY_WRITE %out_ok, %out_guard, %lock_reg, %err_label
+    __rwlock_writing_%out_ok, __rwlock_claim_ok_%out_ok = cmpxchg %lock_reg+RwLock_writing, 0, 1 as i32 acq_rel acquire
+    br __rwlock_claim_ok_%out_ok -> L_RWLOCK_TRY_WRITE_CLAIMED_%out_ok, L_RWLOCK_TRY_WRITE_FAIL_%out_ok
+L_RWLOCK_TRY_WRITE_CLAIMED_%out_ok:
+    __rwlock_readers_%out_ok = atomic_load %lock_reg+RwLock_readers as i32 acquire
+    __rwlock_no_readers_%out_ok = eq __rwlock_readers_%out_ok, 0
+    br __rwlock_no_readers_%out_ok -> L_RWLOCK_TRY_WRITE_OK_%out_ok, L_RWLOCK_TRY_WRITE_ROLLBACK_%out_ok
+L_RWLOCK_TRY_WRITE_OK_%out_ok:
+    %out_guard = add %lock_reg, 0
+    %out_ok = add 0, 1
+    !__rwlock_no_readers_%out_ok
+    !__rwlock_readers_%out_ok
+    !__rwlock_writing_%out_ok
+    !__rwlock_claim_ok_%out_ok
+    jmp L_RWLOCK_TRY_WRITE_END_%out_ok
+L_RWLOCK_TRY_WRITE_ROLLBACK_%out_ok:
+    atomic_store %lock_reg+RwLock_writing, 0 as i32 release
+    %out_guard = add 0, 0
+    %out_ok = add 0, 0
+    !__rwlock_no_readers_%out_ok
+    !__rwlock_readers_%out_ok
+    !__rwlock_writing_%out_ok
+    !__rwlock_claim_ok_%out_ok
+    jmp %err_label
+L_RWLOCK_TRY_WRITE_FAIL_%out_ok:
+    %out_guard = add 0, 0
+    %out_ok = add 0, 0
+    !__rwlock_writing_%out_ok
+    !__rwlock_claim_ok_%out_ok
+    jmp %err_label
+L_RWLOCK_TRY_WRITE_END_%out_ok:
+[END_MACRO]
+
+[MACRO] RWLOCK_RELEASE_READ %lock_reg
+    call @__rwlock_release_read(%lock_reg)
+[END_MACRO]
+
+[MACRO] RWLOCK_TRY_RELEASE_READ %out_ok, %lock_reg
+L_RWLOCK_TRY_RELEASE_READ_ENTRY_%out_ok:
+    __rwlock_try_release_read_state_%out_ok = atomic_load %lock_reg+RwLock_readers as i32 acquire
+    __rwlock_try_release_read_has_%out_ok = sgt __rwlock_try_release_read_state_%out_ok, 0
+    br __rwlock_try_release_read_has_%out_ok -> L_RWLOCK_TRY_RELEASE_READ_CLAIM_%out_ok, L_RWLOCK_TRY_RELEASE_READ_EMPTY_%out_ok
+L_RWLOCK_TRY_RELEASE_READ_CLAIM_%out_ok:
+    __rwlock_try_release_read_next_%out_ok = sub __rwlock_try_release_read_state_%out_ok, 1
+    __rwlock_try_release_read_old_%out_ok, %out_ok = cmpxchg %lock_reg+RwLock_readers, __rwlock_try_release_read_state_%out_ok, __rwlock_try_release_read_next_%out_ok as i32 acq_rel acquire
+    br %out_ok -> L_RWLOCK_TRY_RELEASE_READ_DONE_%out_ok, L_RWLOCK_TRY_RELEASE_READ_RETRY_%out_ok
+L_RWLOCK_TRY_RELEASE_READ_RETRY_%out_ok:
+    !__rwlock_try_release_read_old_%out_ok
+    !__rwlock_try_release_read_next_%out_ok
+    !__rwlock_try_release_read_has_%out_ok
+    !__rwlock_try_release_read_state_%out_ok
+    jmp L_RWLOCK_TRY_RELEASE_READ_ENTRY_%out_ok
+L_RWLOCK_TRY_RELEASE_READ_EMPTY_%out_ok:
+    %out_ok = add 0, 0
+L_RWLOCK_TRY_RELEASE_READ_DONE_%out_ok:
+    !__rwlock_try_release_read_old_%out_ok
+    !__rwlock_try_release_read_next_%out_ok
+    !__rwlock_try_release_read_has_%out_ok
+    !__rwlock_try_release_read_state_%out_ok
+[END_MACRO]
+[MACRO] RWLOCK_RELEASE_WRITE %lock_reg
+    atomic_store %lock_reg+RwLock_writing, 0 as i32 release
+[END_MACRO]
+
+[MACRO] RWLOCK_TRY_RELEASE_WRITE %out_ok, %lock_reg
+    __rwlock_release_state_%out_ok, %out_ok = cmpxchg %lock_reg+RwLock_writing, 1, 0 as i32 acq_rel acquire
+    !__rwlock_release_state_%out_ok
+[END_MACRO]
+
+[MACRO] RWLOCK_FORCE_UNLOCKED %lock_reg
+    atomic_store %lock_reg+RwLock_readers, 0 as i32 release
+    atomic_store %lock_reg+RwLock_writing, 0 as i32 release
+[END_MACRO]
+
+[MACRO] RWLOCK_DEFAULT %out_lock
+    EXPAND RWLOCK_NEW %out_lock
+[END_MACRO]
+
+
+@__rwlock_lock_read_spin(lock: ptr) -> void:
+L_ENTRY:
+    backoff_slot = stack_alloc 8
+    store backoff_slot+0, 1 as u64
+    jmp L_TRY
+L_TRY:
+    writing = atomic_load lock+RwLock_writing as i32 acquire
+    busy = ne writing, 0
+    !writing
+    br busy -> L_BUSY_WAIT, L_CLAIM
+L_BUSY_WAIT:
+    !busy
+    jmp L_WAIT
+L_CLAIM:
+    !busy
+    old = atomic_rmw_add lock+RwLock_readers, 1 as i32 acq_rel
+    writing2 = atomic_load lock+RwLock_writing as i32 acquire
+    still_busy = ne writing2, 0
+    !writing2
+    !old
+    br still_busy -> L_ROLLBACK, L_DONE
+L_ROLLBACK:
+    rolled = atomic_rmw_sub lock+RwLock_readers, 1 as i32 acq_rel
+    !rolled
+    !still_busy
+    jmp L_WAIT
+L_WAIT:
+    backoff_ns = load backoff_slot+0 as u64
+    call @sa_time_sleep_ns(backoff_ns)
+    at_limit = uge backoff_ns, 1024
+    br at_limit -> L_KEEP, L_GROW
+L_GROW:
+    next = shl backoff_ns, 1
+    store backoff_slot+0, next as u64
+    !next
+    !at_limit
+    !backoff_ns
+    jmp L_TRY
+L_KEEP:
+    !at_limit
+    !backoff_ns
+    jmp L_TRY
+L_DONE:
+    !still_busy
+    !lock
+    return
+
+@__rwlock_lock_write_spin(lock: ptr) -> void:
+L_ENTRY:
+    backoff_slot = stack_alloc 8
+    store backoff_slot+0, 1 as u64
+    jmp L_WTRY
+L_WTRY:
+    old_w, ok = cmpxchg lock+RwLock_writing, 0, 1 as i32 acq_rel acquire
+    br ok -> L_WCHECK, L_WFAIL
+L_WFAIL:
+    !ok
+    !old_w
+    jmp L_WWAIT
+L_WCHECK:
+    !ok
+    !old_w
+    readers = atomic_load lock+RwLock_readers as i32 acquire
+    no_readers = eq readers, 0
+    !readers
+    br no_readers -> L_WDONE, L_WABORT
+L_WABORT:
+    atomic_store lock+RwLock_writing, 0 as i32 release
+    !no_readers
+    jmp L_WWAIT
+L_WWAIT:
+    backoff_ns = load backoff_slot+0 as u64
+    call @sa_time_sleep_ns(backoff_ns)
+    at_limit = uge backoff_ns, 1024
+    br at_limit -> L_WKEEP, L_WGROW
+L_WGROW:
+    next = shl backoff_ns, 1
+    store backoff_slot+0, next as u64
+    !next
+    !at_limit
+    !backoff_ns
+    jmp L_WTRY
+L_WKEEP:
+    !at_limit
+    !backoff_ns
+    jmp L_WTRY
+L_WDONE:
+    !no_readers
+    !lock
+    return
+
+[MACRO] RWLOCK_READ %lock_reg
+    call @__rwlock_lock_read_spin(%lock_reg)
+[END_MACRO]
+
+[MACRO] RWLOCK_WRITE %lock_reg
+    call @__rwlock_lock_write_spin(%lock_reg)
+[END_MACRO]
+
+[MACRO] RWLOCK_LOCK_READ %lock_reg
+    EXPAND RWLOCK_READ %lock_reg
+[END_MACRO]
+
+[MACRO] RWLOCK_LOCK_WRITE %lock_reg
+    EXPAND RWLOCK_WRITE %lock_reg
+[END_MACRO]

package/sa_std/sync/rwlock.sal

@@ -0,0 +1,13 @@
+#def RwLock_SIZE = 8
+#def RwLock_readers = +0
+#def RwLock_writing = +4
+#def RwLock_data = +8
+#def RwLockI32_SIZE = 16
+
+#def RwLockReadGuard_SIZE = 8
+#def RwLockReadGuard_rwlock = +0
+#def RwLockReadGuard_data = +8
+
+#def RwLockWriteGuard_SIZE = 8
+#def RwLockWriteGuard_rwlock = +0
+#def RwLockWriteGuard_data = +8

package/sa_std/task.sa

@@ -0,0 +1,2 @@
+@import "core/task.sal"
+@import "core/task.sa"

package/sa_std/task.sal

@@ -0,0 +1 @@
+@import "core/task.sal"

package/sa_std/term.sa

@@ -0,0 +1,2 @@
+@import "term.sal"
+@import "term.sai"

package/sa_std/term.sai

@@ -0,0 +1,10 @@
+// SA-facing contracts for terminal control and epoll-backed event loops.
+// Raw-mode sessions and epoll instances are opaque owned ptr values and must be closed explicitly.
+@extern sa_term_raw_enter(handle: ptr) -> ^ptr!
+@extern sa_term_raw_leave(^session: ptr) -> i32!
+@extern sa_term_winsize(handle: ptr, &out_size: ptr) -> i32!
+
+@extern sa_term_epoll_create(flags: u32) -> ^ptr!
+@extern sa_term_epoll_ctl(epoll: ptr, op: u32, target: ptr, events: u32, data: u64) -> i32!
+@extern sa_term_epoll_wait(epoll: ptr, &events: ptr, max_events: u64, timeout_ms: i32, &out_count: ptr) -> i32!
+@extern sa_term_epoll_close(^epoll: ptr) -> i32!

package/sa_std/term.sal

@@ -0,0 +1,33 @@
+#def SA_TERM_OK = 0
+#def SA_TERM_ERR_UNKNOWN = 1
+#def SA_TERM_ERR_INVALID_ARGUMENT = 2
+#def SA_TERM_ERR_INVALID_HANDLE = 3
+#def SA_TERM_ERR_UNSUPPORTED = 4
+#def SA_TERM_ERR_NO_MEMORY = 5
+#def SA_TERM_ERR_IO = 6
+
+#def SA_TERM_EPOLL_CTL_ADD = 1
+#def SA_TERM_EPOLL_CTL_DEL = 2
+#def SA_TERM_EPOLL_CTL_MOD = 3
+
+#def SA_TERM_EPOLL_CLOEXEC = 1
+#def SA_TERM_EPOLLIN = 0x001
+#def SA_TERM_EPOLLPRI = 0x002
+#def SA_TERM_EPOLLOUT = 0x004
+#def SA_TERM_EPOLLERR = 0x008
+#def SA_TERM_EPOLLHUP = 0x010
+#def SA_TERM_EPOLLRDHUP = 0x2000
+#def SA_TERM_EPOLLEXCLUSIVE = 0x10000000
+#def SA_TERM_EPOLLWAKEUP = 0x20000000
+#def SA_TERM_EPOLLONESHOT = 0x40000000
+#def SA_TERM_EPOLLET = 0x80000000
+
+#def SaTermWinsize_SIZE = 8
+#def SaTermWinsize_row = +0
+#def SaTermWinsize_col = +2
+#def SaTermWinsize_xpixel = +4
+#def SaTermWinsize_ypixel = +6
+
+#def SaTermEpollEvent_SIZE = 16
+#def SaTermEpollEvent_events = +0
+#def SaTermEpollEvent_data = +8

package/sa_std/testing/assert.sai

@@ -0,0 +1,4 @@
+@extern sa_assert_eq_i64(actual: i64, expected: i64, code: i32) -> void
+@extern sa_assert_eq_i64_at(actual: i64, expected: i64, code: i32, &file: ptr, file_len: u64, line: u32, col: u32) -> void
+@extern sa_test_debug_i64(&name: ptr, name_len: u64, value: i64) -> void
+@extern sa_test_fallible_i32_value(value: i32) -> i32!

package/sa_std/testing/mock_io.sa

@@ -0,0 +1,174 @@
+@import "mock_io.sal"
+
+@export sa_mock_io_init(&mock: ptr, &buf: ptr, cap: u64) -> void:
+L_ENTRY:
+    store mock+MockIo_buf, buf as ptr
+    store mock+MockIo_cap, cap as u64
+    store mock+MockIo_len, 0 as u64
+    store mock+MockIo_pos, 0 as u64
+    !cap
+    !buf
+    !mock
+    return
+
+@export sa_mock_io_rewind(&mock: ptr) -> void:
+L_ENTRY:
+    store mock+MockIo_pos, 0 as u64
+    !mock
+    return
+
+@export sa_mock_io_len(&mock: ptr) -> u64:
+L_ENTRY:
+    len = load mock+MockIo_len as u64
+    !mock
+    return len
+
+@export sa_mock_io_pos(&mock: ptr) -> u64:
+L_ENTRY:
+    pos = load mock+MockIo_pos as u64
+    !mock
+    return pos
+
+@export sa_mock_io_write(&mock: ptr, &src: ptr, requested: u64) -> u64:
+L_ENTRY:
+    cap = load mock+MockIo_cap as u64
+    len = load mock+MockIo_len as u64
+    room = sub cap, len
+    fits = ule requested, room
+    br fits -> L_USE_REQUESTED, L_USE_ROOM
+
+L_USE_REQUESTED:
+    count = add requested, 0
+    jmp L_COPY_INIT
+
+L_USE_ROOM:
+    count = add room, 0
+    jmp L_COPY_INIT
+
+L_COPY_INIT:
+    buf = load mock+MockIo_buf as ptr
+    offset_slot = stack_alloc 8
+    store offset_slot+0, 0 as u64
+    jmp L_COPY_HEAD
+
+L_COPY_HEAD:
+    offset = load offset_slot+0 as u64
+    done = eq offset, count
+    br done -> L_DONE, L_COPY_BODY
+
+L_COPY_BODY:
+    src_ip = ptr_add src, offset
+    dst_offset = add len, offset
+    dst_ip = ptr_add buf, dst_offset
+    byte = load src_ip+0 as u8
+    store dst_ip+0, byte as u8
+    next = add offset, 1
+    store offset_slot+0, next as u64
+    !src_ip
+    !dst_offset
+    !dst_ip
+    !byte
+    !offset
+    !done
+    !next
+    jmp L_COPY_HEAD
+
+L_DONE:
+    new_len = add len, count
+    store mock+MockIo_len, new_len as u64
+    !new_len
+    !offset
+    !done
+    !buf
+    !cap
+    !len
+    !room
+    !fits
+    !requested
+    !src
+    !mock
+    return count
+
+@export sa_mock_io_read(&mock: ptr, &dst: ptr, requested: u64) -> u64:
+L_ENTRY:
+    len = load mock+MockIo_len as u64
+    pos = load mock+MockIo_pos as u64
+    remaining = sub len, pos
+    fits = ule requested, remaining
+    br fits -> L_USE_REQUESTED, L_USE_REMAINING
+
+L_USE_REQUESTED:
+    count = add requested, 0
+    jmp L_COPY_INIT
+
+L_USE_REMAINING:
+    count = add remaining, 0
+    jmp L_COPY_INIT
+
+L_COPY_INIT:
+    buf = load mock+MockIo_buf as ptr
+    offset_slot = stack_alloc 8
+    store offset_slot+0, 0 as u64
+    jmp L_COPY_HEAD
+
+L_COPY_HEAD:
+    offset = load offset_slot+0 as u64
+    done = eq offset, count
+    br done -> L_DONE, L_COPY_BODY
+
+L_COPY_BODY:
+    src_offset = add pos, offset
+    src_ip = ptr_add buf, src_offset
+    dst_ip = ptr_add dst, offset
+    byte = load src_ip+0 as u8
+    store dst_ip+0, byte as u8
+    next = add offset, 1
+    store offset_slot+0, next as u64
+    !src_offset
+    !src_ip
+    !dst_ip
+    !byte
+    !offset
+    !done
+    !next
+    jmp L_COPY_HEAD
+
+L_DONE:
+    new_pos = add pos, count
+    store mock+MockIo_pos, new_pos as u64
+    !new_pos
+    !offset
+    !done
+    !buf
+    !len
+    !pos
+    !remaining
+    !fits
+    !requested
+    !dst
+    !mock
+    return count
+
+[MACRO] MOCK_IO_INIT %mock, %buf, %cap
+    call @sa_mock_io_init(&%mock, &%buf, %cap)
+[END_MACRO]
+
+[MACRO] MOCK_IO_REWIND %mock
+    call @sa_mock_io_rewind(&%mock)
+[END_MACRO]
+
+[MACRO] MOCK_IO_LEN %out_len, %mock
+    %out_len = call @sa_mock_io_len(&%mock)
+[END_MACRO]
+
+[MACRO] MOCK_IO_POS %out_pos, %mock
+    %out_pos = call @sa_mock_io_pos(&%mock)
+[END_MACRO]
+
+[MACRO] MOCK_IO_WRITE %out_count, %mock, %src, %len
+    %out_count = call @sa_mock_io_write(&%mock, &%src, %len)
+[END_MACRO]
+
+[MACRO] MOCK_IO_READ %out_count, %mock, %dst, %len
+    %out_count = call @sa_mock_io_read(&%mock, &%dst, %len)
+[END_MACRO]

package/sa_std/testing/mock_io.sal

@@ -0,0 +1,5 @@
+#def MockIo_SIZE = 32
+#def MockIo_buf = +0
+#def MockIo_cap = +8
+#def MockIo_len = +16
+#def MockIo_pos = +24

package/sa_std/testing/prelude.sa

@@ -0,0 +1,2 @@
+@import "assert.sai"
+@import "mock_io.sa"

package/sa_std/testing/prelude.sal

@@ -0,0 +1 @@
+@import "mock_io.sal"

package/sa_std/text/prelude.sa

@@ -0,0 +1 @@
+@import "regex.sa"

package/sa_std/text/prelude.sal

@@ -0,0 +1 @@
+@import "../core/slice.sal"

package/sa_std/text/regex.sa

@@ -0,0 +1,2 @@
+@import "regex.sal"
+@import "regex.sai"

package/sa_std/text/regex.sai

@@ -0,0 +1,9 @@
+// SA-facing contracts for the Zig-backed sa_std.text.regex module.
+// Regex and regex match handles are opaque owned ptr values.
+@extern sa_regex_compile(&pattern: ptr, pattern_len: u64, cflags: i32) -> ^ptr
+@extern sa_regex_match(regex: ptr, &text: ptr, text_len: u64) -> ^ptr
+@extern sa_regex_group_ptr(match: ptr, group_idx: u32) -> &ptr
+@extern sa_regex_group_len(match: ptr, group_idx: u32) -> u64
+@extern sa_regex_group_count(regex: ptr) -> u64
+@extern sa_regex_free(^regex: ptr) -> i32!
+@extern sa_regex_match_free(^match: ptr) -> i32!

package/sa_std/text/regex.sal

@@ -0,0 +1,33 @@
+#def SA_REGEX_EXTENDED = 1
+#def SA_REGEX_ICASE = 2
+#def SA_REGEX_NEWLINE = 4
+#def SA_REGEX_NOSUB = 8
+#def SA_REGEX_NOTBOL = 1
+#def SA_REGEX_NOTEOL = 2
+#def SA_REGEX_REG_NOERROR = 0
+#def SA_REGEX_REG_OK = 0
+#def SA_REGEX_REG_NOMATCH = 1
+#def SA_REGEX_REG_BADPAT = 2
+#def SA_REGEX_REG_ECOLLATE = 3
+#def SA_REGEX_REG_ECTYPE = 4
+#def SA_REGEX_REG_EESCAPE = 5
+#def SA_REGEX_REG_ESUBREG = 6
+#def SA_REGEX_REG_EBRACK = 7
+#def SA_REGEX_REG_EPAREN = 8
+#def SA_REGEX_REG_EBRACE = 9
+#def SA_REGEX_REG_BADBR = 10
+#def SA_REGEX_REG_ERANGE = 11
+#def SA_REGEX_REG_ESPACE = 12
+#def SA_REGEX_REG_BADRPT = 13
+// SAASM layout constants currently avoid negative literals; keep the signed -1
+// bit pattern so the value still matches the runtime's C ABI error code.
+#def SA_REGEX_REG_ENOSYS = 0xffffffffffffffff
+
+#def SaRegexGroup_SIZE = 16
+#def SaRegexGroup_ptr = +0
+#def SaRegexGroup_len = +8
+
+#def SaRegexMatch_SIZE = 16
+#def SaRegexMatch_matched = +0
+#def SaRegexMatch_group_count = +4
+#def SaRegexMatch_groups = +8

package/sa_std/thread/join_handle.sa

@@ -0,0 +1,3 @@
+// JoinHandle namespace facade.
+@import "../thread.sal"
+@import "../thread.sa"

package/sa_std/thread/join_handle.sal

@@ -0,0 +1 @@
+@import "../thread.sal"